@norskvideo/norsk-api 1.0.345 → 1.0.347

package/lib/manager_pb.ts

@@ -5,7 +5,65 @@
 
 import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
 import { Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf";
-import { Log, Version } from "./shared/common_pb.js";
+import { ActiveJobKey, JobId, JobInfoMessage, Log, NodeId, NodeMetadata, ResolvedPortMappings, RunningNodeMetadata, Service, ServiceParameters, Version as Version$1 } from "./shared/common_pb.js";
+
+/**
+ * @generated from enum norsk.api.manager.Version
+ */
+export enum Version {
+  /**
+   * @generated from enum value: RECOMMENDED = 0;
+   */
+  RECOMMENDED = 0,
+
+  /**
+   * @generated from enum value: LATEST = 1;
+   */
+  LATEST = 1,
+
+  /**
+   * @generated from enum value: PREVIOUS_RECOMMENDED = 2;
+   */
+  PREVIOUS_RECOMMENDED = 2,
+
+  /**
+   * @generated from enum value: LTS = 3;
+   */
+  LTS = 3,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Version)
+proto3.util.setEnumType(Version, "norsk.api.manager.Version", [
+  { no: 0, name: "RECOMMENDED" },
+  { no: 1, name: "LATEST" },
+  { no: 2, name: "PREVIOUS_RECOMMENDED" },
+  { no: 3, name: "LTS" },
+]);
+
+/**
+ * @generated from enum norsk.api.manager.Health
+ */
+export enum Health {
+  /**
+   * @generated from enum value: HEALTHY = 0;
+   */
+  HEALTHY = 0,
+
+  /**
+   * @generated from enum value: UNSTABLE = 1;
+   */
+  UNSTABLE = 1,
+
+  /**
+   * @generated from enum value: FAILED = 2;
+   */
+  FAILED = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Health)
+proto3.util.setEnumType(Health, "norsk.api.manager.Health", [
+  { no: 0, name: "HEALTHY" },
+  { no: 1, name: "UNSTABLE" },
+  { no: 2, name: "FAILED" },
+]);
 
 /**
  *  `Hello` is sent to the client at the start of a status channel, and gives
@@ -19,7 +77,7 @@ export class Hello extends Message<Hello> {
    *
    * @generated from field: norsk.api.common.Version version = 1;
    */
-  version?: Version;
+  version?: Version$1;
 
   constructor(data?: PartialMessage<Hello>) {
     super();
@@ -29,7 +87,7 @@ export class Hello extends Message<Hello> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.manager.Hello";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "version", kind: "message", T: Version },
+    { no: 1, name: "version", kind: "message", T: Version$1 },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Hello {
@@ -50,963 +108,972 @@ export class Hello extends Message<Hello> {
 }
 
 /**
- * @generated from message norsk.api.manager.AwsS3Location
+ * @generated from message norsk.api.manager.Job
  */
-export class AwsS3Location extends Message<AwsS3Location> {
+export class Job extends Message<Job> {
   /**
-   * @generated from field: string url = 1;
+   * @generated from field: norsk.api.common.JobId job_id = 1;
    */
-  url = "";
+  jobId?: JobId;
 
-  constructor(data?: PartialMessage<AwsS3Location>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
+  /**
+   * @generated from field: string description = 2;
+   */
+  description = "";
 
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.AwsS3Location";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-  ]);
+  /**
+   * @generated from field: map<string, string> tags = 3;
+   */
+  tags: { [key: string]: string } = {};
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsS3Location {
-    return new AwsS3Location().fromBinary(bytes, options);
-  }
+  /**
+   * @generated from field: google.protobuf.Timestamp start_date_time = 4;
+   */
+  startDateTime?: Timestamp;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsS3Location {
-    return new AwsS3Location().fromJson(jsonValue, options);
-  }
+  /**
+   * @generated from field: int64 current_hash = 5;
+   */
+  currentHash = protoInt64.zero;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsS3Location {
-    return new AwsS3Location().fromJsonString(jsonString, options);
-  }
+  /**
+   * @generated from field: string manager_configuration = 6;
+   */
+  managerConfiguration = "";
 
-  static equals(a: AwsS3Location | PlainMessage<AwsS3Location> | undefined, b: AwsS3Location | PlainMessage<AwsS3Location> | undefined): boolean {
-    return proto3.util.equals(AwsS3Location, a, b);
-  }
-}
+  /**
+   * @generated from field: repeated norsk.api.common.Service services = 7;
+   */
+  services: Service[] = [];
 
-/**
- * @generated from message norsk.api.manager.PublicHttpLocation
- */
-export class PublicHttpLocation extends Message<PublicHttpLocation> {
   /**
-   * @generated from field: string url = 1;
+   * @generated from field: norsk.api.manager.Version norsk_media_version = 8;
    */
-  url = "";
+  norskMediaVersion = Version.RECOMMENDED;
 
-  constructor(data?: PartialMessage<PublicHttpLocation>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
+  /**
+   * @generated from field: norsk.api.common.ServiceParameters norsk_service_parameters = 9;
+   */
+  norskServiceParameters?: ServiceParameters;
 
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.PublicHttpLocation";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-  ]);
+  /**
+   * @generated from field: repeated string volumes = 10;
+   */
+  volumes: string[] = [];
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublicHttpLocation {
-    return new PublicHttpLocation().fromBinary(bytes, options);
-  }
+  /**
+   * @generated from field: norsk.api.manager.Job.JobState state = 11;
+   */
+  state = Job_JobState.PRE;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublicHttpLocation {
-    return new PublicHttpLocation().fromJson(jsonValue, options);
-  }
+  /**
+   * @generated from field: string shape = 12;
+   */
+  shape = "";
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublicHttpLocation {
-    return new PublicHttpLocation().fromJsonString(jsonString, options);
-  }
+  /**
+   * @generated from field: string architecture = 13;
+   */
+  architecture = "";
 
-  static equals(a: PublicHttpLocation | PlainMessage<PublicHttpLocation> | undefined, b: PublicHttpLocation | PlainMessage<PublicHttpLocation> | undefined): boolean {
-    return proto3.util.equals(PublicHttpLocation, a, b);
-  }
-}
+  /**
+   * @generated from field: string subnet = 14;
+   */
+  subnet = "";
 
-/**
- * @generated from message norsk.api.manager.CustomLocation
- */
-export class CustomLocation extends Message<CustomLocation> {
   /**
-   * @generated from oneof norsk.api.manager.CustomLocation.script
+   * @generated from field: string availabilityDomain = 15;
    */
-  script: {
-    /**
-     * @generated from field: norsk.api.manager.AwsS3Location aws_s3_location = 1;
-     */
-    value: AwsS3Location;
-    case: "awsS3Location";
-  } | {
-    /**
-     * @generated from field: norsk.api.manager.PublicHttpLocation http_location = 2;
-     */
-    value: PublicHttpLocation;
-    case: "httpLocation";
-  } | { case: undefined; value?: undefined } = { case: undefined };
+  availabilityDomain = "";
 
-  constructor(data?: PartialMessage<CustomLocation>) {
+  constructor(data?: PartialMessage<Job>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.CustomLocation";
+  static readonly typeName = "norsk.api.manager.Job";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "aws_s3_location", kind: "message", T: AwsS3Location, oneof: "script" },
-    { no: 2, name: "http_location", kind: "message", T: PublicHttpLocation, oneof: "script" },
+    { no: 1, name: "job_id", kind: "message", T: JobId },
+    { no: 2, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "tags", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
+    { no: 4, name: "start_date_time", kind: "message", T: Timestamp },
+    { no: 5, name: "current_hash", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+    { no: 6, name: "manager_configuration", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 7, name: "services", kind: "message", T: Service, repeated: true },
+    { no: 8, name: "norsk_media_version", kind: "enum", T: proto3.getEnumType(Version) },
+    { no: 9, name: "norsk_service_parameters", kind: "message", T: ServiceParameters },
+    { no: 10, name: "volumes", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    { no: 11, name: "state", kind: "enum", T: proto3.getEnumType(Job_JobState) },
+    { no: 12, name: "shape", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 13, name: "architecture", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 14, name: "subnet", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 15, name: "availabilityDomain", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CustomLocation {
-    return new CustomLocation().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Job {
+    return new Job().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CustomLocation {
-    return new CustomLocation().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Job {
+    return new Job().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CustomLocation {
-    return new CustomLocation().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Job {
+    return new Job().fromJsonString(jsonString, options);
   }
 
-  static equals(a: CustomLocation | PlainMessage<CustomLocation> | undefined, b: CustomLocation | PlainMessage<CustomLocation> | undefined): boolean {
-    return proto3.util.equals(CustomLocation, a, b);
+  static equals(a: Job | PlainMessage<Job> | undefined, b: Job | PlainMessage<Job> | undefined): boolean {
+    return proto3.util.equals(Job, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.Location
+ * @generated from enum norsk.api.manager.Job.JobState
  */
-export class Location extends Message<Location> {
+export enum Job_JobState {
   /**
-   * @generated from oneof norsk.api.manager.Location.location
+   * @generated from enum value: PRE = 0;
    */
-  location: {
-    /**
-     * @generated from field: norsk.api.manager.AwsS3Location aws_s3_location = 1;
-     */
-    value: AwsS3Location;
-    case: "awsS3Location";
-  } | {
-    /**
-     * @generated from field: norsk.api.manager.PublicHttpLocation http_location = 2;
-     */
-    value: PublicHttpLocation;
-    case: "httpLocation";
-  } | {
-    /**
-     * @generated from field: norsk.api.manager.CustomLocation custom_location = 3;
-     */
-    value: CustomLocation;
-    case: "customLocation";
-  } | { case: undefined; value?: undefined } = { case: undefined };
+  PRE = 0,
+
+  /**
+   * @generated from enum value: ACTIVE = 1;
+   */
+  ACTIVE = 1,
+
+  /**
+   * @generated from enum value: POST = 2;
+   */
+  POST = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Job_JobState)
+proto3.util.setEnumType(Job_JobState, "norsk.api.manager.Job.JobState", [
+  { no: 0, name: "PRE" },
+  { no: 1, name: "ACTIVE" },
+  { no: 2, name: "POST" },
+]);
+
+/**
+ * @generated from message norsk.api.manager.JobHash
+ */
+export class JobHash extends Message<JobHash> {
+  /**
+   * @generated from field: int64 hash = 1;
+   */
+  hash = protoInt64.zero;
 
-  constructor(data?: PartialMessage<Location>) {
+  constructor(data?: PartialMessage<JobHash>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.Location";
+  static readonly typeName = "norsk.api.manager.JobHash";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "aws_s3_location", kind: "message", T: AwsS3Location, oneof: "location" },
-    { no: 2, name: "http_location", kind: "message", T: PublicHttpLocation, oneof: "location" },
-    { no: 3, name: "custom_location", kind: "message", T: CustomLocation, oneof: "location" },
+    { no: 1, name: "hash", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Location {
-    return new Location().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobHash {
+    return new JobHash().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Location {
-    return new Location().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobHash {
+    return new JobHash().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Location {
-    return new Location().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobHash {
+    return new JobHash().fromJsonString(jsonString, options);
   }
 
-  static equals(a: Location | PlainMessage<Location> | undefined, b: Location | PlainMessage<Location> | undefined): boolean {
-    return proto3.util.equals(Location, a, b);
+  static equals(a: JobHash | PlainMessage<JobHash> | undefined, b: JobHash | PlainMessage<JobHash> | undefined): boolean {
+    return proto3.util.equals(JobHash, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.DockerContainer
+ * @generated from message norsk.api.manager.JobHistoryJobCreated
  */
-export class DockerContainer extends Message<DockerContainer> {
+export class JobHistoryJobCreated extends Message<JobHistoryJobCreated> {
   /**
-   * @generated from field: norsk.api.manager.Location location = 1;
+   * @generated from field: google.protobuf.Timestamp timestamp = 1;
    */
-  location?: Location;
+  timestamp?: Timestamp;
 
-  constructor(data?: PartialMessage<DockerContainer>) {
+  constructor(data?: PartialMessage<JobHistoryJobCreated>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.DockerContainer";
+  static readonly typeName = "norsk.api.manager.JobHistoryJobCreated";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "location", kind: "message", T: Location },
+    { no: 1, name: "timestamp", kind: "message", T: Timestamp },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DockerContainer {
-    return new DockerContainer().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobHistoryJobCreated {
+    return new JobHistoryJobCreated().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DockerContainer {
-    return new DockerContainer().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobHistoryJobCreated {
+    return new JobHistoryJobCreated().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DockerContainer {
-    return new DockerContainer().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobHistoryJobCreated {
+    return new JobHistoryJobCreated().fromJsonString(jsonString, options);
   }
 
-  static equals(a: DockerContainer | PlainMessage<DockerContainer> | undefined, b: DockerContainer | PlainMessage<DockerContainer> | undefined): boolean {
-    return proto3.util.equals(DockerContainer, a, b);
+  static equals(a: JobHistoryJobCreated | PlainMessage<JobHistoryJobCreated> | undefined, b: JobHistoryJobCreated | PlainMessage<JobHistoryJobCreated> | undefined): boolean {
+    return proto3.util.equals(JobHistoryJobCreated, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.NpmPackage
+ * @generated from message norsk.api.manager.JobHistoryJobUpdated
  */
-export class NpmPackage extends Message<NpmPackage> {
+export class JobHistoryJobUpdated extends Message<JobHistoryJobUpdated> {
+  /**
+   * @generated from field: google.protobuf.Timestamp timestamp = 1;
+   */
+  timestamp?: Timestamp;
+
   /**
-   * @generated from field: norsk.api.manager.Location location = 1;
+   * @generated from field: norsk.api.manager.Job previous_job = 2;
    */
-  location?: Location;
+  previousJob?: Job;
 
-  constructor(data?: PartialMessage<NpmPackage>) {
+  constructor(data?: PartialMessage<JobHistoryJobUpdated>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.NpmPackage";
+  static readonly typeName = "norsk.api.manager.JobHistoryJobUpdated";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "location", kind: "message", T: Location },
+    { no: 1, name: "timestamp", kind: "message", T: Timestamp },
+    { no: 2, name: "previous_job", kind: "message", T: Job },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NpmPackage {
-    return new NpmPackage().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobHistoryJobUpdated {
+    return new JobHistoryJobUpdated().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NpmPackage {
-    return new NpmPackage().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobHistoryJobUpdated {
+    return new JobHistoryJobUpdated().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NpmPackage {
-    return new NpmPackage().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobHistoryJobUpdated {
+    return new JobHistoryJobUpdated().fromJsonString(jsonString, options);
   }
 
-  static equals(a: NpmPackage | PlainMessage<NpmPackage> | undefined, b: NpmPackage | PlainMessage<NpmPackage> | undefined): boolean {
-    return proto3.util.equals(NpmPackage, a, b);
+  static equals(a: JobHistoryJobUpdated | PlainMessage<JobHistoryJobUpdated> | undefined, b: JobHistoryJobUpdated | PlainMessage<JobHistoryJobUpdated> | undefined): boolean {
+    return proto3.util.equals(JobHistoryJobUpdated, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.Job
+ * @generated from message norsk.api.manager.JobHistoryJobProvisioned
  */
-export class Job extends Message<Job> {
-  /**
-   * @generated from field: string id = 1;
-   */
-  id = "";
-
-  /**
-   * @generated from field: string description = 2;
-   */
-  description = "";
-
-  /**
-   * @generated from field: map<string, string> tags = 3;
-   */
-  tags: { [key: string]: string } = {};
-
-  /**
-   * @generated from field: google.protobuf.Timestamp start_date_time = 4;
-   */
-  startDateTime?: Timestamp;
-
-  /**
-   * @generated from field: google.protobuf.Timestamp end_date_time = 5;
-   */
-  endDateTime?: Timestamp;
-
-  /**
-   * @generated from field: int64 current_hash = 6;
-   */
-  currentHash = protoInt64.zero;
-
-  /**
-   * @generated from field: string media_configuration = 7;
-   */
-  mediaConfiguration = "";
-
+export class JobHistoryJobProvisioned extends Message<JobHistoryJobProvisioned> {
   /**
-   * @generated from field: string manager_configuration = 8;
+   * @generated from field: google.protobuf.Timestamp timestamp = 1;
    */
-  managerConfiguration = "";
+  timestamp?: Timestamp;
 
   /**
-   * @generated from field: string norsk_media_version = 9;
+   * @generated from field: string role = 2;
    */
-  norskMediaVersion = "";
+  role = "";
 
   /**
-   * @generated from oneof norsk.api.manager.Job.client_code
+   * @generated from field: norsk.api.common.NodeMetadata nodeMetadata = 3;
    */
-  clientCode: {
-    /**
-     * @generated from field: norsk.api.manager.DockerContainer docker = 10;
-     */
-    value: DockerContainer;
-    case: "docker";
-  } | {
-    /**
-     * @generated from field: norsk.api.manager.NpmPackage npm = 11;
-     */
-    value: NpmPackage;
-    case: "npm";
-  } | { case: undefined; value?: undefined } = { case: undefined };
+  nodeMetadata?: NodeMetadata;
 
-  constructor(data?: PartialMessage<Job>) {
+  constructor(data?: PartialMessage<JobHistoryJobProvisioned>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.Job";
+  static readonly typeName = "norsk.api.manager.JobHistoryJobProvisioned";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: "tags", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
-    { no: 4, name: "start_date_time", kind: "message", T: Timestamp },
-    { no: 5, name: "end_date_time", kind: "message", T: Timestamp },
-    { no: 6, name: "current_hash", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
-    { no: 7, name: "media_configuration", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 8, name: "manager_configuration", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 9, name: "norsk_media_version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 10, name: "docker", kind: "message", T: DockerContainer, oneof: "client_code" },
-    { no: 11, name: "npm", kind: "message", T: NpmPackage, oneof: "client_code" },
+    { no: 1, name: "timestamp", kind: "message", T: Timestamp },
+    { no: 2, name: "role", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "nodeMetadata", kind: "message", T: NodeMetadata },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Job {
-    return new Job().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobHistoryJobProvisioned {
+    return new JobHistoryJobProvisioned().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Job {
-    return new Job().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobHistoryJobProvisioned {
+    return new JobHistoryJobProvisioned().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Job {
-    return new Job().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobHistoryJobProvisioned {
+    return new JobHistoryJobProvisioned().fromJsonString(jsonString, options);
   }
 
-  static equals(a: Job | PlainMessage<Job> | undefined, b: Job | PlainMessage<Job> | undefined): boolean {
-    return proto3.util.equals(Job, a, b);
+  static equals(a: JobHistoryJobProvisioned | PlainMessage<JobHistoryJobProvisioned> | undefined, b: JobHistoryJobProvisioned | PlainMessage<JobHistoryJobProvisioned> | undefined): boolean {
+    return proto3.util.equals(JobHistoryJobProvisioned, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.AwsNode
+ * @generated from message norsk.api.manager.JobHistoryJobRunning
  */
-export class AwsNode extends Message<AwsNode> {
-  /**
-   * @generated from field: string id = 1;
-   */
-  id = "";
-
+export class JobHistoryJobRunning extends Message<JobHistoryJobRunning> {
   /**
-   * @generated from field: map<string, string> tags = 2;
+   * @generated from field: google.protobuf.Timestamp timestamp = 1;
    */
-  tags: { [key: string]: string } = {};
+  timestamp?: Timestamp;
 
   /**
-   * @generated from field: string instance_type = 3;
-   */
-  instanceType = "";
-
-  /**
-   * @generated from field: string region = 4;
+   * @generated from field: string role = 2;
    */
-  region = "";
+  role = "";
 
   /**
-   * @generated from field: string az = 5;
+   * @generated from field: norsk.api.common.NodeMetadata nodeMetadata = 3;
    */
-  az = "";
+  nodeMetadata?: NodeMetadata;
 
   /**
-   * @generated from field: google.protobuf.Timestamp created_at = 6;
+   * @generated from field: norsk.api.common.RunningNodeMetadata runningNodeMetadata = 4;
    */
-  createdAt?: Timestamp;
+  runningNodeMetadata?: RunningNodeMetadata;
 
   /**
-   * @generated from field: string daemon_version = 7;
+   * @generated from field: map<string, norsk.api.common.ResolvedPortMappings> service_port_mappings = 5;
    */
-  daemonVersion = "";
+  servicePortMappings: { [key: string]: ResolvedPortMappings } = {};
 
-  constructor(data?: PartialMessage<AwsNode>) {
+  constructor(data?: PartialMessage<JobHistoryJobRunning>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.AwsNode";
+  static readonly typeName = "norsk.api.manager.JobHistoryJobRunning";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: "tags", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
-    { no: 3, name: "instance_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 4, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 5, name: "az", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 6, name: "created_at", kind: "message", T: Timestamp },
-    { no: 7, name: "daemon_version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 1, name: "timestamp", kind: "message", T: Timestamp },
+    { no: 2, name: "role", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "nodeMetadata", kind: "message", T: NodeMetadata },
+    { no: 4, name: "runningNodeMetadata", kind: "message", T: RunningNodeMetadata },
+    { no: 5, name: "service_port_mappings", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: ResolvedPortMappings} },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsNode {
-    return new AwsNode().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobHistoryJobRunning {
+    return new JobHistoryJobRunning().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsNode {
-    return new AwsNode().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobHistoryJobRunning {
+    return new JobHistoryJobRunning().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsNode {
-    return new AwsNode().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobHistoryJobRunning {
+    return new JobHistoryJobRunning().fromJsonString(jsonString, options);
   }
 
-  static equals(a: AwsNode | PlainMessage<AwsNode> | undefined, b: AwsNode | PlainMessage<AwsNode> | undefined): boolean {
-    return proto3.util.equals(AwsNode, a, b);
+  static equals(a: JobHistoryJobRunning | PlainMessage<JobHistoryJobRunning> | undefined, b: JobHistoryJobRunning | PlainMessage<JobHistoryJobRunning> | undefined): boolean {
+    return proto3.util.equals(JobHistoryJobRunning, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.AwsNodeAddress
+ * @generated from message norsk.api.manager.JobHistoryJobStopping
  */
-export class AwsNodeAddress extends Message<AwsNodeAddress> {
+export class JobHistoryJobStopping extends Message<JobHistoryJobStopping> {
+  /**
+   * @generated from field: google.protobuf.Timestamp timestamp = 1;
+   */
+  timestamp?: Timestamp;
+
+  /**
+   * @generated from field: string role = 2;
+   */
+  role = "";
+
   /**
-   * @generated from field: string public_dns_name = 1;
+   * @generated from field: norsk.api.common.NodeMetadata nodeMetadata = 3;
    */
-  publicDnsName = "";
+  nodeMetadata?: NodeMetadata;
 
   /**
-   * @generated from field: string private_dns_name = 2;
+   * @generated from field: norsk.api.common.RunningNodeMetadata runningNodeMetadata = 4;
    */
-  privateDnsName = "";
+  runningNodeMetadata?: RunningNodeMetadata;
 
   /**
-   * @generated from field: string private_ip_address = 3;
+   * @generated from field: norsk.api.manager.JobHistoryJobStopping.Reason reason = 5;
    */
-  privateIpAddress = "";
+  reason = JobHistoryJobStopping_Reason.JOB_STOPPED_NODE_STOPPED;
 
-  constructor(data?: PartialMessage<AwsNodeAddress>) {
+  constructor(data?: PartialMessage<JobHistoryJobStopping>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.AwsNodeAddress";
+  static readonly typeName = "norsk.api.manager.JobHistoryJobStopping";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "public_dns_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: "private_dns_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: "private_ip_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 1, name: "timestamp", kind: "message", T: Timestamp },
+    { no: 2, name: "role", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "nodeMetadata", kind: "message", T: NodeMetadata },
+    { no: 4, name: "runningNodeMetadata", kind: "message", T: RunningNodeMetadata },
+    { no: 5, name: "reason", kind: "enum", T: proto3.getEnumType(JobHistoryJobStopping_Reason) },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsNodeAddress {
-    return new AwsNodeAddress().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobHistoryJobStopping {
+    return new JobHistoryJobStopping().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsNodeAddress {
-    return new AwsNodeAddress().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobHistoryJobStopping {
+    return new JobHistoryJobStopping().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsNodeAddress {
-    return new AwsNodeAddress().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobHistoryJobStopping {
+    return new JobHistoryJobStopping().fromJsonString(jsonString, options);
   }
 
-  static equals(a: AwsNodeAddress | PlainMessage<AwsNodeAddress> | undefined, b: AwsNodeAddress | PlainMessage<AwsNodeAddress> | undefined): boolean {
-    return proto3.util.equals(AwsNodeAddress, a, b);
+  static equals(a: JobHistoryJobStopping | PlainMessage<JobHistoryJobStopping> | undefined, b: JobHistoryJobStopping | PlainMessage<JobHistoryJobStopping> | undefined): boolean {
+    return proto3.util.equals(JobHistoryJobStopping, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.AwsRunningNode
+ * @generated from enum norsk.api.manager.JobHistoryJobStopping.Reason
  */
-export class AwsRunningNode extends Message<AwsRunningNode> {
+export enum JobHistoryJobStopping_Reason {
   /**
-   * @generated from field: norsk.api.manager.AwsNode node = 1;
+   * @generated from enum value: JOB_STOPPED_NODE_STOPPED = 0;
    */
-  node?: AwsNode;
+  JOB_STOPPED_NODE_STOPPED = 0,
 
   /**
-   * @generated from field: norsk.api.manager.AwsNodeAddress address = 2;
+   * @generated from enum value: JOB_STOPPED_NODE_TERMINATED = 1;
    */
-  address?: AwsNodeAddress;
-
-  constructor(data?: PartialMessage<AwsRunningNode>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.AwsRunningNode";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "node", kind: "message", T: AwsNode },
-    { no: 2, name: "address", kind: "message", T: AwsNodeAddress },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsRunningNode {
-    return new AwsRunningNode().fromBinary(bytes, options);
-  }
+  JOB_STOPPED_NODE_TERMINATED = 1,
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsRunningNode {
-    return new AwsRunningNode().fromJson(jsonValue, options);
-  }
+  /**
+   * @generated from enum value: JOB_STOPPED_USER_REQUESTED = 2;
+   */
+  JOB_STOPPED_USER_REQUESTED = 2,
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsRunningNode {
-    return new AwsRunningNode().fromJsonString(jsonString, options);
-  }
+  /**
+   * @generated from enum value: JOB_STOPPED_UNKNOWN_JOB = 3;
+   */
+  JOB_STOPPED_UNKNOWN_JOB = 3,
 
-  static equals(a: AwsRunningNode | PlainMessage<AwsRunningNode> | undefined, b: AwsRunningNode | PlainMessage<AwsRunningNode> | undefined): boolean {
-    return proto3.util.equals(AwsRunningNode, a, b);
-  }
+  /**
+   * @generated from enum value: JOB_STOPPED_JOB_FAILED = 4;
+   */
+  JOB_STOPPED_JOB_FAILED = 4,
 }
+// Retrieve enum metadata with: proto3.getEnumType(JobHistoryJobStopping_Reason)
+proto3.util.setEnumType(JobHistoryJobStopping_Reason, "norsk.api.manager.JobHistoryJobStopping.Reason", [
+  { no: 0, name: "JOB_STOPPED_NODE_STOPPED" },
+  { no: 1, name: "JOB_STOPPED_NODE_TERMINATED" },
+  { no: 2, name: "JOB_STOPPED_USER_REQUESTED" },
+  { no: 3, name: "JOB_STOPPED_UNKNOWN_JOB" },
+  { no: 4, name: "JOB_STOPPED_JOB_FAILED" },
+]);
 
 /**
- * @generated from message norsk.api.manager.PhysicalNode
+ * @generated from message norsk.api.manager.JobHistoryJobStopped
  */
-export class PhysicalNode extends Message<PhysicalNode> {
+export class JobHistoryJobStopped extends Message<JobHistoryJobStopped> {
   /**
-   * @generated from field: string id = 1;
+   * @generated from field: google.protobuf.Timestamp timestamp = 1;
    */
-  id = "";
+  timestamp?: Timestamp;
 
   /**
-   * @generated from field: map<string, string> tags = 2;
+   * @generated from field: string role = 2;
    */
-  tags: { [key: string]: string } = {};
+  role = "";
 
   /**
-   * @generated from field: string ip_address = 3;
+   * @generated from field: norsk.api.common.NodeMetadata nodeMetadata = 3;
    */
-  ipAddress = "";
+  nodeMetadata?: NodeMetadata;
 
-  constructor(data?: PartialMessage<PhysicalNode>) {
+  /**
+   * @generated from field: norsk.api.common.RunningNodeMetadata runningNodeMetadata = 4;
+   */
+  runningNodeMetadata?: RunningNodeMetadata;
+
+  constructor(data?: PartialMessage<JobHistoryJobStopped>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.PhysicalNode";
+  static readonly typeName = "norsk.api.manager.JobHistoryJobStopped";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: "tags", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
-    { no: 3, name: "ip_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 1, name: "timestamp", kind: "message", T: Timestamp },
+    { no: 2, name: "role", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "nodeMetadata", kind: "message", T: NodeMetadata },
+    { no: 4, name: "runningNodeMetadata", kind: "message", T: RunningNodeMetadata },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PhysicalNode {
-    return new PhysicalNode().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobHistoryJobStopped {
+    return new JobHistoryJobStopped().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PhysicalNode {
-    return new PhysicalNode().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobHistoryJobStopped {
+    return new JobHistoryJobStopped().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PhysicalNode {
-    return new PhysicalNode().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobHistoryJobStopped {
+    return new JobHistoryJobStopped().fromJsonString(jsonString, options);
   }
-
-  static equals(a: PhysicalNode | PlainMessage<PhysicalNode> | undefined, b: PhysicalNode | PlainMessage<PhysicalNode> | undefined): boolean {
-    return proto3.util.equals(PhysicalNode, a, b);
+
+  static equals(a: JobHistoryJobStopped | PlainMessage<JobHistoryJobStopped> | undefined, b: JobHistoryJobStopped | PlainMessage<JobHistoryJobStopped> | undefined): boolean {
+    return proto3.util.equals(JobHistoryJobStopped, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.RunningJob
+ * @generated from message norsk.api.manager.JobHistoryJobCompleted
  */
-export class RunningJob extends Message<RunningJob> {
-  /**
-   * @generated from field: norsk.api.manager.JobId job_id = 1;
-   */
-  jobId?: JobId;
-
-  /**
-   * @generated from field: string role = 2;
-   */
-  role = "";
-
+export class JobHistoryJobCompleted extends Message<JobHistoryJobCompleted> {
   /**
-   * @generated from field: norsk.api.manager.NodeId node_id = 3;
+   * @generated from field: google.protobuf.Timestamp timestamp = 1;
    */
-  nodeId?: NodeId;
+  timestamp?: Timestamp;
 
-  constructor(data?: PartialMessage<RunningJob>) {
+  constructor(data?: PartialMessage<JobHistoryJobCompleted>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.RunningJob";
+  static readonly typeName = "norsk.api.manager.JobHistoryJobCompleted";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "job_id", kind: "message", T: JobId },
-    { no: 2, name: "role", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: "node_id", kind: "message", T: NodeId },
+    { no: 1, name: "timestamp", kind: "message", T: Timestamp },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RunningJob {
-    return new RunningJob().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobHistoryJobCompleted {
+    return new JobHistoryJobCompleted().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RunningJob {
-    return new RunningJob().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobHistoryJobCompleted {
+    return new JobHistoryJobCompleted().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RunningJob {
-    return new RunningJob().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobHistoryJobCompleted {
+    return new JobHistoryJobCompleted().fromJsonString(jsonString, options);
   }
 
-  static equals(a: RunningJob | PlainMessage<RunningJob> | undefined, b: RunningJob | PlainMessage<RunningJob> | undefined): boolean {
-    return proto3.util.equals(RunningJob, a, b);
+  static equals(a: JobHistoryJobCompleted | PlainMessage<JobHistoryJobCompleted> | undefined, b: JobHistoryJobCompleted | PlainMessage<JobHistoryJobCompleted> | undefined): boolean {
+    return proto3.util.equals(JobHistoryJobCompleted, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.JobPending
+ * @generated from message norsk.api.manager.JobHistoryEntry
  */
-export class JobPending extends Message<JobPending> {
+export class JobHistoryEntry extends Message<JobHistoryEntry> {
   /**
-   * @generated from field: norsk.api.manager.Job job = 1;
+   * @generated from oneof norsk.api.manager.JobHistoryEntry.history_entry
    */
-  job?: Job;
+  historyEntry: {
+    /**
+     * @generated from field: norsk.api.manager.JobHistoryJobCreated job_created = 1;
+     */
+    value: JobHistoryJobCreated;
+    case: "jobCreated";
+  } | {
+    /**
+     * @generated from field: norsk.api.manager.JobHistoryJobUpdated job_updated = 2;
+     */
+    value: JobHistoryJobUpdated;
+    case: "jobUpdated";
+  } | {
+    /**
+     * @generated from field: norsk.api.manager.JobHistoryJobProvisioned job_provisioned = 3;
+     */
+    value: JobHistoryJobProvisioned;
+    case: "jobProvisioned";
+  } | {
+    /**
+     * @generated from field: norsk.api.manager.JobHistoryJobRunning job_running = 4;
+     */
+    value: JobHistoryJobRunning;
+    case: "jobRunning";
+  } | {
+    /**
+     * @generated from field: norsk.api.manager.JobHistoryJobStopping job_stopping = 5;
+     */
+    value: JobHistoryJobStopping;
+    case: "jobStopping";
+  } | {
+    /**
+     * @generated from field: norsk.api.manager.JobHistoryJobStopped job_stopped = 6;
+     */
+    value: JobHistoryJobStopped;
+    case: "jobStopped";
+  } | {
+    /**
+     * @generated from field: norsk.api.manager.JobHistoryJobCompleted job_completed = 7;
+     */
+    value: JobHistoryJobCompleted;
+    case: "jobCompleted";
+  } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<JobPending>) {
+  constructor(data?: PartialMessage<JobHistoryEntry>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.JobPending";
+  static readonly typeName = "norsk.api.manager.JobHistoryEntry";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "job", kind: "message", T: Job },
+    { no: 1, name: "job_created", kind: "message", T: JobHistoryJobCreated, oneof: "history_entry" },
+    { no: 2, name: "job_updated", kind: "message", T: JobHistoryJobUpdated, oneof: "history_entry" },
+    { no: 3, name: "job_provisioned", kind: "message", T: JobHistoryJobProvisioned, oneof: "history_entry" },
+    { no: 4, name: "job_running", kind: "message", T: JobHistoryJobRunning, oneof: "history_entry" },
+    { no: 5, name: "job_stopping", kind: "message", T: JobHistoryJobStopping, oneof: "history_entry" },
+    { no: 6, name: "job_stopped", kind: "message", T: JobHistoryJobStopped, oneof: "history_entry" },
+    { no: 7, name: "job_completed", kind: "message", T: JobHistoryJobCompleted, oneof: "history_entry" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobPending {
-    return new JobPending().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobHistoryEntry {
+    return new JobHistoryEntry().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobPending {
-    return new JobPending().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobHistoryEntry {
+    return new JobHistoryEntry().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobPending {
-    return new JobPending().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobHistoryEntry {
+    return new JobHistoryEntry().fromJsonString(jsonString, options);
   }
 
-  static equals(a: JobPending | PlainMessage<JobPending> | undefined, b: JobPending | PlainMessage<JobPending> | undefined): boolean {
-    return proto3.util.equals(JobPending, a, b);
+  static equals(a: JobHistoryEntry | PlainMessage<JobHistoryEntry> | undefined, b: JobHistoryEntry | PlainMessage<JobHistoryEntry> | undefined): boolean {
+    return proto3.util.equals(JobHistoryEntry, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.JobUpdated
+ * @generated from message norsk.api.manager.JobWithHistory
  */
-export class JobUpdated extends Message<JobUpdated> {
+export class JobWithHistory extends Message<JobWithHistory> {
   /**
    * @generated from field: norsk.api.manager.Job job = 1;
    */
   job?: Job;
 
-  constructor(data?: PartialMessage<JobUpdated>) {
+  /**
+   * @generated from field: repeated norsk.api.manager.JobHistoryEntry history_entry = 2;
+   */
+  historyEntry: JobHistoryEntry[] = [];
+
+  constructor(data?: PartialMessage<JobWithHistory>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.JobUpdated";
+  static readonly typeName = "norsk.api.manager.JobWithHistory";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "job", kind: "message", T: Job },
+    { no: 2, name: "history_entry", kind: "message", T: JobHistoryEntry, repeated: true },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobUpdated {
-    return new JobUpdated().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobWithHistory {
+    return new JobWithHistory().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobUpdated {
-    return new JobUpdated().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobWithHistory {
+    return new JobWithHistory().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobUpdated {
-    return new JobUpdated().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobWithHistory {
+    return new JobWithHistory().fromJsonString(jsonString, options);
   }
 
-  static equals(a: JobUpdated | PlainMessage<JobUpdated> | undefined, b: JobUpdated | PlainMessage<JobUpdated> | undefined): boolean {
-    return proto3.util.equals(JobUpdated, a, b);
+  static equals(a: JobWithHistory | PlainMessage<JobWithHistory> | undefined, b: JobWithHistory | PlainMessage<JobWithHistory> | undefined): boolean {
+    return proto3.util.equals(JobWithHistory, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.JobDueToStart
+ * @generated from message norsk.api.manager.PhysicalNode
  */
-export class JobDueToStart extends Message<JobDueToStart> {
+export class PhysicalNode extends Message<PhysicalNode> {
   /**
-   * @generated from field: norsk.api.manager.Job job = 1;
+   * @generated from field: string id = 1;
    */
-  job?: Job;
+  id = "";
+
+  /**
+   * @generated from field: map<string, string> tags = 2;
+   */
+  tags: { [key: string]: string } = {};
+
+  /**
+   * @generated from field: string ip_address = 3;
+   */
+  ipAddress = "";
 
-  constructor(data?: PartialMessage<JobDueToStart>) {
+  constructor(data?: PartialMessage<PhysicalNode>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.JobDueToStart";
+  static readonly typeName = "norsk.api.manager.PhysicalNode";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "job", kind: "message", T: Job },
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "tags", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
+    { no: 3, name: "ip_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobDueToStart {
-    return new JobDueToStart().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PhysicalNode {
+    return new PhysicalNode().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobDueToStart {
-    return new JobDueToStart().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PhysicalNode {
+    return new PhysicalNode().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobDueToStart {
-    return new JobDueToStart().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PhysicalNode {
+    return new PhysicalNode().fromJsonString(jsonString, options);
   }
 
-  static equals(a: JobDueToStart | PlainMessage<JobDueToStart> | undefined, b: JobDueToStart | PlainMessage<JobDueToStart> | undefined): boolean {
-    return proto3.util.equals(JobDueToStart, a, b);
+  static equals(a: PhysicalNode | PlainMessage<PhysicalNode> | undefined, b: PhysicalNode | PlainMessage<PhysicalNode> | undefined): boolean {
+    return proto3.util.equals(PhysicalNode, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.JobInstanceStarting
+ * @generated from message norsk.api.manager.RunningJob
  */
-export class JobInstanceStarting extends Message<JobInstanceStarting> {
+export class RunningJob extends Message<RunningJob> {
+  /**
+   * @generated from field: norsk.api.common.ActiveJobKey job_key = 1;
+   */
+  jobKey?: ActiveJobKey;
+
   /**
-   * @generated from field: norsk.api.manager.RunningJob running_job = 1;
+   * @generated from field: norsk.api.common.NodeId node_id = 2;
    */
-  runningJob?: RunningJob;
+  nodeId?: NodeId;
 
-  constructor(data?: PartialMessage<JobInstanceStarting>) {
+  constructor(data?: PartialMessage<RunningJob>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.JobInstanceStarting";
+  static readonly typeName = "norsk.api.manager.RunningJob";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "running_job", kind: "message", T: RunningJob },
+    { no: 1, name: "job_key", kind: "message", T: ActiveJobKey },
+    { no: 2, name: "node_id", kind: "message", T: NodeId },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobInstanceStarting {
-    return new JobInstanceStarting().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RunningJob {
+    return new RunningJob().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobInstanceStarting {
-    return new JobInstanceStarting().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RunningJob {
+    return new RunningJob().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobInstanceStarting {
-    return new JobInstanceStarting().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RunningJob {
+    return new RunningJob().fromJsonString(jsonString, options);
   }
 
-  static equals(a: JobInstanceStarting | PlainMessage<JobInstanceStarting> | undefined, b: JobInstanceStarting | PlainMessage<JobInstanceStarting> | undefined): boolean {
-    return proto3.util.equals(JobInstanceStarting, a, b);
+  static equals(a: RunningJob | PlainMessage<RunningJob> | undefined, b: RunningJob | PlainMessage<RunningJob> | undefined): boolean {
+    return proto3.util.equals(RunningJob, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.JobInstanceStarted
+ * @generated from message norsk.api.manager.JobActive
  */
-export class JobInstanceStarted extends Message<JobInstanceStarted> {
+export class JobActive extends Message<JobActive> {
   /**
-   * @generated from field: norsk.api.manager.RunningJob running_job = 1;
+   * @generated from field: norsk.api.manager.JobWithHistory jobWithHistory = 1;
    */
-  runningJob?: RunningJob;
+  jobWithHistory?: JobWithHistory;
 
-  constructor(data?: PartialMessage<JobInstanceStarted>) {
+  constructor(data?: PartialMessage<JobActive>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.JobInstanceStarted";
+  static readonly typeName = "norsk.api.manager.JobActive";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "running_job", kind: "message", T: RunningJob },
+    { no: 1, name: "jobWithHistory", kind: "message", T: JobWithHistory },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobInstanceStarted {
-    return new JobInstanceStarted().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobActive {
+    return new JobActive().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobInstanceStarted {
-    return new JobInstanceStarted().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobActive {
+    return new JobActive().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobInstanceStarted {
-    return new JobInstanceStarted().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobActive {
+    return new JobActive().fromJsonString(jsonString, options);
   }
 
-  static equals(a: JobInstanceStarted | PlainMessage<JobInstanceStarted> | undefined, b: JobInstanceStarted | PlainMessage<JobInstanceStarted> | undefined): boolean {
-    return proto3.util.equals(JobInstanceStarted, a, b);
+  static equals(a: JobActive | PlainMessage<JobActive> | undefined, b: JobActive | PlainMessage<JobActive> | undefined): boolean {
+    return proto3.util.equals(JobActive, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.JobDueToStop
+ * @generated from message norsk.api.manager.JobPending
  */
-export class JobDueToStop extends Message<JobDueToStop> {
-  /**
-   * @generated from field: norsk.api.manager.Job job = 1;
-   */
-  job?: Job;
-
+export class JobPending extends Message<JobPending> {
   /**
-   * @generated from field: repeated norsk.api.manager.RunningJob instances = 2;
+   * @generated from field: norsk.api.manager.JobWithHistory jobWithHistory = 1;
    */
-  instances: RunningJob[] = [];
+  jobWithHistory?: JobWithHistory;
 
-  constructor(data?: PartialMessage<JobDueToStop>) {
+  constructor(data?: PartialMessage<JobPending>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.JobDueToStop";
+  static readonly typeName = "norsk.api.manager.JobPending";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "job", kind: "message", T: Job },
-    { no: 2, name: "instances", kind: "message", T: RunningJob, repeated: true },
+    { no: 1, name: "jobWithHistory", kind: "message", T: JobWithHistory },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobDueToStop {
-    return new JobDueToStop().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobPending {
+    return new JobPending().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobDueToStop {
-    return new JobDueToStop().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobPending {
+    return new JobPending().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobDueToStop {
-    return new JobDueToStop().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobPending {
+    return new JobPending().fromJsonString(jsonString, options);
   }
 
-  static equals(a: JobDueToStop | PlainMessage<JobDueToStop> | undefined, b: JobDueToStop | PlainMessage<JobDueToStop> | undefined): boolean {
-    return proto3.util.equals(JobDueToStop, a, b);
+  static equals(a: JobPending | PlainMessage<JobPending> | undefined, b: JobPending | PlainMessage<JobPending> | undefined): boolean {
+    return proto3.util.equals(JobPending, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.JobInstanceStopping
+ * @generated from message norsk.api.manager.JobUpdated
  */
-export class JobInstanceStopping extends Message<JobInstanceStopping> {
+export class JobUpdated extends Message<JobUpdated> {
   /**
-   * @generated from field: norsk.api.manager.RunningJob running_job = 1;
+   * @generated from field: norsk.api.manager.JobWithHistory jobWithHistory = 1;
    */
-  runningJob?: RunningJob;
+  jobWithHistory?: JobWithHistory;
 
-  constructor(data?: PartialMessage<JobInstanceStopping>) {
+  constructor(data?: PartialMessage<JobUpdated>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.JobInstanceStopping";
+  static readonly typeName = "norsk.api.manager.JobUpdated";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "running_job", kind: "message", T: RunningJob },
+    { no: 1, name: "jobWithHistory", kind: "message", T: JobWithHistory },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobInstanceStopping {
-    return new JobInstanceStopping().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobUpdated {
+    return new JobUpdated().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobInstanceStopping {
-    return new JobInstanceStopping().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobUpdated {
+    return new JobUpdated().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobInstanceStopping {
-    return new JobInstanceStopping().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobUpdated {
+    return new JobUpdated().fromJsonString(jsonString, options);
   }
 
-  static equals(a: JobInstanceStopping | PlainMessage<JobInstanceStopping> | undefined, b: JobInstanceStopping | PlainMessage<JobInstanceStopping> | undefined): boolean {
-    return proto3.util.equals(JobInstanceStopping, a, b);
+  static equals(a: JobUpdated | PlainMessage<JobUpdated> | undefined, b: JobUpdated | PlainMessage<JobUpdated> | undefined): boolean {
+    return proto3.util.equals(JobUpdated, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.JobInstanceStopped
+ * @generated from message norsk.api.manager.JobDeleted
  */
-export class JobInstanceStopped extends Message<JobInstanceStopped> {
+export class JobDeleted extends Message<JobDeleted> {
   /**
-   * @generated from field: norsk.api.manager.RunningJob running_job = 1;
+   * @generated from field: norsk.api.common.JobId jobId = 1;
    */
-  runningJob?: RunningJob;
+  jobId?: JobId;
 
-  constructor(data?: PartialMessage<JobInstanceStopped>) {
+  constructor(data?: PartialMessage<JobDeleted>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.JobInstanceStopped";
+  static readonly typeName = "norsk.api.manager.JobDeleted";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "running_job", kind: "message", T: RunningJob },
+    { no: 1, name: "jobId", kind: "message", T: JobId },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobInstanceStopped {
-    return new JobInstanceStopped().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobDeleted {
+    return new JobDeleted().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobInstanceStopped {
-    return new JobInstanceStopped().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobDeleted {
+    return new JobDeleted().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobInstanceStopped {
-    return new JobInstanceStopped().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobDeleted {
+    return new JobDeleted().fromJsonString(jsonString, options);
   }
 
-  static equals(a: JobInstanceStopped | PlainMessage<JobInstanceStopped> | undefined, b: JobInstanceStopped | PlainMessage<JobInstanceStopped> | undefined): boolean {
-    return proto3.util.equals(JobInstanceStopped, a, b);
+  static equals(a: JobDeleted | PlainMessage<JobDeleted> | undefined, b: JobDeleted | PlainMessage<JobDeleted> | undefined): boolean {
+    return proto3.util.equals(JobDeleted, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.JobInstanceFailed
+ * @generated from message norsk.api.manager.JobOutOfWindow
  */
-export class JobInstanceFailed extends Message<JobInstanceFailed> {
+export class JobOutOfWindow extends Message<JobOutOfWindow> {
   /**
-   * @generated from field: norsk.api.manager.RunningJob running_job = 1;
+   * @generated from field: norsk.api.manager.JobWithHistory jobWithHistory = 1;
    */
-  runningJob?: RunningJob;
+  jobWithHistory?: JobWithHistory;
 
-  constructor(data?: PartialMessage<JobInstanceFailed>) {
+  constructor(data?: PartialMessage<JobOutOfWindow>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.JobInstanceFailed";
+  static readonly typeName = "norsk.api.manager.JobOutOfWindow";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "running_job", kind: "message", T: RunningJob },
+    { no: 1, name: "jobWithHistory", kind: "message", T: JobWithHistory },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobInstanceFailed {
-    return new JobInstanceFailed().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobOutOfWindow {
+    return new JobOutOfWindow().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobInstanceFailed {
-    return new JobInstanceFailed().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobOutOfWindow {
+    return new JobOutOfWindow().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobInstanceFailed {
-    return new JobInstanceFailed().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobOutOfWindow {
+    return new JobOutOfWindow().fromJsonString(jsonString, options);
   }
 
-  static equals(a: JobInstanceFailed | PlainMessage<JobInstanceFailed> | undefined, b: JobInstanceFailed | PlainMessage<JobInstanceFailed> | undefined): boolean {
-    return proto3.util.equals(JobInstanceFailed, a, b);
+  static equals(a: JobOutOfWindow | PlainMessage<JobOutOfWindow> | undefined, b: JobOutOfWindow | PlainMessage<JobOutOfWindow> | undefined): boolean {
+    return proto3.util.equals(JobOutOfWindow, a, b);
   }
 }
 
@@ -1058,9 +1125,9 @@ export class CurrentJob extends Message<CurrentJob> {
  */
 export class NodeStarting extends Message<NodeStarting> {
   /**
-   * @generated from field: norsk.api.manager.NodeId node_id = 1;
+   * @generated from field: norsk.api.common.NodeMetadata nodeMetadata = 1;
    */
-  nodeId?: NodeId;
+  nodeMetadata?: NodeMetadata;
 
   constructor(data?: PartialMessage<NodeStarting>) {
     super();
@@ -1070,7 +1137,7 @@ export class NodeStarting extends Message<NodeStarting> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.manager.NodeStarting";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "node_id", kind: "message", T: NodeId },
+    { no: 1, name: "nodeMetadata", kind: "message", T: NodeMetadata },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NodeStarting {
@@ -1095,15 +1162,14 @@ export class NodeStarting extends Message<NodeStarting> {
  */
 export class NodeStarted extends Message<NodeStarted> {
   /**
-   * @generated from oneof norsk.api.manager.NodeStarted.node
+   * @generated from field: norsk.api.common.NodeMetadata nodeMetadata = 1;
    */
-  node: {
-    /**
-     * @generated from field: norsk.api.manager.AwsRunningNode aws_node = 1;
-     */
-    value: AwsRunningNode;
-    case: "awsNode";
-  } | { case: undefined; value?: undefined } = { case: undefined };
+  nodeMetadata?: NodeMetadata;
+
+  /**
+   * @generated from field: norsk.api.common.RunningNodeMetadata runningNodeMetadata = 2;
+   */
+  runningNodeMetadata?: RunningNodeMetadata;
 
   constructor(data?: PartialMessage<NodeStarted>) {
     super();
@@ -1113,7 +1179,8 @@ export class NodeStarted extends Message<NodeStarted> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.manager.NodeStarted";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "aws_node", kind: "message", T: AwsRunningNode, oneof: "node" },
+    { no: 1, name: "nodeMetadata", kind: "message", T: NodeMetadata },
+    { no: 2, name: "runningNodeMetadata", kind: "message", T: RunningNodeMetadata },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NodeStarted {
@@ -1138,14 +1205,14 @@ export class NodeStarted extends Message<NodeStarted> {
  */
 export class NodeStopping extends Message<NodeStopping> {
   /**
-   * @generated from field: norsk.api.manager.NodeId node_id = 1;
+   * @generated from field: norsk.api.common.NodeId node_id = 1;
    */
   nodeId?: NodeId;
 
   /**
-   * @generated from field: repeated norsk.api.manager.RunningJob instances = 2;
+   * @generated from field: norsk.api.manager.NodeStopping.Reason reason = 2;
    */
-  instances: RunningJob[] = [];
+  reason = NodeStopping_Reason.CREATE_FAILED;
 
   constructor(data?: PartialMessage<NodeStopping>) {
     super();
@@ -1156,7 +1223,7 @@ export class NodeStopping extends Message<NodeStopping> {
   static readonly typeName = "norsk.api.manager.NodeStopping";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "node_id", kind: "message", T: NodeId },
-    { no: 2, name: "instances", kind: "message", T: RunningJob, repeated: true },
+    { no: 2, name: "reason", kind: "enum", T: proto3.getEnumType(NodeStopping_Reason) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NodeStopping {
@@ -1176,12 +1243,80 @@ export class NodeStopping extends Message<NodeStopping> {
   }
 }
 
+/**
+ * @generated from enum norsk.api.manager.NodeStopping.Reason
+ */
+export enum NodeStopping_Reason {
+  /**
+   * @generated from enum value: CREATE_FAILED = 0;
+   */
+  CREATE_FAILED = 0,
+
+  /**
+   * @generated from enum value: PENDING_TIME_EXCEEDED = 1;
+   */
+  PENDING_TIME_EXCEEDED = 1,
+
+  /**
+   * @generated from enum value: STARTUP_TIME_EXCEEDED = 2;
+   */
+  STARTUP_TIME_EXCEEDED = 2,
+
+  /**
+   * @generated from enum value: INITIALISATION_HEALTH_PING_TIME_EXCEEDED = 3;
+   */
+  INITIALISATION_HEALTH_PING_TIME_EXCEEDED = 3,
+
+  /**
+   * @generated from enum value: HEALTH_PING_TIME_EXCEEDED = 4;
+   */
+  HEALTH_PING_TIME_EXCEEDED = 4,
+
+  /**
+   * @generated from enum value: DUPLICATE_JOB = 5;
+   */
+  DUPLICATE_JOB = 5,
+
+  /**
+   * @generated from enum value: PROVIDER_STOP = 6;
+   */
+  PROVIDER_STOP = 6,
+
+  /**
+   * @generated from enum value: PROVIDER_TERMINATE = 7;
+   */
+  PROVIDER_TERMINATE = 7,
+
+  /**
+   * @generated from enum value: USER_REQUESTED = 8;
+   */
+  USER_REQUESTED = 8,
+
+  /**
+   * @generated from enum value: UNKNOWN_NODE = 9;
+   */
+  UNKNOWN_NODE = 9,
+}
+// Retrieve enum metadata with: proto3.getEnumType(NodeStopping_Reason)
+proto3.util.setEnumType(NodeStopping_Reason, "norsk.api.manager.NodeStopping.Reason", [
+  { no: 0, name: "CREATE_FAILED" },
+  { no: 1, name: "PENDING_TIME_EXCEEDED" },
+  { no: 2, name: "STARTUP_TIME_EXCEEDED" },
+  { no: 3, name: "INITIALISATION_HEALTH_PING_TIME_EXCEEDED" },
+  { no: 4, name: "HEALTH_PING_TIME_EXCEEDED" },
+  { no: 5, name: "DUPLICATE_JOB" },
+  { no: 6, name: "PROVIDER_STOP" },
+  { no: 7, name: "PROVIDER_TERMINATE" },
+  { no: 8, name: "USER_REQUESTED" },
+  { no: 9, name: "UNKNOWN_NODE" },
+]);
+
 /**
  * @generated from message norsk.api.manager.NodeStopped
  */
 export class NodeStopped extends Message<NodeStopped> {
   /**
-   * @generated from field: norsk.api.manager.NodeId node_id = 1;
+   * @generated from field: norsk.api.common.NodeId node_id = 1;
    */
   nodeId?: NodeId;
 
@@ -1214,68 +1349,18 @@ export class NodeStopped extends Message<NodeStopped> {
 }
 
 /**
- * @generated from message norsk.api.manager.NodeFailed
+ * @generated from message norsk.api.manager.NodeRunning
  */
-export class NodeFailed extends Message<NodeFailed> {
-  /**
-   * @generated from field: norsk.api.manager.NodeId node_id = 1;
-   */
-  nodeId?: NodeId;
-
+export class NodeRunning extends Message<NodeRunning> {
   /**
-   * @generated from field: repeated norsk.api.manager.RunningJob instances = 2;
+   * @generated from field: norsk.api.common.NodeMetadata nodeMetadata = 1;
    */
-  instances: RunningJob[] = [];
-
-  constructor(data?: PartialMessage<NodeFailed>) {
-    super();
-    proto3.util.initPartial(data, this);
-  }
-
-  static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.NodeFailed";
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "node_id", kind: "message", T: NodeId },
-    { no: 2, name: "instances", kind: "message", T: RunningJob, repeated: true },
-  ]);
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NodeFailed {
-    return new NodeFailed().fromBinary(bytes, options);
-  }
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NodeFailed {
-    return new NodeFailed().fromJson(jsonValue, options);
-  }
+  nodeMetadata?: NodeMetadata;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NodeFailed {
-    return new NodeFailed().fromJsonString(jsonString, options);
-  }
-
-  static equals(a: NodeFailed | PlainMessage<NodeFailed> | undefined, b: NodeFailed | PlainMessage<NodeFailed> | undefined): boolean {
-    return proto3.util.equals(NodeFailed, a, b);
-  }
-}
-
-/**
- * @generated from message norsk.api.manager.NodeRunning
- */
-export class NodeRunning extends Message<NodeRunning> {
   /**
-   * @generated from oneof norsk.api.manager.NodeRunning.node
+   * @generated from field: norsk.api.common.RunningNodeMetadata runningNodeMetadata = 2;
    */
-  node: {
-    /**
-     * @generated from field: norsk.api.manager.AwsRunningNode aws_node = 1;
-     */
-    value: AwsRunningNode;
-    case: "awsNode";
-  } | {
-    /**
-     * @generated from field: norsk.api.manager.PhysicalNode physical_node = 2;
-     */
-    value: PhysicalNode;
-    case: "physicalNode";
-  } | { case: undefined; value?: undefined } = { case: undefined };
+  runningNodeMetadata?: RunningNodeMetadata;
 
   /**
    * @generated from field: repeated norsk.api.manager.RunningJob instances = 3;
@@ -1290,8 +1375,8 @@ export class NodeRunning extends Message<NodeRunning> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.manager.NodeRunning";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "aws_node", kind: "message", T: AwsRunningNode, oneof: "node" },
-    { no: 2, name: "physical_node", kind: "message", T: PhysicalNode, oneof: "node" },
+    { no: 1, name: "nodeMetadata", kind: "message", T: NodeMetadata },
+    { no: 2, name: "runningNodeMetadata", kind: "message", T: RunningNodeMetadata },
     { no: 3, name: "instances", kind: "message", T: RunningJob, repeated: true },
   ]);
 
@@ -1356,76 +1441,108 @@ export class PhysicalNodeConnected extends Message<PhysicalNodeConnected> {
 }
 
 /**
- * @generated from message norsk.api.manager.JobId
+ * @generated from message norsk.api.manager.AwsLaunchTemplate
  */
-export class JobId extends Message<JobId> {
+export class AwsLaunchTemplate extends Message<AwsLaunchTemplate> {
+  /**
+   * @generated from oneof norsk.api.manager.AwsLaunchTemplate.template
+   */
+  template: {
+    /**
+     * @generated from field: string id = 1;
+     */
+    value: string;
+    case: "id";
+  } | {
+    /**
+     * @generated from field: string name = 2;
+     */
+    value: string;
+    case: "name";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
   /**
-   * @generated from field: string job_id = 1;
+   * @generated from field: string version = 3;
    */
-  jobId = "";
+  version = "";
 
-  constructor(data?: PartialMessage<JobId>) {
+  constructor(data?: PartialMessage<AwsLaunchTemplate>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.JobId";
+  static readonly typeName = "norsk.api.manager.AwsLaunchTemplate";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "job_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "template" },
+    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "template" },
+    { no: 3, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobId {
-    return new JobId().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsLaunchTemplate {
+    return new AwsLaunchTemplate().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobId {
-    return new JobId().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsLaunchTemplate {
+    return new AwsLaunchTemplate().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobId {
-    return new JobId().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsLaunchTemplate {
+    return new AwsLaunchTemplate().fromJsonString(jsonString, options);
   }
 
-  static equals(a: JobId | PlainMessage<JobId> | undefined, b: JobId | PlainMessage<JobId> | undefined): boolean {
-    return proto3.util.equals(JobId, a, b);
+  static equals(a: AwsLaunchTemplate | PlainMessage<AwsLaunchTemplate> | undefined, b: AwsLaunchTemplate | PlainMessage<AwsLaunchTemplate> | undefined): boolean {
+    return proto3.util.equals(AwsLaunchTemplate, a, b);
   }
 }
 
 /**
- * @generated from message norsk.api.manager.NodeId
+ * @generated from message norsk.api.manager.AwsIamRole
  */
-export class NodeId extends Message<NodeId> {
+export class AwsIamRole extends Message<AwsIamRole> {
   /**
-   * @generated from field: string node_id = 1;
+   * @generated from oneof norsk.api.manager.AwsIamRole.iam_role
    */
-  nodeId = "";
+  iamRole: {
+    /**
+     * @generated from field: string arn = 1;
+     */
+    value: string;
+    case: "arn";
+  } | {
+    /**
+     * @generated from field: string name = 2;
+     */
+    value: string;
+    case: "name";
+  } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<NodeId>) {
+  constructor(data?: PartialMessage<AwsIamRole>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.NodeId";
+  static readonly typeName = "norsk.api.manager.AwsIamRole";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "node_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 1, name: "arn", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "iam_role" },
+    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "iam_role" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NodeId {
-    return new NodeId().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsIamRole {
+    return new AwsIamRole().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NodeId {
-    return new NodeId().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsIamRole {
+    return new AwsIamRole().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NodeId {
-    return new NodeId().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsIamRole {
+    return new AwsIamRole().fromJsonString(jsonString, options);
   }
 
-  static equals(a: NodeId | PlainMessage<NodeId> | undefined, b: NodeId | PlainMessage<NodeId> | undefined): boolean {
-    return proto3.util.equals(NodeId, a, b);
+  static equals(a: AwsIamRole | PlainMessage<AwsIamRole> | undefined, b: AwsIamRole | PlainMessage<AwsIamRole> | undefined): boolean {
+    return proto3.util.equals(AwsIamRole, a, b);
   }
 }
 
@@ -1434,14 +1551,14 @@ export class NodeId extends Message<NodeId> {
  */
 export class CreateAwsNodeRequest extends Message<CreateAwsNodeRequest> {
   /**
-   * @generated from field: map<string, string> tags = 1;
+   * @generated from field: norsk.api.common.NodeId node_id = 1;
    */
-  tags: { [key: string]: string } = {};
+  nodeId?: NodeId;
 
   /**
-   * @generated from field: string instance_type = 2;
+   * @generated from field: map<string, string> tags = 2;
    */
-  instanceType = "";
+  tags: { [key: string]: string } = {};
 
   /**
    * @generated from field: string region = 3;
@@ -1449,14 +1566,24 @@ export class CreateAwsNodeRequest extends Message<CreateAwsNodeRequest> {
   region = "";
 
   /**
-   * @generated from field: string az = 4;
+   * @generated from field: string instance_type = 4;
+   */
+  instanceType = "";
+
+  /**
+   * @generated from field: norsk.api.manager.AwsLaunchTemplate template = 5;
+   */
+  template?: AwsLaunchTemplate;
+
+  /**
+   * @generated from field: norsk.api.manager.Version worker_image_version = 11;
    */
-  az = "";
+  workerImageVersion = Version.RECOMMENDED;
 
   /**
-   * @generated from field: string norsk_bootstrap_version = 5;
+   * @generated from field: norsk.api.manager.Version worker_daemon_version = 12;
    */
-  norskBootstrapVersion = "";
+  workerDaemonVersion = Version.RECOMMENDED;
 
   constructor(data?: PartialMessage<CreateAwsNodeRequest>) {
     super();
@@ -1466,11 +1593,13 @@ export class CreateAwsNodeRequest extends Message<CreateAwsNodeRequest> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.manager.CreateAwsNodeRequest";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "tags", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
-    { no: 2, name: "instance_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 1, name: "node_id", kind: "message", T: NodeId },
+    { no: 2, name: "tags", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
     { no: 3, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 4, name: "az", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 5, name: "norsk_bootstrap_version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "instance_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 5, name: "template", kind: "message", T: AwsLaunchTemplate },
+    { no: 11, name: "worker_image_version", kind: "enum", T: proto3.getEnumType(Version) },
+    { no: 12, name: "worker_daemon_version", kind: "enum", T: proto3.getEnumType(Version) },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateAwsNodeRequest {
@@ -1490,6 +1619,85 @@ export class CreateAwsNodeRequest extends Message<CreateAwsNodeRequest> {
   }
 }
 
+/**
+ * @generated from message norsk.api.manager.CreateOciNodeRequest
+ */
+export class CreateOciNodeRequest extends Message<CreateOciNodeRequest> {
+  /**
+   * @generated from field: norsk.api.common.NodeId node_id = 1;
+   */
+  nodeId?: NodeId;
+
+  /**
+   * @generated from field: map<string, string> tags = 2;
+   */
+  tags: { [key: string]: string } = {};
+
+  /**
+   * @generated from field: string availabilityDomain = 3;
+   */
+  availabilityDomain = "";
+
+  /**
+   * @generated from field: string architecture = 4;
+   */
+  architecture = "";
+
+  /**
+   * @generated from field: string shape = 5;
+   */
+  shape = "";
+
+  /**
+   * @generated from field: string subnet = 6;
+   */
+  subnet = "";
+
+  /**
+   * @generated from field: norsk.api.manager.Version worker_image_version = 11;
+   */
+  workerImageVersion = Version.RECOMMENDED;
+
+  /**
+   * @generated from field: norsk.api.manager.Version worker_daemon_version = 12;
+   */
+  workerDaemonVersion = Version.RECOMMENDED;
+
+  constructor(data?: PartialMessage<CreateOciNodeRequest>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.manager.CreateOciNodeRequest";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "node_id", kind: "message", T: NodeId },
+    { no: 2, name: "tags", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
+    { no: 3, name: "availabilityDomain", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "architecture", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 5, name: "shape", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 6, name: "subnet", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 11, name: "worker_image_version", kind: "enum", T: proto3.getEnumType(Version) },
+    { no: 12, name: "worker_daemon_version", kind: "enum", T: proto3.getEnumType(Version) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateOciNodeRequest {
+    return new CreateOciNodeRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateOciNodeRequest {
+    return new CreateOciNodeRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateOciNodeRequest {
+    return new CreateOciNodeRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: CreateOciNodeRequest | PlainMessage<CreateOciNodeRequest> | undefined, b: CreateOciNodeRequest | PlainMessage<CreateOciNodeRequest> | undefined): boolean {
+    return proto3.util.equals(CreateOciNodeRequest, a, b);
+  }
+}
+
 /**
  * @generated from message norsk.api.manager.UpdatePhysicalNodeRequest
  */
@@ -1500,9 +1708,9 @@ export class UpdatePhysicalNodeRequest extends Message<UpdatePhysicalNodeRequest
   id = "";
 
   /**
-   * @generated from field: string norsk_bootstrap_version = 2;
+   * @generated from field: string daemon_version = 2;
    */
-  norskBootstrapVersion = "";
+  daemonVersion = "";
 
   constructor(data?: PartialMessage<UpdatePhysicalNodeRequest>) {
     super();
@@ -1513,7 +1721,7 @@ export class UpdatePhysicalNodeRequest extends Message<UpdatePhysicalNodeRequest
   static readonly typeName = "norsk.api.manager.UpdatePhysicalNodeRequest";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
     { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: "norsk_bootstrap_version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "daemon_version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdatePhysicalNodeRequest {
@@ -1538,7 +1746,7 @@ export class UpdatePhysicalNodeRequest extends Message<UpdatePhysicalNodeRequest
  */
 export class StartJobRequest extends Message<StartJobRequest> {
   /**
-   * @generated from field: norsk.api.manager.JobId job_id = 1;
+   * @generated from field: norsk.api.common.JobId job_id = 1;
    */
   jobId?: JobId;
 
@@ -1548,7 +1756,7 @@ export class StartJobRequest extends Message<StartJobRequest> {
   role = "";
 
   /**
-   * @generated from field: norsk.api.manager.NodeId node_id = 3;
+   * @generated from field: norsk.api.common.NodeId node_id = 3;
    */
   nodeId?: NodeId;
 
@@ -1587,7 +1795,7 @@ export class StartJobRequest extends Message<StartJobRequest> {
  */
 export class StopJobRequest extends Message<StopJobRequest> {
   /**
-   * @generated from field: norsk.api.manager.JobId job_id = 1;
+   * @generated from field: norsk.api.common.JobId job_id = 1;
    */
   jobId?: JobId;
 
@@ -1597,7 +1805,7 @@ export class StopJobRequest extends Message<StopJobRequest> {
   role = "";
 
   /**
-   * @generated from field: norsk.api.manager.NodeId node_id = 3;
+   * @generated from field: norsk.api.common.NodeId node_id = 3;
    */
   nodeId?: NodeId;
 
@@ -1937,45 +2145,287 @@ export class JobFilter extends Message<JobFilter> {
 }
 
 /**
- * @generated from message norsk.api.manager.ManagerActivityStreamRequest
+ * @generated from message norsk.api.manager.EventStreamRequest
  */
-export class ManagerActivityStreamRequest extends Message<ManagerActivityStreamRequest> {
+export class EventStreamRequest extends Message<EventStreamRequest> {
   /**
    * @generated from field: int32 pending_window_s = 1;
    */
   pendingWindowS = 0;
 
+  constructor(data?: PartialMessage<EventStreamRequest>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.manager.EventStreamRequest";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "pending_window_s", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EventStreamRequest {
+    return new EventStreamRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EventStreamRequest {
+    return new EventStreamRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EventStreamRequest {
+    return new EventStreamRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: EventStreamRequest | PlainMessage<EventStreamRequest> | undefined, b: EventStreamRequest | PlainMessage<EventStreamRequest> | undefined): boolean {
+    return proto3.util.equals(EventStreamRequest, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.manager.AwsRegionHealth
+ */
+export class AwsRegionHealth extends Message<AwsRegionHealth> {
   /**
-   * @generated from field: repeated norsk.api.manager.JobFilter job_filter = 2;
+   * @generated from field: string region = 1;
    */
-  jobFilter: JobFilter[] = [];
+  region = "";
 
-  constructor(data?: PartialMessage<ManagerActivityStreamRequest>) {
+  /**
+   * @generated from field: norsk.api.manager.Health health = 2;
+   */
+  health = Health.HEALTHY;
+
+  constructor(data?: PartialMessage<AwsRegionHealth>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.ManagerActivityStreamRequest";
+  static readonly typeName = "norsk.api.manager.AwsRegionHealth";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "pending_window_s", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
-    { no: 2, name: "job_filter", kind: "message", T: JobFilter, repeated: true },
+    { no: 1, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "health", kind: "enum", T: proto3.getEnumType(Health) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsRegionHealth {
+    return new AwsRegionHealth().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsRegionHealth {
+    return new AwsRegionHealth().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsRegionHealth {
+    return new AwsRegionHealth().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AwsRegionHealth | PlainMessage<AwsRegionHealth> | undefined, b: AwsRegionHealth | PlainMessage<AwsRegionHealth> | undefined): boolean {
+    return proto3.util.equals(AwsRegionHealth, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.manager.AwsHealth
+ */
+export class AwsHealth extends Message<AwsHealth> {
+  /**
+   * @generated from field: repeated norsk.api.manager.AwsRegionHealth region_health = 1;
+   */
+  regionHealth: AwsRegionHealth[] = [];
+
+  constructor(data?: PartialMessage<AwsHealth>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.manager.AwsHealth";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "region_health", kind: "message", T: AwsRegionHealth, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsHealth {
+    return new AwsHealth().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsHealth {
+    return new AwsHealth().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsHealth {
+    return new AwsHealth().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AwsHealth | PlainMessage<AwsHealth> | undefined, b: AwsHealth | PlainMessage<AwsHealth> | undefined): boolean {
+    return proto3.util.equals(AwsHealth, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.manager.OciRegionHealth
+ */
+export class OciRegionHealth extends Message<OciRegionHealth> {
+  /**
+   * @generated from field: string availabilityDomain = 1;
+   */
+  availabilityDomain = "";
+
+  /**
+   * @generated from field: norsk.api.manager.Health health = 2;
+   */
+  health = Health.HEALTHY;
+
+  constructor(data?: PartialMessage<OciRegionHealth>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.manager.OciRegionHealth";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "availabilityDomain", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "health", kind: "enum", T: proto3.getEnumType(Health) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OciRegionHealth {
+    return new OciRegionHealth().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OciRegionHealth {
+    return new OciRegionHealth().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OciRegionHealth {
+    return new OciRegionHealth().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: OciRegionHealth | PlainMessage<OciRegionHealth> | undefined, b: OciRegionHealth | PlainMessage<OciRegionHealth> | undefined): boolean {
+    return proto3.util.equals(OciRegionHealth, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.manager.OciHealth
+ */
+export class OciHealth extends Message<OciHealth> {
+  /**
+   * @generated from field: repeated norsk.api.manager.OciRegionHealth region_health = 1;
+   */
+  regionHealth: OciRegionHealth[] = [];
+
+  constructor(data?: PartialMessage<OciHealth>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.manager.OciHealth";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "region_health", kind: "message", T: OciRegionHealth, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OciHealth {
+    return new OciHealth().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OciHealth {
+    return new OciHealth().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OciHealth {
+    return new OciHealth().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: OciHealth | PlainMessage<OciHealth> | undefined, b: OciHealth | PlainMessage<OciHealth> | undefined): boolean {
+    return proto3.util.equals(OciHealth, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.manager.TestHealth
+ */
+export class TestHealth extends Message<TestHealth> {
+  constructor(data?: PartialMessage<TestHealth>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.manager.TestHealth";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TestHealth {
+    return new TestHealth().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TestHealth {
+    return new TestHealth().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TestHealth {
+    return new TestHealth().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: TestHealth | PlainMessage<TestHealth> | undefined, b: TestHealth | PlainMessage<TestHealth> | undefined): boolean {
+    return proto3.util.equals(TestHealth, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.manager.ProviderHealth
+ */
+export class ProviderHealth extends Message<ProviderHealth> {
+  /**
+   * @generated from oneof norsk.api.manager.ProviderHealth.health
+   */
+  health: {
+    /**
+     * @generated from field: norsk.api.manager.AwsHealth aws = 1;
+     */
+    value: AwsHealth;
+    case: "aws";
+  } | {
+    /**
+     * @generated from field: norsk.api.manager.OciHealth oci = 2;
+     */
+    value: OciHealth;
+    case: "oci";
+  } | {
+    /**
+     * @generated from field: norsk.api.manager.TestHealth test = 3;
+     */
+    value: TestHealth;
+    case: "test";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<ProviderHealth>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.manager.ProviderHealth";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "aws", kind: "message", T: AwsHealth, oneof: "health" },
+    { no: 2, name: "oci", kind: "message", T: OciHealth, oneof: "health" },
+    { no: 3, name: "test", kind: "message", T: TestHealth, oneof: "health" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ManagerActivityStreamRequest {
-    return new ManagerActivityStreamRequest().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ProviderHealth {
+    return new ProviderHealth().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ManagerActivityStreamRequest {
-    return new ManagerActivityStreamRequest().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ProviderHealth {
+    return new ProviderHealth().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ManagerActivityStreamRequest {
-    return new ManagerActivityStreamRequest().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ProviderHealth {
+    return new ProviderHealth().fromJsonString(jsonString, options);
   }
 
-  static equals(a: ManagerActivityStreamRequest | PlainMessage<ManagerActivityStreamRequest> | undefined, b: ManagerActivityStreamRequest | PlainMessage<ManagerActivityStreamRequest> | undefined): boolean {
-    return proto3.util.equals(ManagerActivityStreamRequest, a, b);
+  static equals(a: ProviderHealth | PlainMessage<ProviderHealth> | undefined, b: ProviderHealth | PlainMessage<ProviderHealth> | undefined): boolean {
+    return proto3.util.equals(ProviderHealth, a, b);
   }
 }
 
@@ -1983,6 +2433,11 @@ export class ManagerActivityStreamRequest extends Message<ManagerActivityStreamR
  * @generated from message norsk.api.manager.InitialDataComplete
  */
 export class InitialDataComplete extends Message<InitialDataComplete> {
+  /**
+   * @generated from field: repeated norsk.api.manager.ProviderHealth health = 1;
+   */
+  health: ProviderHealth[] = [];
+
   constructor(data?: PartialMessage<InitialDataComplete>) {
     super();
     proto3.util.initPartial(data, this);
@@ -1991,6 +2446,7 @@ export class InitialDataComplete extends Message<InitialDataComplete> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.manager.InitialDataComplete";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "health", kind: "message", T: ProviderHealth, repeated: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InitialDataComplete {
@@ -2011,159 +2467,140 @@ export class InitialDataComplete extends Message<InitialDataComplete> {
 }
 
 /**
- * @generated from message norsk.api.manager.ManagerActivityStreamEvent
+ * @generated from message norsk.api.manager.EventStreamEvent
  */
-export class ManagerActivityStreamEvent extends Message<ManagerActivityStreamEvent> {
+export class EventStreamEvent extends Message<EventStreamEvent> {
   /**
-   * @generated from oneof norsk.api.manager.ManagerActivityStreamEvent.event
+   * @generated from oneof norsk.api.manager.EventStreamEvent.event
    */
   event: {
     /**
-     * @generated from field: norsk.api.manager.InitialDataComplete initial_data_complete = 1;
-     */
-    value: InitialDataComplete;
-    case: "initialDataComplete";
-  } | {
-    /**
-     * @generated from field: norsk.api.manager.JobUpdated job_updated = 2;
-     */
-    value: JobUpdated;
-    case: "jobUpdated";
-  } | {
-    /**
-     * @generated from field: norsk.api.manager.JobPending job_pending = 3;
-     */
-    value: JobPending;
-    case: "jobPending";
-  } | {
-    /**
-     * @generated from field: norsk.api.manager.JobDueToStart job_due_to_start = 4;
-     */
-    value: JobDueToStart;
-    case: "jobDueToStart";
-  } | {
-    /**
-     * @generated from field: norsk.api.manager.JobInstanceStarting job_instance_starting = 5;
+     * Only sent before initial_data_complete
+     *
+     * @generated from field: norsk.api.manager.NodeRunning node_running = 1;
      */
-    value: JobInstanceStarting;
-    case: "jobInstanceStarting";
+    value: NodeRunning;
+    case: "nodeRunning";
   } | {
     /**
-     * @generated from field: norsk.api.manager.JobInstanceStarted job_instance_started = 6;
+     * Only sent before initial_data_complete
+     *
+     * @generated from field: norsk.api.manager.JobActive job_active = 2;
      */
-    value: JobInstanceStarted;
-    case: "jobInstanceStarted";
+    value: JobActive;
+    case: "jobActive";
   } | {
     /**
-     * @generated from field: norsk.api.manager.JobDueToStop job_due_to_stop = 7;
+     * @generated from field: norsk.api.manager.InitialDataComplete initial_data_complete = 3;
      */
-    value: JobDueToStop;
-    case: "jobDueToStop";
+    value: InitialDataComplete;
+    case: "initialDataComplete";
   } | {
     /**
-     * @generated from field: norsk.api.manager.JobInstanceStopping job_instance_stopping = 8;
+     * @generated from field: norsk.api.manager.JobUpdated job_updated = 4;
      */
-    value: JobInstanceStopping;
-    case: "jobInstanceStopping";
+    value: JobUpdated;
+    case: "jobUpdated";
   } | {
     /**
-     * @generated from field: norsk.api.manager.JobInstanceStopped job_instance_stopped = 9;
+     * @generated from field: norsk.api.manager.JobDeleted job_deleted = 5;
      */
-    value: JobInstanceStopped;
-    case: "jobInstanceStopped";
+    value: JobDeleted;
+    case: "jobDeleted";
   } | {
     /**
-     * @generated from field: norsk.api.manager.JobInstanceFailed job_instance_failed = 10;
+     * @generated from field: norsk.api.manager.JobPending job_pending = 6;
      */
-    value: JobInstanceFailed;
-    case: "jobInstanceFailed";
+    value: JobPending;
+    case: "jobPending";
   } | {
     /**
-     * Only sent before initial_data_complete
-     *
-     * @generated from field: norsk.api.manager.NodeRunning node_running = 11;
+     * @generated from field: norsk.api.manager.JobOutOfWindow job_out_of_window = 7;
      */
-    value: NodeRunning;
-    case: "nodeRunning";
+    value: JobOutOfWindow;
+    case: "jobOutOfWindow";
   } | {
     /**
-     * @generated from field: norsk.api.manager.NodeStarting node_starting = 12;
+     * @generated from field: norsk.api.manager.NodeStarting node_starting = 8;
      */
     value: NodeStarting;
     case: "nodeStarting";
   } | {
     /**
-     * @generated from field: norsk.api.manager.NodeStarted node_started = 13;
+     * @generated from field: norsk.api.manager.NodeStarted node_started = 9;
      */
     value: NodeStarted;
     case: "nodeStarted";
   } | {
     /**
-     * @generated from field: norsk.api.manager.NodeStopping node_stopping = 14;
+     * @generated from field: norsk.api.manager.NodeStopping node_stopping = 10;
      */
     value: NodeStopping;
     case: "nodeStopping";
   } | {
     /**
-     * @generated from field: norsk.api.manager.NodeStopped node_stopped = 15;
+     * @generated from field: norsk.api.manager.NodeStopped node_stopped = 11;
      */
     value: NodeStopped;
     case: "nodeStopped";
   } | {
     /**
-     * @generated from field: norsk.api.manager.NodeFailed node_failed = 16;
+     * @generated from field: norsk.api.manager.PhysicalNodeConnected physical_node_connected = 12;
      */
-    value: NodeFailed;
-    case: "nodeFailed";
+    value: PhysicalNodeConnected;
+    case: "physicalNodeConnected";
   } | {
     /**
-     * @generated from field: norsk.api.manager.PhysicalNodeConnected physical_node_connected = 17;
+     * @generated from field: norsk.api.manager.ProviderHealth provider_health_change = 13;
      */
-    value: PhysicalNodeConnected;
-    case: "physicalNodeConnected";
+    value: ProviderHealth;
+    case: "providerHealthChange";
+  } | {
+    /**
+     * @generated from field: norsk.api.common.JobInfoMessage job_info = 14;
+     */
+    value: JobInfoMessage;
+    case: "jobInfo";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
-  constructor(data?: PartialMessage<ManagerActivityStreamEvent>) {
+  constructor(data?: PartialMessage<EventStreamEvent>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.manager.ManagerActivityStreamEvent";
+  static readonly typeName = "norsk.api.manager.EventStreamEvent";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "initial_data_complete", kind: "message", T: InitialDataComplete, oneof: "event" },
-    { no: 2, name: "job_updated", kind: "message", T: JobUpdated, oneof: "event" },
-    { no: 3, name: "job_pending", kind: "message", T: JobPending, oneof: "event" },
-    { no: 4, name: "job_due_to_start", kind: "message", T: JobDueToStart, oneof: "event" },
-    { no: 5, name: "job_instance_starting", kind: "message", T: JobInstanceStarting, oneof: "event" },
-    { no: 6, name: "job_instance_started", kind: "message", T: JobInstanceStarted, oneof: "event" },
-    { no: 7, name: "job_due_to_stop", kind: "message", T: JobDueToStop, oneof: "event" },
-    { no: 8, name: "job_instance_stopping", kind: "message", T: JobInstanceStopping, oneof: "event" },
-    { no: 9, name: "job_instance_stopped", kind: "message", T: JobInstanceStopped, oneof: "event" },
-    { no: 10, name: "job_instance_failed", kind: "message", T: JobInstanceFailed, oneof: "event" },
-    { no: 11, name: "node_running", kind: "message", T: NodeRunning, oneof: "event" },
-    { no: 12, name: "node_starting", kind: "message", T: NodeStarting, oneof: "event" },
-    { no: 13, name: "node_started", kind: "message", T: NodeStarted, oneof: "event" },
-    { no: 14, name: "node_stopping", kind: "message", T: NodeStopping, oneof: "event" },
-    { no: 15, name: "node_stopped", kind: "message", T: NodeStopped, oneof: "event" },
-    { no: 16, name: "node_failed", kind: "message", T: NodeFailed, oneof: "event" },
-    { no: 17, name: "physical_node_connected", kind: "message", T: PhysicalNodeConnected, oneof: "event" },
+    { no: 1, name: "node_running", kind: "message", T: NodeRunning, oneof: "event" },
+    { no: 2, name: "job_active", kind: "message", T: JobActive, oneof: "event" },
+    { no: 3, name: "initial_data_complete", kind: "message", T: InitialDataComplete, oneof: "event" },
+    { no: 4, name: "job_updated", kind: "message", T: JobUpdated, oneof: "event" },
+    { no: 5, name: "job_deleted", kind: "message", T: JobDeleted, oneof: "event" },
+    { no: 6, name: "job_pending", kind: "message", T: JobPending, oneof: "event" },
+    { no: 7, name: "job_out_of_window", kind: "message", T: JobOutOfWindow, oneof: "event" },
+    { no: 8, name: "node_starting", kind: "message", T: NodeStarting, oneof: "event" },
+    { no: 9, name: "node_started", kind: "message", T: NodeStarted, oneof: "event" },
+    { no: 10, name: "node_stopping", kind: "message", T: NodeStopping, oneof: "event" },
+    { no: 11, name: "node_stopped", kind: "message", T: NodeStopped, oneof: "event" },
+    { no: 12, name: "physical_node_connected", kind: "message", T: PhysicalNodeConnected, oneof: "event" },
+    { no: 13, name: "provider_health_change", kind: "message", T: ProviderHealth, oneof: "event" },
+    { no: 14, name: "job_info", kind: "message", T: JobInfoMessage, oneof: "event" },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ManagerActivityStreamEvent {
-    return new ManagerActivityStreamEvent().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EventStreamEvent {
+    return new EventStreamEvent().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ManagerActivityStreamEvent {
-    return new ManagerActivityStreamEvent().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EventStreamEvent {
+    return new EventStreamEvent().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ManagerActivityStreamEvent {
-    return new ManagerActivityStreamEvent().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EventStreamEvent {
+    return new EventStreamEvent().fromJsonString(jsonString, options);
   }
 
-  static equals(a: ManagerActivityStreamEvent | PlainMessage<ManagerActivityStreamEvent> | undefined, b: ManagerActivityStreamEvent | PlainMessage<ManagerActivityStreamEvent> | undefined): boolean {
-    return proto3.util.equals(ManagerActivityStreamEvent, a, b);
+  static equals(a: EventStreamEvent | PlainMessage<EventStreamEvent> | undefined, b: EventStreamEvent | PlainMessage<EventStreamEvent> | undefined): boolean {
+    return proto3.util.equals(EventStreamEvent, a, b);
   }
 }