npm-core-sdk/org_pb.ts

// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file org.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 { IDP } from "./idp_pb.js";
import { Module } from "./module_pb.js";
import { RequestOrganisationHeader, WorkflowExecutionResult } from "./shared_pb.js";

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

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

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

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

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

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

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

  /**
   * @generated from enum value: STOPPED = 7;
   */
  STOPPED = 7,

  /**
   * @generated from enum value: STARTING = 8;
   */
  STARTING = 8,

  /**
   * @generated from enum value: STOPPING = 9;
   */
  STOPPING = 9,

  /**
   * @generated from enum value: PARTIALLY_RUNNING = 10;
   */
  PARTIALLY_RUNNING = 10,

  /**
   * @generated from enum value: PARTIALLY_STOPPED = 11;
   */
  PARTIALLY_STOPPED = 11,

  /**
   * @generated from enum value: PAUSING = 12;
   */
  PAUSING = 12,

  /**
   * @generated from enum value: PROVISIONING = 13;
   */
  PROVISIONING = 13,

  /**
   * @generated from enum value: DEPROVISIONING = 14;
   */
  DEPROVISIONING = 14,

  /**
   * @generated from enum value: IN_ERROR = 15;
   */
  IN_ERROR = 15,
}
// Retrieve enum metadata with: proto3.getEnumType(StatusEnum)
proto3.util.setEnumType(StatusEnum, "api.StatusEnum", [
  { no: 0, name: "STATUS_UNDEFINED" },
  { no: 1, name: "CREATED" },
  { no: 2, name: "INITIALIZED" },
  { no: 3, name: "RUNNING" },
  { no: 4, name: "PAUSE" },
  { no: 5, name: "ARCHIVED" },
  { no: 6, name: "DELETED" },
  { no: 7, name: "STOPPED" },
  { no: 8, name: "STARTING" },
  { no: 9, name: "STOPPING" },
  { no: 10, name: "PARTIALLY_RUNNING" },
  { no: 11, name: "PARTIALLY_STOPPED" },
  { no: 12, name: "PAUSING" },
  { no: 13, name: "PROVISIONING" },
  { no: 14, name: "DEPROVISIONING" },
  { no: 15, name: "IN_ERROR" },
]);

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

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

  /**
   * @generated from field: repeated api.IDP IDPs = 3;
   */
  IDPs: IDP[] = [];

  /**
   * @generated from field: api.StatusEnum status = 4;
   */
  status = StatusEnum.STATUS_UNDEFINED;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: api.StatusEnum status = 2;
   */
  status = StatusEnum.STATUS_UNDEFINED;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.UpdateOrganisationStatusResult
 */
export class UpdateOrganisationStatusResult extends Message<UpdateOrganisationStatusResult> {
  /**
   * @generated from field: api.StatusEnum status = 1;
   */
  status = StatusEnum.STATUS_UNDEFINED;

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

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

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

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

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

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

/**
 * @generated from message api.StartStreamingJobsRequest
 */
export class StartStreamingJobsRequest extends Message<StartStreamingJobsRequest> {
  /**
   * @generated from field: string OrgID = 2;
   */
  OrgID = "";

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

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

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

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

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

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

/**
 * @generated from message api.StopStreamingJobsRequest
 */
export class StopStreamingJobsRequest extends Message<StopStreamingJobsRequest> {
  /**
   * @generated from field: string OrgID = 2;
   */
  OrgID = "";

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

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

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

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

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.StartIndividualStreamingJobRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "OrgID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "Domain", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Entity", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "ClassName", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "Arguments", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: bool Force = 4;
   */
  Force = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.StopIndividualStreamingJobRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "OrgID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "Domain", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Entity", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "ClassName", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "Force", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.StopAllStreamingJobsResult
 */
export class StopAllStreamingJobsResult extends Message<StopAllStreamingJobsResult> {
  /**
   * @generated from field: repeated string IDs = 1;
   */
  IDs: string[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.RestartAllStreamingJobsResult
 */
export class RestartAllStreamingJobsResult extends Message<RestartAllStreamingJobsResult> {
  /**
   * @generated from field: repeated string IDs = 1;
   */
  IDs: string[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.StartAllStreamingJobsResult
 */
export class StartAllStreamingJobsResult extends Message<StartAllStreamingJobsResult> {
  /**
   * @generated from field: repeated string IDs = 1;
   */
  IDs: string[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.ForceStopAllStreamingJobsResult
 */
export class ForceStopAllStreamingJobsResult extends Message<ForceStopAllStreamingJobsResult> {
  /**
   * @generated from field: repeated string IDs = 1;
   */
  IDs: string[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.CheckStreamingStatusRequest
 */
export class CheckStreamingStatusRequest extends Message<CheckStreamingStatusRequest> {
  /**
   * @generated from field: string OrgID = 4;
   */
  OrgID = "";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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