// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file proj.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 { Module } from "./module_pb.js";
import { ModelDataSetEnum, RecoverType, RequestOrganisationHeader, RequestProjectHeader, WorkflowExecutionResult } from "./shared_pb.js";
import { Paging } from "./base_pb.js";
import { Organisation } from "./org_pb.js";
import { User } from "./user_pb.js";

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

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

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

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

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

  /**
   * @generated from enum value: PROJECT_STATUS_ERROR = 5;
   */
  PROJECT_STATUS_ERROR = 5,
}
// Retrieve enum metadata with: proto3.getEnumType(ProjectStatusEnum)
proto3.util.setEnumType(ProjectStatusEnum, "api.ProjectStatusEnum", [
  { no: 0, name: "PROJECT_STATUS_UNKNOWN" },
  { no: 1, name: "PROJECT_STATUS_PROVISIONNING" },
  { no: 2, name: "PROJECT_STATUS_READY" },
  { no: 3, name: "PROJECT_STATUS_DEPROVISIONNING" },
  { no: 4, name: "PROJECT_STATUS_DEPROVISIONNED" },
  { no: 5, name: "PROJECT_STATUS_ERROR" },
]);

/**
 * Project creation should not have status in request
 *
 * @generated from message api.ProjectCreation
 */
export class ProjectCreation extends Message<ProjectCreation> {
  /**
   * @generated from field: string ID = 1;
   */
  ID = "";

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

  /**
   * @generated from field: repeated api.Module Modules = 3;
   */
  Modules: Module[] = [];

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: api.ProjectStatusEnum status = 4;
   */
  status = ProjectStatusEnum.PROJECT_STATUS_UNKNOWN;

  /**
   * @generated from field: repeated api.Module Modules = 5;
   */
  Modules: Module[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.Project";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "OrganisationID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "status", kind: "enum", T: proto3.getEnumType(ProjectStatusEnum) },
    { no: 5, name: "Modules", kind: "message", T: Module, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message api.DeleteProjectRequest
 */
export class DeleteProjectRequest extends Message<DeleteProjectRequest> {
  /**
   * @generated from field: api.RequestOrganisationHeader Header = 3;
   */
  Header?: RequestOrganisationHeader;

  /**
   * @generated from field: string ID = 1;
   */
  ID = "";

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

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

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

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

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

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

/**
 * @generated from message api.GetProjectRequest
 */
export class GetProjectRequest extends Message<GetProjectRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 4;
   */
  Header?: RequestProjectHeader;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetProjectRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 4, name: "Header", kind: "message", T: RequestProjectHeader },
  ]);

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

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

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

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

/**
 * @generated from message api.ListProjectRequest
 */
export class ListProjectRequest extends Message<ListProjectRequest> {
  /**
   * @generated from field: api.RequestOrganisationHeader Header = 4;
   */
  Header?: RequestOrganisationHeader;

