// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file workflow.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 { BlockFilter, ExtractColumnFormat, ModelDataSetEnum, ModuleDeregistration, ModuleRegistration, ModuleWorkflowTypeEnum, RecoverType, TranslationMap, WorkflowExecutionResult, WorkflowTypeEnum } from "./shared_pb.js";
import { Module } from "./module_pb.js";
import { CHDimension, CHFilter, CHMetric, CHQueryType, EntityBlockFilter } from "./clickhouse_pb.js";

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

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

  /**
   * @generated from enum value: WORKFLOW_STATUS_SUCCESS = 2;
   */
  WORKFLOW_STATUS_SUCCESS = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(WorkflowStatusEnum)
proto3.util.setEnumType(WorkflowStatusEnum, "api.WorkflowStatusEnum", [
  { no: 0, name: "WORKFLOW_STATUS_UNKNOWN" },
  { no: 1, name: "WORKFLOW_STATUS_FAILED" },
  { no: 2, name: "WORKFLOW_STATUS_SUCCESS" },
]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: repeated api.BlockFilter BlockFilters = 3;
   */
  BlockFilters: BlockFilter[] = [];

  /**
   * @generated from field: string TargetDomain = 9;
   */
  TargetDomain = "";

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

  /**
   * @generated from field: repeated string Fields = 5;
   */
  Fields: string[] = [];

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

  /**
   * @generated from field: string DecimalSeparator = 7;
   */
  DecimalSeparator = "";

  /**
   * @generated from field: repeated string ColumnNames = 8;
   */
  ColumnNames: string[] = [];

  /**
   * @generated from field: map<string, api.TranslationMap> ColumnTranslationMaps = 10;
   */
  ColumnTranslationMaps: { [key: string]: TranslationMap } = {};

  /**
   * @generated from field: map<int32, api.ExtractColumnFormat> ColumnFormats = 11;
   */
  ColumnFormats: { [key: number]: ExtractColumnFormat } = {};

  /**
   * @generated from field: string TargetTimeZone = 12;
   */
  TargetTimeZone = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.StartWorkflowExtractDataFromDBRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "UserId", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "ProjectId", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "BlockFilters", kind: "message", T: BlockFilter, repeated: true },
    { no: 9, name: "TargetDomain", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "TargetType", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "Fields", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 6, name: "ListSeparator", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "DecimalSeparator", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "ColumnNames", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 10, name: "ColumnTranslationMaps", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: TranslationMap} },
    { no: 11, name: "ColumnFormats", kind: "map", K: 5 /* ScalarType.INT32 */, V: {kind: "message", T: ExtractColumnFormat} },
    { no: 12, name: "TargetTimeZone", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: api.CHQueryType QueryType = 3;
   */
  QueryType = CHQueryType.CH_QUERY_TYPE_UNKNOWN;

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

  /**
   * @generated from field: repeated api.EntityBlockFilter EntityBlockFilters = 5;
   */
  EntityBlockFilters: EntityBlockFilter[] = [];

  /**
   * @generated from field: api.CHFilter Filter = 6;
   */
  Filter?: CHFilter;

  /**
   * @generated from field: repeated api.CHDimension Dimensions = 7;
   */
  Dimensions: CHDimension[] = [];

  /**
   * @generated from field: repeated api.CHMetric Metrics = 8;
   */
  Metrics: CHMetric[] = [];

  /**
   * @generated from field: string TargetTimeZone = 9;
   */
  TargetTimeZone = "";

  /**
   * @generated from field: string KpiGroupName = 10;
   */
  KpiGroupName = "";

  /**
   * @generated from field: string TargetDomain = 11;
   */
  TargetDomain = "";

  /**
   * @generated from field: string TargetType = 12;
   */
  TargetType = "";

  /**
   * @generated from field: repeated string Fields = 13;
   */
  Fields: string[] = [];

  /**
   * @generated from field: string ListSeparator = 14;
   */
  ListSeparator = "";

  /**
   * @generated from field: string DecimalSeparator = 15;
   */
  DecimalSeparator = "";

  /**
   * @generated from field: repeated string ColumnNames = 16;
   */
  ColumnNames: string[] = [];

  /**
   * @generated from field: map<string, api.TranslationMap> ColumnTranslationMaps = 17;
   */
  ColumnTranslationMaps: { [key: string]: TranslationMap } = {};

  /**
   * @generated from field: repeated int32 FieldIdxLVDetailedQuantity = 18;
   */
  FieldIdxLVDetailedQuantity: number[] = [];

  /**
   * @generated from field: map<int32, api.ExtractColumnFormat> ColumnFormats = 19;
   */
  ColumnFormats: { [key: number]: ExtractColumnFormat } = {};

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.StartWorkflowExtractKPIRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ProjectId", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "UserId", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "QueryType", kind: "enum", T: proto3.getEnumType(CHQueryType) },
    { no: 4, name: "QueryBlock", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "EntityBlockFilters", kind: "message", T: EntityBlockFilter, repeated: true },
    { no: 6, name: "Filter", kind: "message", T: CHFilter },
    { no: 7, name: "Dimensions", kind: "message", T: CHDimension, repeated: true },
    { no: 8, name: "Metrics", kind: "message", T: CHMetric, repeated: true },
    { no: 9, name: "TargetTimeZone", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 10, name: "KpiGroupName", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 11, name: "TargetDomain", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 12, name: "TargetType", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 13, name: "Fields", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 14, name: "ListSeparator", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 15, name: "DecimalSeparator", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 16, name: "ColumnNames", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 17, name: "ColumnTranslationMaps", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: TranslationMap} },
    { no: 18, name: "FieldIdxLVDetailedQuantity", kind: "scalar", T: 5 /* ScalarType.INT32 */, repeated: true },
    { no: 19, name: "ColumnFormats", kind: "map", K: 5 /* ScalarType.INT32 */, V: {kind: "message", T: ExtractColumnFormat} },
  ]);

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.RegisterModuleWorkflowsRequest
 */
