@norskvideo/norsk-api 1.0.345 → 1.0.346

package/lib/shared/common_pb.ts

@@ -4,7 +4,201 @@
 // @ts-nocheck
 
 import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
-import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
+import { Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf";
+
+/**
+ * @generated from enum norsk.api.common.Architecture
+ */
+export enum Architecture {
+  /**
+   * @generated from enum value: X86_64 = 0;
+   */
+  X86_64 = 0,
+
+  /**
+   * @generated from enum value: AARCH_64 = 1;
+   */
+  AARCH_64 = 1,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Architecture)
+proto3.util.setEnumType(Architecture, "norsk.api.common.Architecture", [
+  { no: 0, name: "X86_64" },
+  { no: 1, name: "AARCH_64" },
+]);
+
+/**
+ * @generated from enum norsk.api.common.ProtocolFamily
+ */
+export enum ProtocolFamily {
+  /**
+   * @generated from enum value: ANY = 0;
+   */
+  ANY = 0,
+
+  /**
+   * @generated from enum value: UDP = 1;
+   */
+  UDP = 1,
+
+  /**
+   * @generated from enum value: TCP = 2;
+   */
+  TCP = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(ProtocolFamily)
+proto3.util.setEnumType(ProtocolFamily, "norsk.api.common.ProtocolFamily", [
+  { no: 0, name: "ANY" },
+  { no: 1, name: "UDP" },
+  { no: 2, name: "TCP" },
+]);
+
+/**
+ * @generated from message norsk.api.common.OptionalInt
+ */
+export class OptionalInt extends Message<OptionalInt> {
+  /**
+   * @generated from field: uint32 value = 1;
+   */
+  value = 0;
+
+  constructor(data?: PartialMessage<OptionalInt>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.OptionalInt";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "value", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OptionalInt {
+    return new OptionalInt().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OptionalInt {
+    return new OptionalInt().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OptionalInt {
+    return new OptionalInt().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: OptionalInt | PlainMessage<OptionalInt> | undefined, b: OptionalInt | PlainMessage<OptionalInt> | undefined): boolean {
+    return proto3.util.equals(OptionalInt, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.OptionalInt64
+ */
+export class OptionalInt64 extends Message<OptionalInt64> {
+  /**
+   * @generated from field: uint64 value = 1;
+   */
+  value = protoInt64.zero;
+
+  constructor(data?: PartialMessage<OptionalInt64>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.OptionalInt64";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "value", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OptionalInt64 {
+    return new OptionalInt64().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OptionalInt64 {
+    return new OptionalInt64().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OptionalInt64 {
+    return new OptionalInt64().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: OptionalInt64 | PlainMessage<OptionalInt64> | undefined, b: OptionalInt64 | PlainMessage<OptionalInt64> | undefined): boolean {
+    return proto3.util.equals(OptionalInt64, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.OptionalBool
+ */
+export class OptionalBool extends Message<OptionalBool> {
+  /**
+   * @generated from field: bool value = 1;
+   */
+  value = false;
+
+  constructor(data?: PartialMessage<OptionalBool>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.OptionalBool";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "value", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OptionalBool {
+    return new OptionalBool().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OptionalBool {
+    return new OptionalBool().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OptionalBool {
+    return new OptionalBool().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: OptionalBool | PlainMessage<OptionalBool> | undefined, b: OptionalBool | PlainMessage<OptionalBool> | undefined): boolean {
+    return proto3.util.equals(OptionalBool, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.OptionalString
+ */
+export class OptionalString extends Message<OptionalString> {
+  /**
+   * @generated from field: string value = 1;
+   */
+  value = "";
+
+  constructor(data?: PartialMessage<OptionalString>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.OptionalString";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "value", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OptionalString {
+    return new OptionalString().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OptionalString {
+    return new OptionalString().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OptionalString {
+    return new OptionalString().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: OptionalString | PlainMessage<OptionalString> | undefined, b: OptionalString | PlainMessage<OptionalString> | undefined): boolean {
+    return proto3.util.equals(OptionalString, a, b);
+  }
+}
 
 /**
  * `Version` gives version information about the currently running Norsk release
@@ -228,113 +422,1560 @@ export class CurrentLoad extends Message<CurrentLoad> {
 }
 
 /**
- * @generated from message norsk.api.common.Log
+ * @generated from message norsk.api.common.AwsMetadata
  */
-export class Log extends Message<Log> {
+export class AwsMetadata extends Message<AwsMetadata> {
   /**
-   * @generated from field: norsk.api.common.Log.Level level = 1;
+   * @generated from field: string instance_type = 1;
    */
-  level = Log_Level.EMERGENCY;
+  instanceType = "";
 
   /**
-   * @generated from field: uint64 timestamp = 2;
+   * @generated from field: string region = 2;
    */
-  timestamp = protoInt64.zero;
+  region = "";
 
   /**
-   * @generated from field: string msg = 3;
+   * @generated from field: norsk.api.common.Architecture architecture = 3;
    */
-  msg = "";
+  architecture = Architecture.X86_64;
 
-  /**
-   * @generated from field: string metadata = 4;
-   */
-  metadata = "";
+  constructor(data?: PartialMessage<AwsMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
 
-  constructor(data?: PartialMessage<Log>) {
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.AwsMetadata";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "instance_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "region", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "architecture", kind: "enum", T: proto3.getEnumType(Architecture) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AwsMetadata {
+    return new AwsMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AwsMetadata {
+    return new AwsMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AwsMetadata {
+    return new AwsMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AwsMetadata | PlainMessage<AwsMetadata> | undefined, b: AwsMetadata | PlainMessage<AwsMetadata> | undefined): boolean {
+    return proto3.util.equals(AwsMetadata, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.OciMetadata
+ */
+export class OciMetadata extends Message<OciMetadata> {
+  constructor(data?: PartialMessage<OciMetadata>) {
     super();
     proto3.util.initPartial(data, this);
   }
 
   static readonly runtime = proto3;
-  static readonly typeName = "norsk.api.common.Log";
+  static readonly typeName = "norsk.api.common.OciMetadata";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: "level", kind: "enum", T: proto3.getEnumType(Log_Level) },
-    { no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
-    { no: 3, name: "msg", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-    { no: 4, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Log {
-    return new Log().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OciMetadata {
+    return new OciMetadata().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Log {
-    return new Log().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OciMetadata {
+    return new OciMetadata().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Log {
-    return new Log().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OciMetadata {
+    return new OciMetadata().fromJsonString(jsonString, options);
   }
 
-  static equals(a: Log | PlainMessage<Log> | undefined, b: Log | PlainMessage<Log> | undefined): boolean {
-    return proto3.util.equals(Log, a, b);
+  static equals(a: OciMetadata | PlainMessage<OciMetadata> | undefined, b: OciMetadata | PlainMessage<OciMetadata> | undefined): boolean {
+    return proto3.util.equals(OciMetadata, a, b);
   }
 }
 
 /**
- * @generated from enum norsk.api.common.Log.Level
+ * @generated from message norsk.api.common.TestMetadata
  */
-export enum Log_Level {
-  /**
-   * @generated from enum value: EMERGENCY = 0;
-   */
-  EMERGENCY = 0,
+export class TestMetadata extends Message<TestMetadata> {
+  constructor(data?: PartialMessage<TestMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
 
-  /**
-   * @generated from enum value: ALERT = 1;
-   */
-  ALERT = 1,
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.TestMetadata";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TestMetadata {
+    return new TestMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TestMetadata {
+    return new TestMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TestMetadata {
+    return new TestMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: TestMetadata | PlainMessage<TestMetadata> | undefined, b: TestMetadata | PlainMessage<TestMetadata> | undefined): boolean {
+    return proto3.util.equals(TestMetadata, a, b);
+  }
+}
 
+/**
+ * @generated from message norsk.api.common.ProviderMetadata
+ */
+export class ProviderMetadata extends Message<ProviderMetadata> {
   /**
-   * @generated from enum value: CRITICAL = 2;
+   * @generated from oneof norsk.api.common.ProviderMetadata.metadata
    */
-  CRITICAL = 2,
+  metadata: {
+    /**
+     * @generated from field: norsk.api.common.AwsMetadata aws = 1;
+     */
+    value: AwsMetadata;
+    case: "aws";
+  } | {
+    /**
+     * @generated from field: norsk.api.common.OciMetadata oci = 2;
+     */
+    value: OciMetadata;
+    case: "oci";
+  } | {
+    /**
+     * @generated from field: norsk.api.common.TestMetadata test = 3;
+     */
+    value: TestMetadata;
+    case: "test";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<ProviderMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.ProviderMetadata";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "aws", kind: "message", T: AwsMetadata, oneof: "metadata" },
+    { no: 2, name: "oci", kind: "message", T: OciMetadata, oneof: "metadata" },
+    { no: 3, name: "test", kind: "message", T: TestMetadata, oneof: "metadata" },
+  ]);
 
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ProviderMetadata {
+    return new ProviderMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ProviderMetadata {
+    return new ProviderMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ProviderMetadata {
+    return new ProviderMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ProviderMetadata | PlainMessage<ProviderMetadata> | undefined, b: ProviderMetadata | PlainMessage<ProviderMetadata> | undefined): boolean {
+    return proto3.util.equals(ProviderMetadata, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.NodeMetadata
+ */
+export class NodeMetadata extends Message<NodeMetadata> {
   /**
-   * @generated from enum value: ERROR = 3;
+   * @generated from field: norsk.api.common.NodeId node_id = 1;
    */
-  ERROR = 3,
+  nodeId?: NodeId;
 
   /**
-   * @generated from enum value: WARNING = 4;
+   * @generated from field: map<string, string> tags = 2;
    */
-  WARNING = 4,
+  tags: { [key: string]: string } = {};
 
   /**
-   * @generated from enum value: NOTICE = 5;
+   * @generated from field: google.protobuf.Timestamp created_at = 3;
    */
-  NOTICE = 5,
+  createdAt?: Timestamp;
 
   /**
-   * @generated from enum value: INFO = 6;
+   * @generated from field: norsk.api.common.ProviderMetadata provider_metadata = 4;
    */
-  INFO = 6,
+  providerMetadata?: ProviderMetadata;
+
+  constructor(data?: PartialMessage<NodeMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.NodeMetadata";
+  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: "created_at", kind: "message", T: Timestamp },
+    { no: 4, name: "provider_metadata", kind: "message", T: ProviderMetadata },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NodeMetadata {
+    return new NodeMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NodeMetadata {
+    return new NodeMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NodeMetadata {
+    return new NodeMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: NodeMetadata | PlainMessage<NodeMetadata> | undefined, b: NodeMetadata | PlainMessage<NodeMetadata> | undefined): boolean {
+    return proto3.util.equals(NodeMetadata, a, b);
+  }
+}
 
+/**
+ * @generated from message norsk.api.common.RunningAwsMetadata
+ */
+export class RunningAwsMetadata extends Message<RunningAwsMetadata> {
   /**
-   * @generated from enum value: DEBUG = 7;
+   * @generated from field: string instance_id = 1;
    */
-  DEBUG = 7,
+  instanceId = "";
+
+  constructor(data?: PartialMessage<RunningAwsMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.RunningAwsMetadata";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "instance_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RunningAwsMetadata {
+    return new RunningAwsMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RunningAwsMetadata {
+    return new RunningAwsMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RunningAwsMetadata {
+    return new RunningAwsMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: RunningAwsMetadata | PlainMessage<RunningAwsMetadata> | undefined, b: RunningAwsMetadata | PlainMessage<RunningAwsMetadata> | undefined): boolean {
+    return proto3.util.equals(RunningAwsMetadata, a, b);
+  }
 }
-// Retrieve enum metadata with: proto3.getEnumType(Log_Level)
-proto3.util.setEnumType(Log_Level, "norsk.api.common.Log.Level", [
-  { no: 0, name: "EMERGENCY" },
-  { no: 1, name: "ALERT" },
-  { no: 2, name: "CRITICAL" },
-  { no: 3, name: "ERROR" },
-  { no: 4, name: "WARNING" },
-  { no: 5, name: "NOTICE" },
+
+/**
+ * @generated from message norsk.api.common.RunningOciMetadata
+ */
+export class RunningOciMetadata extends Message<RunningOciMetadata> {
+  constructor(data?: PartialMessage<RunningOciMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.RunningOciMetadata";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RunningOciMetadata {
+    return new RunningOciMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RunningOciMetadata {
+    return new RunningOciMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RunningOciMetadata {
+    return new RunningOciMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: RunningOciMetadata | PlainMessage<RunningOciMetadata> | undefined, b: RunningOciMetadata | PlainMessage<RunningOciMetadata> | undefined): boolean {
+    return proto3.util.equals(RunningOciMetadata, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.RunningTestMetadata
+ */
+export class RunningTestMetadata extends Message<RunningTestMetadata> {
+  constructor(data?: PartialMessage<RunningTestMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.RunningTestMetadata";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RunningTestMetadata {
+    return new RunningTestMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RunningTestMetadata {
+    return new RunningTestMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RunningTestMetadata {
+    return new RunningTestMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: RunningTestMetadata | PlainMessage<RunningTestMetadata> | undefined, b: RunningTestMetadata | PlainMessage<RunningTestMetadata> | undefined): boolean {
+    return proto3.util.equals(RunningTestMetadata, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.RunningNodeProviderMetadata
+ */
+export class RunningNodeProviderMetadata extends Message<RunningNodeProviderMetadata> {
+  /**
+   * @generated from oneof norsk.api.common.RunningNodeProviderMetadata.instance
+   */
+  instance: {
+    /**
+     * @generated from field: norsk.api.common.RunningAwsMetadata aws = 1;
+     */
+    value: RunningAwsMetadata;
+    case: "aws";
+  } | {
+    /**
+     * @generated from field: norsk.api.common.RunningOciMetadata oci = 2;
+     */
+    value: RunningOciMetadata;
+    case: "oci";
+  } | {
+    /**
+     * @generated from field: norsk.api.common.RunningTestMetadata test = 3;
+     */
+    value: RunningTestMetadata;
+    case: "test";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<RunningNodeProviderMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.RunningNodeProviderMetadata";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "aws", kind: "message", T: RunningAwsMetadata, oneof: "instance" },
+    { no: 2, name: "oci", kind: "message", T: RunningOciMetadata, oneof: "instance" },
+    { no: 3, name: "test", kind: "message", T: RunningTestMetadata, oneof: "instance" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RunningNodeProviderMetadata {
+    return new RunningNodeProviderMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RunningNodeProviderMetadata {
+    return new RunningNodeProviderMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RunningNodeProviderMetadata {
+    return new RunningNodeProviderMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: RunningNodeProviderMetadata | PlainMessage<RunningNodeProviderMetadata> | undefined, b: RunningNodeProviderMetadata | PlainMessage<RunningNodeProviderMetadata> | undefined): boolean {
+    return proto3.util.equals(RunningNodeProviderMetadata, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.RunningNodeMetadata
+ */
+export class RunningNodeMetadata extends Message<RunningNodeMetadata> {
+  /**
+   * @generated from field: string public_dns_name = 1;
+   */
+  publicDnsName = "";
+
+  /**
+   * @generated from field: string private_dns_name = 2;
+   */
+  privateDnsName = "";
+
+  /**
+   * @generated from field: string private_ip_address = 3;
+   */
+  privateIpAddress = "";
+
+  /**
+   * @generated from field: norsk.api.common.RunningNodeProviderMetadata provider_metadata = 4;
+   */
+  providerMetadata?: RunningNodeProviderMetadata;
+
+  constructor(data?: PartialMessage<RunningNodeMetadata>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.RunningNodeMetadata";
+  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: 4, name: "provider_metadata", kind: "message", T: RunningNodeProviderMetadata },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RunningNodeMetadata {
+    return new RunningNodeMetadata().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RunningNodeMetadata {
+    return new RunningNodeMetadata().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RunningNodeMetadata {
+    return new RunningNodeMetadata().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: RunningNodeMetadata | PlainMessage<RunningNodeMetadata> | undefined, b: RunningNodeMetadata | PlainMessage<RunningNodeMetadata> | undefined): boolean {
+    return proto3.util.equals(RunningNodeMetadata, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.NodeId
+ */
+export class NodeId extends Message<NodeId> {
+  /**
+   * @generated from field: string node_id = 1;
+   */
+  nodeId = "";
+
+  constructor(data?: PartialMessage<NodeId>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.NodeId";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "node_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NodeId {
+    return new NodeId().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NodeId {
+    return new NodeId().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NodeId {
+    return new NodeId().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: NodeId | PlainMessage<NodeId> | undefined, b: NodeId | PlainMessage<NodeId> | undefined): boolean {
+    return proto3.util.equals(NodeId, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.JobId
+ */
+export class JobId extends Message<JobId> {
+  /**
+   * @generated from field: string job_id = 1;
+   */
+  jobId = "";
+
+  constructor(data?: PartialMessage<JobId>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.JobId";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "job_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobId {
+    return new JobId().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobId {
+    return new JobId().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobId {
+    return new JobId().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: JobId | PlainMessage<JobId> | undefined, b: JobId | PlainMessage<JobId> | undefined): boolean {
+    return proto3.util.equals(JobId, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.ActiveJobKey
+ */
+export class ActiveJobKey extends Message<ActiveJobKey> {
+  /**
+   * @generated from field: norsk.api.common.JobId jobId = 1;
+   */
+  jobId?: JobId;
+
+  /**
+   * @generated from field: string role = 2;
+   */
+  role = "";
+
+  constructor(data?: PartialMessage<ActiveJobKey>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.ActiveJobKey";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "jobId", kind: "message", T: JobId },
+    { no: 2, name: "role", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ActiveJobKey {
+    return new ActiveJobKey().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ActiveJobKey {
+    return new ActiveJobKey().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ActiveJobKey {
+    return new ActiveJobKey().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ActiveJobKey | PlainMessage<ActiveJobKey> | undefined, b: ActiveJobKey | PlainMessage<ActiveJobKey> | undefined): boolean {
+    return proto3.util.equals(ActiveJobKey, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.ContainerUrl
+ */
+export class ContainerUrl extends Message<ContainerUrl> {
+  /**
+   * @generated from field: string url = 1;
+   */
+  url = "";
+
+  constructor(data?: PartialMessage<ContainerUrl>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.ContainerUrl";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ContainerUrl {
+    return new ContainerUrl().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ContainerUrl {
+    return new ContainerUrl().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ContainerUrl {
+    return new ContainerUrl().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ContainerUrl | PlainMessage<ContainerUrl> | undefined, b: ContainerUrl | PlainMessage<ContainerUrl> | undefined): boolean {
+    return proto3.util.equals(ContainerUrl, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.DockerContainer
+ */
+export class DockerContainer extends Message<DockerContainer> {
+  /**
+   * @generated from field: norsk.api.common.ContainerUrl container_url = 1;
+   */
+  containerUrl?: ContainerUrl;
+
+  constructor(data?: PartialMessage<DockerContainer>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.DockerContainer";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "container_url", kind: "message", T: ContainerUrl },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DockerContainer {
+    return new DockerContainer().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DockerContainer {
+    return new DockerContainer().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DockerContainer {
+    return new DockerContainer().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: DockerContainer | PlainMessage<DockerContainer> | undefined, b: DockerContainer | PlainMessage<DockerContainer> | undefined): boolean {
+    return proto3.util.equals(DockerContainer, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.Log
+ */
+export class Log extends Message<Log> {
+  /**
+   * @generated from field: norsk.api.common.Log.Level level = 1;
+   */
+  level = Log_Level.EMERGENCY;
+
+  /**
+   * @generated from field: uint64 timestamp = 2;
+   */
+  timestamp = protoInt64.zero;
+
+  /**
+   * @generated from field: string msg = 3;
+   */
+  msg = "";
+
+  /**
+   * @generated from field: string metadata = 4;
+   */
+  metadata = "";
+
+  constructor(data?: PartialMessage<Log>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.Log";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "level", kind: "enum", T: proto3.getEnumType(Log_Level) },
+    { no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+    { no: 3, name: "msg", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Log {
+    return new Log().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Log {
+    return new Log().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Log {
+    return new Log().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Log | PlainMessage<Log> | undefined, b: Log | PlainMessage<Log> | undefined): boolean {
+    return proto3.util.equals(Log, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.common.Log.Level
+ */
+export enum Log_Level {
+  /**
+   * @generated from enum value: EMERGENCY = 0;
+   */
+  EMERGENCY = 0,
+
+  /**
+   * @generated from enum value: ALERT = 1;
+   */
+  ALERT = 1,
+
+  /**
+   * @generated from enum value: CRITICAL = 2;
+   */
+  CRITICAL = 2,
+
+  /**
+   * @generated from enum value: ERROR = 3;
+   */
+  ERROR = 3,
+
+  /**
+   * @generated from enum value: WARNING = 4;
+   */
+  WARNING = 4,
+
+  /**
+   * @generated from enum value: NOTICE = 5;
+   */
+  NOTICE = 5,
+
+  /**
+   * @generated from enum value: INFO = 6;
+   */
+  INFO = 6,
+
+  /**
+   * @generated from enum value: DEBUG = 7;
+   */
+  DEBUG = 7,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Log_Level)
+proto3.util.setEnumType(Log_Level, "norsk.api.common.Log.Level", [
+  { no: 0, name: "EMERGENCY" },
+  { no: 1, name: "ALERT" },
+  { no: 2, name: "CRITICAL" },
+  { no: 3, name: "ERROR" },
+  { no: 4, name: "WARNING" },
+  { no: 5, name: "NOTICE" },
   { no: 6, name: "INFO" },
   { no: 7, name: "DEBUG" },
 ]);
 
+/**
+ * @generated from message norsk.api.common.HostPortEphemeral
+ */
+export class HostPortEphemeral extends Message<HostPortEphemeral> {
+  constructor(data?: PartialMessage<HostPortEphemeral>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.HostPortEphemeral";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HostPortEphemeral {
+    return new HostPortEphemeral().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HostPortEphemeral {
+    return new HostPortEphemeral().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HostPortEphemeral {
+    return new HostPortEphemeral().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: HostPortEphemeral | PlainMessage<HostPortEphemeral> | undefined, b: HostPortEphemeral | PlainMessage<HostPortEphemeral> | undefined): boolean {
+    return proto3.util.equals(HostPortEphemeral, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.HostPortRange
+ */
+export class HostPortRange extends Message<HostPortRange> {
+  /**
+   * @generated from field: uint32 min_port = 1;
+   */
+  minPort = 0;
+
+  /**
+   * @generated from field: uint32 max_port = 2;
+   */
+  maxPort = 0;
+
+  constructor(data?: PartialMessage<HostPortRange>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.HostPortRange";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "min_port", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "max_port", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HostPortRange {
+    return new HostPortRange().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HostPortRange {
+    return new HostPortRange().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HostPortRange {
+    return new HostPortRange().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: HostPortRange | PlainMessage<HostPortRange> | undefined, b: HostPortRange | PlainMessage<HostPortRange> | undefined): boolean {
+    return proto3.util.equals(HostPortRange, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.HostPortSpecific
+ */
+export class HostPortSpecific extends Message<HostPortSpecific> {
+  /**
+   * @generated from field: uint32 port = 1;
+   */
+  port = 0;
+
+  constructor(data?: PartialMessage<HostPortSpecific>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.HostPortSpecific";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "port", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HostPortSpecific {
+    return new HostPortSpecific().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HostPortSpecific {
+    return new HostPortSpecific().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HostPortSpecific {
+    return new HostPortSpecific().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: HostPortSpecific | PlainMessage<HostPortSpecific> | undefined, b: HostPortSpecific | PlainMessage<HostPortSpecific> | undefined): boolean {
+    return proto3.util.equals(HostPortSpecific, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.PortMapping
+ */
+export class PortMapping extends Message<PortMapping> {
+  /**
+   * @generated from field: uint32 container_port = 1;
+   */
+  containerPort = 0;
+
+  /**
+   * @generated from field: norsk.api.common.ProtocolFamily protocol = 2;
+   */
+  protocol = ProtocolFamily.ANY;
+
+  /**
+   * @generated from oneof norsk.api.common.PortMapping.host_port
+   */
+  hostPort: {
+    /**
+     * @generated from field: norsk.api.common.HostPortEphemeral ephemeral = 3;
+     */
+    value: HostPortEphemeral;
+    case: "ephemeral";
+  } | {
+    /**
+     * @generated from field: norsk.api.common.HostPortRange range = 4;
+     */
+    value: HostPortRange;
+    case: "range";
+  } | {
+    /**
+     * @generated from field: norsk.api.common.HostPortSpecific specific = 5;
+     */
+    value: HostPortSpecific;
+    case: "specific";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  /**
+   * @generated from field: string host_address = 6;
+   */
+  hostAddress = "";
+
+  constructor(data?: PartialMessage<PortMapping>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.PortMapping";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "container_port", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 2, name: "protocol", kind: "enum", T: proto3.getEnumType(ProtocolFamily) },
+    { no: 3, name: "ephemeral", kind: "message", T: HostPortEphemeral, oneof: "host_port" },
+    { no: 4, name: "range", kind: "message", T: HostPortRange, oneof: "host_port" },
+    { no: 5, name: "specific", kind: "message", T: HostPortSpecific, oneof: "host_port" },
+    { no: 6, name: "host_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PortMapping {
+    return new PortMapping().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PortMapping {
+    return new PortMapping().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PortMapping {
+    return new PortMapping().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: PortMapping | PlainMessage<PortMapping> | undefined, b: PortMapping | PlainMessage<PortMapping> | undefined): boolean {
+    return proto3.util.equals(PortMapping, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.ResolvedPortMapping
+ */
+export class ResolvedPortMapping extends Message<ResolvedPortMapping> {
+  /**
+   * @generated from field: string url = 1;
+   */
+  url = "";
+
+  /**
+   * @generated from field: uint32 target = 2;
+   */
+  target = 0;
+
+  /**
+   * @generated from field: uint32 published = 3;
+   */
+  published = 0;
+
+  /**
+   * @generated from field: norsk.api.common.ProtocolFamily protocol = 4;
+   */
+  protocol = ProtocolFamily.ANY;
+
+  constructor(data?: PartialMessage<ResolvedPortMapping>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.ResolvedPortMapping";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "target", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 3, name: "published", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 4, name: "protocol", kind: "enum", T: proto3.getEnumType(ProtocolFamily) },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResolvedPortMapping {
+    return new ResolvedPortMapping().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResolvedPortMapping {
+    return new ResolvedPortMapping().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResolvedPortMapping {
+    return new ResolvedPortMapping().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ResolvedPortMapping | PlainMessage<ResolvedPortMapping> | undefined, b: ResolvedPortMapping | PlainMessage<ResolvedPortMapping> | undefined): boolean {
+    return proto3.util.equals(ResolvedPortMapping, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.ResolvedPortMappings
+ */
+export class ResolvedPortMappings extends Message<ResolvedPortMappings> {
+  /**
+   * @generated from field: repeated norsk.api.common.ResolvedPortMapping mappings = 1;
+   */
+  mappings: ResolvedPortMapping[] = [];
+
+  constructor(data?: PartialMessage<ResolvedPortMappings>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.ResolvedPortMappings";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "mappings", kind: "message", T: ResolvedPortMapping, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResolvedPortMappings {
+    return new ResolvedPortMappings().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResolvedPortMappings {
+    return new ResolvedPortMappings().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResolvedPortMappings {
+    return new ResolvedPortMappings().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ResolvedPortMappings | PlainMessage<ResolvedPortMappings> | undefined, b: ResolvedPortMappings | PlainMessage<ResolvedPortMappings> | undefined): boolean {
+    return proto3.util.equals(ResolvedPortMappings, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.EnvironmentVariable
+ */
+export class EnvironmentVariable extends Message<EnvironmentVariable> {
+  /**
+   * @generated from field: string name = 1;
+   */
+  name = "";
+
+  /**
+   * @generated from field: string value = 2;
+   */
+  value = "";
+
+  constructor(data?: PartialMessage<EnvironmentVariable>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.EnvironmentVariable";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "value", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EnvironmentVariable {
+    return new EnvironmentVariable().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EnvironmentVariable {
+    return new EnvironmentVariable().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EnvironmentVariable {
+    return new EnvironmentVariable().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: EnvironmentVariable | PlainMessage<EnvironmentVariable> | undefined, b: EnvironmentVariable | PlainMessage<EnvironmentVariable> | undefined): boolean {
+    return proto3.util.equals(EnvironmentVariable, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.VolumeMount
+ */
+export class VolumeMount extends Message<VolumeMount> {
+  /**
+   * @generated from field: string volume_name = 1;
+   */
+  volumeName = "";
+
+  /**
+   * @generated from field: string container_path = 2;
+   */
+  containerPath = "";
+
+  /**
+   * @generated from field: bool read_only = 3;
+   */
+  readOnly = false;
+
+  constructor(data?: PartialMessage<VolumeMount>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.VolumeMount";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "volume_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "container_path", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "read_only", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VolumeMount {
+    return new VolumeMount().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VolumeMount {
+    return new VolumeMount().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VolumeMount {
+    return new VolumeMount().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: VolumeMount | PlainMessage<VolumeMount> | undefined, b: VolumeMount | PlainMessage<VolumeMount> | undefined): boolean {
+    return proto3.util.equals(VolumeMount, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.ServiceParameters
+ */
+export class ServiceParameters extends Message<ServiceParameters> {
+  /**
+   * @generated from field: repeated norsk.api.common.PortMapping port_mappings = 1;
+   */
+  portMappings: PortMapping[] = [];
+
+  /**
+   * @generated from field: repeated norsk.api.common.EnvironmentVariable environment_variables = 2;
+   */
+  environmentVariables: EnvironmentVariable[] = [];
+
+  /**
+   * @generated from field: norsk.api.common.OptionalInt64 shared_memory_size = 3;
+   */
+  sharedMemorySize?: OptionalInt64;
+
+  /**
+   * @generated from field: repeated uint32 cpu_set = 4;
+   */
+  cpuSet: number[] = [];
+
+  /**
+   * @generated from field: repeated norsk.api.common.VolumeMount volume_mounts = 5;
+   */
+  volumeMounts: VolumeMount[] = [];
+
+  constructor(data?: PartialMessage<ServiceParameters>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.ServiceParameters";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "port_mappings", kind: "message", T: PortMapping, repeated: true },
+    { no: 2, name: "environment_variables", kind: "message", T: EnvironmentVariable, repeated: true },
+    { no: 3, name: "shared_memory_size", kind: "message", T: OptionalInt64 },
+    { no: 4, name: "cpu_set", kind: "scalar", T: 13 /* ScalarType.UINT32 */, repeated: true },
+    { no: 5, name: "volume_mounts", kind: "message", T: VolumeMount, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ServiceParameters {
+    return new ServiceParameters().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ServiceParameters {
+    return new ServiceParameters().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ServiceParameters {
+    return new ServiceParameters().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ServiceParameters | PlainMessage<ServiceParameters> | undefined, b: ServiceParameters | PlainMessage<ServiceParameters> | undefined): boolean {
+    return proto3.util.equals(ServiceParameters, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.Service
+ */
+export class Service extends Message<Service> {
+  /**
+   * @generated from field: string name = 1;
+   */
+  name = "";
+
+  /**
+   * @generated from oneof norsk.api.common.Service.container
+   */
+  container: {
+    /**
+     * @generated from field: norsk.api.common.DockerContainer docker = 2;
+     */
+    value: DockerContainer;
+    case: "docker";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  /**
+   * @generated from field: norsk.api.common.Service.ServiceRestart restart = 3;
+   */
+  restart = Service_ServiceRestart.NEVER;
+
+  /**
+   * @generated from field: repeated string dependsOn = 4;
+   */
+  dependsOn: string[] = [];
+
+  /**
+   * @generated from field: string configuration = 5;
+   */
+  configuration = "";
+
+  /**
+   * @generated from field: uint32 restart_count = 6;
+   */
+  restartCount = 0;
+
+  /**
+   * @generated from field: uint32 restart_period = 7;
+   */
+  restartPeriod = 0;
+
+  /**
+   * @generated from field: string command = 8;
+   */
+  command = "";
+
+  /**
+   * @generated from field: norsk.api.common.ServiceParameters parameters = 9;
+   */
+  parameters?: ServiceParameters;
+
+  constructor(data?: PartialMessage<Service>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.Service";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "docker", kind: "message", T: DockerContainer, oneof: "container" },
+    { no: 3, name: "restart", kind: "enum", T: proto3.getEnumType(Service_ServiceRestart) },
+    { no: 4, name: "dependsOn", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    { no: 5, name: "configuration", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 6, name: "restart_count", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 7, name: "restart_period", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+    { no: 8, name: "command", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 9, name: "parameters", kind: "message", T: ServiceParameters },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Service {
+    return new Service().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Service {
+    return new Service().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Service {
+    return new Service().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Service | PlainMessage<Service> | undefined, b: Service | PlainMessage<Service> | undefined): boolean {
+    return proto3.util.equals(Service, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.common.Service.ServiceRestart
+ */
+export enum Service_ServiceRestart {
+  /**
+   * @generated from enum value: NEVER = 0;
+   */
+  NEVER = 0,
+
+  /**
+   * @generated from enum value: ON_FAILURE = 1;
+   */
+  ON_FAILURE = 1,
+
+  /**
+   * @generated from enum value: ALWAYS = 2;
+   */
+  ALWAYS = 2,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Service_ServiceRestart)
+proto3.util.setEnumType(Service_ServiceRestart, "norsk.api.common.Service.ServiceRestart", [
+  { no: 0, name: "NEVER" },
+  { no: 1, name: "ON_FAILURE" },
+  { no: 2, name: "ALWAYS" },
+]);
+
+/**
+ * @generated from message norsk.api.common.JobInfoServiceStarted
+ */
+export class JobInfoServiceStarted extends Message<JobInfoServiceStarted> {
+  /**
+   * @generated from field: string service_name = 2;
+   */
+  serviceName = "";
+
+  constructor(data?: PartialMessage<JobInfoServiceStarted>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.JobInfoServiceStarted";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 2, name: "service_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobInfoServiceStarted {
+    return new JobInfoServiceStarted().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobInfoServiceStarted {
+    return new JobInfoServiceStarted().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobInfoServiceStarted {
+    return new JobInfoServiceStarted().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: JobInfoServiceStarted | PlainMessage<JobInfoServiceStarted> | undefined, b: JobInfoServiceStarted | PlainMessage<JobInfoServiceStarted> | undefined): boolean {
+    return proto3.util.equals(JobInfoServiceStarted, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.JobInfoServiceRestarting
+ */
+export class JobInfoServiceRestarting extends Message<JobInfoServiceRestarting> {
+  /**
+   * @generated from field: string service_name = 2;
+   */
+  serviceName = "";
+
+  constructor(data?: PartialMessage<JobInfoServiceRestarting>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.JobInfoServiceRestarting";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 2, name: "service_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobInfoServiceRestarting {
+    return new JobInfoServiceRestarting().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobInfoServiceRestarting {
+    return new JobInfoServiceRestarting().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobInfoServiceRestarting {
+    return new JobInfoServiceRestarting().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: JobInfoServiceRestarting | PlainMessage<JobInfoServiceRestarting> | undefined, b: JobInfoServiceRestarting | PlainMessage<JobInfoServiceRestarting> | undefined): boolean {
+    return proto3.util.equals(JobInfoServiceRestarting, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.JobInfoContainerEvent
+ */
+export class JobInfoContainerEvent extends Message<JobInfoContainerEvent> {
+  /**
+   * @generated from field: string service_name = 2;
+   */
+  serviceName = "";
+
+  /**
+   * @generated from field: string text = 3;
+   */
+  text = "";
+
+  constructor(data?: PartialMessage<JobInfoContainerEvent>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.JobInfoContainerEvent";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 2, name: "service_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "text", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobInfoContainerEvent {
+    return new JobInfoContainerEvent().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobInfoContainerEvent {
+    return new JobInfoContainerEvent().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobInfoContainerEvent {
+    return new JobInfoContainerEvent().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: JobInfoContainerEvent | PlainMessage<JobInfoContainerEvent> | undefined, b: JobInfoContainerEvent | PlainMessage<JobInfoContainerEvent> | undefined): boolean {
+    return proto3.util.equals(JobInfoContainerEvent, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.common.JobInfoComponseMessage
+ */
+export class JobInfoComponseMessage extends Message<JobInfoComponseMessage> {
+  /**
+   * @generated from field: norsk.api.common.JobInfoComponseMessage.Stage stage = 2;
+   */
+  stage = JobInfoComponseMessage_Stage.BUILD;
+
+  /**
+   * @generated from field: string text = 3;
+   */
+  text = "";
+
+  constructor(data?: PartialMessage<JobInfoComponseMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.JobInfoComponseMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 2, name: "stage", kind: "enum", T: proto3.getEnumType(JobInfoComponseMessage_Stage) },
+    { no: 3, name: "text", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobInfoComponseMessage {
+    return new JobInfoComponseMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobInfoComponseMessage {
+    return new JobInfoComponseMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobInfoComponseMessage {
+    return new JobInfoComponseMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: JobInfoComponseMessage | PlainMessage<JobInfoComponseMessage> | undefined, b: JobInfoComponseMessage | PlainMessage<JobInfoComponseMessage> | undefined): boolean {
+    return proto3.util.equals(JobInfoComponseMessage, a, b);
+  }
+}
+
+/**
+ * @generated from enum norsk.api.common.JobInfoComponseMessage.Stage
+ */
+export enum JobInfoComponseMessage_Stage {
+  /**
+   * @generated from enum value: BUILD = 0;
+   */
+  BUILD = 0,
+
+  /**
+   * @generated from enum value: CREATE = 1;
+   */
+  CREATE = 1,
+
+  /**
+   * @generated from enum value: START = 2;
+   */
+  START = 2,
+
+  /**
+   * @generated from enum value: STOP = 3;
+   */
+  STOP = 3,
+
+  /**
+   * @generated from enum value: DOWN = 4;
+   */
+  DOWN = 4,
+}
+// Retrieve enum metadata with: proto3.getEnumType(JobInfoComponseMessage_Stage)
+proto3.util.setEnumType(JobInfoComponseMessage_Stage, "norsk.api.common.JobInfoComponseMessage.Stage", [
+  { no: 0, name: "BUILD" },
+  { no: 1, name: "CREATE" },
+  { no: 2, name: "START" },
+  { no: 3, name: "STOP" },
+  { no: 4, name: "DOWN" },
+]);
+
+/**
+ * @generated from message norsk.api.common.JobInfoMessage
+ */
+export class JobInfoMessage extends Message<JobInfoMessage> {
+  /**
+   * @generated from field: norsk.api.common.ActiveJobKey job_key = 1;
+   */
+  jobKey?: ActiveJobKey;
+
+  /**
+   * @generated from field: google.protobuf.Timestamp timestamp = 2;
+   */
+  timestamp?: Timestamp;
+
+  /**
+   * @generated from oneof norsk.api.common.JobInfoMessage.message
+   */
+  message: {
+    /**
+     * @generated from field: norsk.api.common.JobInfoServiceStarted service_started = 3;
+     */
+    value: JobInfoServiceStarted;
+    case: "serviceStarted";
+  } | {
+    /**
+     * @generated from field: norsk.api.common.JobInfoServiceRestarting service_restarting = 4;
+     */
+    value: JobInfoServiceRestarting;
+    case: "serviceRestarting";
+  } | {
+    /**
+     * @generated from field: norsk.api.common.JobInfoContainerEvent container_event = 5;
+     */
+    value: JobInfoContainerEvent;
+    case: "containerEvent";
+  } | {
+    /**
+     * @generated from field: norsk.api.common.JobInfoComponseMessage compose_message = 6;
+     */
+    value: JobInfoComponseMessage;
+    case: "composeMessage";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<JobInfoMessage>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.common.JobInfoMessage";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "job_key", kind: "message", T: ActiveJobKey },
+    { no: 2, name: "timestamp", kind: "message", T: Timestamp },
+    { no: 3, name: "service_started", kind: "message", T: JobInfoServiceStarted, oneof: "message" },
+    { no: 4, name: "service_restarting", kind: "message", T: JobInfoServiceRestarting, oneof: "message" },
+    { no: 5, name: "container_event", kind: "message", T: JobInfoContainerEvent, oneof: "message" },
+    { no: 6, name: "compose_message", kind: "message", T: JobInfoComponseMessage, oneof: "message" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobInfoMessage {
+    return new JobInfoMessage().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobInfoMessage {
+    return new JobInfoMessage().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobInfoMessage {
+    return new JobInfoMessage().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: JobInfoMessage | PlainMessage<JobInfoMessage> | undefined, b: JobInfoMessage | PlainMessage<JobInfoMessage> | undefined): boolean {
+    return proto3.util.equals(JobInfoMessage, a, b);
+  }
+}
+