  /**
   * @generated from field: api.Paging Paging = 3;
   */
  Paging?: Paging;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ListProjectRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 4, name: "Header", kind: "message", T: RequestOrganisationHeader },
    { no: 3, name: "Paging", kind: "message", T: Paging },
    { no: 5, name: "ShowInactiveProjects", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: repeated api.User Managers = 3;
   */
  Managers: User[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ListAllProjectResultElement";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Organisation", kind: "message", T: Organisation },
    { no: 2, name: "Projects", kind: "message", T: Project, repeated: true },
    { no: 3, name: "Managers", kind: "message", T: User, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message api.ListAllProjectResult
 */
export class ListAllProjectResult extends Message<ListAllProjectResult> {
  /**
   * @generated from field: repeated api.ListAllProjectResultElement Organisations = 1;
   */
  Organisations: ListAllProjectResultElement[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ListAllProjectResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Organisations", kind: "message", T: ListAllProjectResultElement, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message api.CreateProjectRequest
 */
export class CreateProjectRequest extends Message<CreateProjectRequest> {
  /**
   * @generated from field: api.RequestOrganisationHeader Header = 2;
   */
  Header?: RequestOrganisationHeader;

  /**
   * @generated from field: api.ProjectCreation Project = 1;
   */
  Project?: ProjectCreation;

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

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

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

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

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

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

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

/**
 * @generated from message api.UpdateProjectRequest
 */
export class UpdateProjectRequest extends Message<UpdateProjectRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 2;
   */
  Header?: RequestProjectHeader;

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: repeated api.Module Modules = 3;
   */
  Modules: Module[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.SetModulesProjectRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestOrganisationHeader },
    { no: 2, name: "ProjectID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Modules", kind: "message", T: Module, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message api.CreateProjectResult
 */
export class CreateProjectResult extends Message<CreateProjectResult> {
  /**
   * @generated from field: api.Project Result = 1;
   */
  Result?: Project;

  /**
   * @generated from field: api.WorkflowExecutionResult WorkflowExecution = 2;
   */
  WorkflowExecution?: WorkflowExecutionResult;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.CreateProjectResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Result", kind: "message", T: Project },
    { no: 2, name: "WorkflowExecution", kind: "message", T: WorkflowExecutionResult },
  ]);

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

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

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

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

/**
 * @generated from message api.UpdateProjectResult
 */
export class UpdateProjectResult extends Message<UpdateProjectResult> {
  /**
   * @generated from field: api.Project Result = 1;
   */
  Result?: Project;

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

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

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

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

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

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

/**
 * @generated from message api.DeleteProjectResult
 */
export class DeleteProjectResult extends Message<DeleteProjectResult> {
  /**
   * @generated from field: api.WorkflowExecutionResult WorkflowExecution = 1;
   */
  WorkflowExecution?: WorkflowExecutionResult;

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

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

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

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

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

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

/**
 * @generated from message api.GetProjectResult
 */
export class GetProjectResult extends Message<GetProjectResult> {
  /**
   * @generated from field: api.Project Result = 1;
   */
  Result?: Project;

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

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

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

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

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

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

/**
 * @generated from message api.ListProjectResult
 */
export class ListProjectResult extends Message<ListProjectResult> {
  /**
   * @generated from field: repeated api.Project Result = 1;
   */
  Result: Project[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ListProjectResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Result", kind: "message", T: Project, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message api.SetModulesProjectResult
 */
export class SetModulesProjectResult extends Message<SetModulesProjectResult> {
  /**
   * @generated from field: api.Project Result = 1;
   */
  Result?: Project;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: bool Final = 2;
   */
  Final = false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.SuggestProjectIDRequest
 */
export class SuggestProjectIDRequest extends Message<SuggestProjectIDRequest> {
  /**
   * @generated from field: api.RequestOrganisationHeader Header = 3;
   */
  Header?: RequestOrganisationHeader;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: api.ModelDataSetEnum Entity = 2;
   */
  Entity = ModelDataSetEnum.ACTOR;

  /**
   * @generated from field: api.RecoverType RecoveryType = 3;
   */
  RecoveryType = RecoverType.RECOVER_OPENSEARCH;

  /**
   * @generated from field: int32 PartitionStart = 4;
   */
  PartitionStart = 0;

  /**
   * @generated from field: int32 PartitionEnd = 5;
   */
  PartitionEnd = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.StartRecoverDataStreamingJobRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ProjectID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Entity", kind: "enum", T: proto3.getEnumType(ModelDataSetEnum) },
    { no: 3, name: "RecoveryType", kind: "enum", T: proto3.getEnumType(RecoverType) },
    { no: 4, name: "PartitionStart", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 5, name: "PartitionEnd", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: bool IsDisplayed = 3;
   */
  IsDisplayed = false;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.IDName";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "IsDisplayed", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 4, name: "PartnerID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message api.MyContext
 */
export class MyContext extends Message<MyContext> {
  /**
   * @generated from field: api.IDName Organisation = 1;
   */
  Organisation?: IDName;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.MyContext";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Organisation", kind: "message", T: IDName },
    { no: 2, name: "Projects", kind: "message", T: IDName, repeated: true },
  ]);

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.GetMyUIContextResult
 */
export class GetMyUIContextResult extends Message<GetMyUIContextResult> {
  /**
   * @generated from field: repeated api.MyContext MyContexts = 1;
   */
  MyContexts: MyContext[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetMyUIContextResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "MyContexts", kind: "message", T: MyContext, repeated: true },
  ]);

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.GetMyContextResult
 */
export class GetMyContextResult extends Message<GetMyContextResult> {
  /**
   * @generated from field: repeated api.MyContext MyContexts = 1;
   */
  MyContexts: MyContext[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetMyContextResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "MyContexts", kind: "message", T: MyContext, repeated: true },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.ProjectStatusEnum status = 2;
   */
  status = ProjectStatusEnum.PROJECT_STATUS_UNKNOWN;

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

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

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

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

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

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

/**
 * @generated from message api.UpdateProjectStatusResult
 */
export class UpdateProjectStatusResult extends Message<UpdateProjectStatusResult> {
  /**
   * @generated from field: api.ProjectStatusEnum status = 1;
   */
  status = ProjectStatusEnum.PROJECT_STATUS_UNKNOWN;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.UpdateProjectStatusResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "status", kind: "enum", T: proto3.getEnumType(ProjectStatusEnum) },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