export class RegisterModuleWorkflowsRequest extends Message<RegisterModuleWorkflowsRequest> {
  /**
   * @generated from field: repeated api.ModuleRegistration ModuleRegistrations = 1;
   */
  ModuleRegistrations: ModuleRegistration[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.DeregisterModuleWorkflowsRequest
 */
export class DeregisterModuleWorkflowsRequest extends Message<DeregisterModuleWorkflowsRequest> {
  /**
   * @generated from field: repeated api.ModuleDeregistration ModuleDeregistrations = 1;
   */
  ModuleDeregistrations: ModuleDeregistration[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.ModuleWorkflow
 */
export class ModuleWorkflow extends Message<ModuleWorkflow> {
  /**
   * @generated from field: api.WorkflowTypeEnum WorkflowTarget = 1;
   */
  WorkflowTarget = WorkflowTypeEnum.CREATE_PROJECT;

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

  /**
   * @generated from field: api.ModuleWorkflowTypeEnum Type = 3;
   */
  Type = ModuleWorkflowTypeEnum.PRE_WORKFLOW;

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ModuleWorkflow";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "WorkflowTarget", kind: "enum", T: proto3.getEnumType(WorkflowTypeEnum) },
    { no: 2, name: "WorkflowPath", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Type", kind: "enum", T: proto3.getEnumType(ModuleWorkflowTypeEnum) },
    { no: 4, name: "Timeout", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 5, name: "Tasklist", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message api.GetModuleWorkflowsRequest
 */
export class GetModuleWorkflowsRequest extends Message<GetModuleWorkflowsRequest> {
  /**
   * @generated from field: api.WorkflowTypeEnum WorkflowTarget = 1;
   */
  WorkflowTarget = WorkflowTypeEnum.CREATE_PROJECT;

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

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

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

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

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

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

/**
 * @generated from message api.GetModuleWorkflowsResult
 */
export class GetModuleWorkflowsResult extends Message<GetModuleWorkflowsResult> {
  /**
   * @generated from field: repeated api.ModuleWorkflow ModuleWorkflows = 1;
   */
  ModuleWorkflows: ModuleWorkflow[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.StartWorkflowRecoverDataRequest
 */
export class StartWorkflowRecoverDataRequest extends Message<StartWorkflowRecoverDataRequest> {
  /**
   * @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: bool ClearEntityData = 4;
   */
  ClearEntityData = false;

  /**
   * @generated from field: bool RestartJob = 6;
   */
  RestartJob = false;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.StartWorkflowRecoverDataRequest";
  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: "ClearEntityData", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 6, name: "RestartJob", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 7, name: "OrganisationID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.StartWorkflowCheckAndLaunchRecoverDataRequest
 */
export class StartWorkflowCheckAndLaunchRecoverDataRequest extends Message<StartWorkflowCheckAndLaunchRecoverDataRequest> {
  /**
   * @generated from field: api.ModelDataSetEnum Entity = 1;
   */
  Entity = ModelDataSetEnum.ACTOR;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.StartWorkflowCheckAndLaunchRecoverDataRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Entity", kind: "enum", T: proto3.getEnumType(ModelDataSetEnum) },
    { no: 2, name: "RecoveryType", kind: "enum", T: proto3.getEnumType(RecoverType) },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

