@norskvideo/norsk-api 1.0.345 → 1.0.347

package/lib/shared/error_pb.ts

@@ -0,0 +1,546 @@
+// @generated by protoc-gen-es v0.3.0 with parameter "target=ts"
+// @generated from file shared/error.proto (package norsk.api.error, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
+import { Message, proto3 } from "@bufbuild/protobuf";
+
+/**
+ * The canonical error codes for gRPC APIs.
+ *
+ *
+ * Sometimes multiple error codes may apply.  Services should return
+ * the most specific error code that applies.  For example, prefer
+ * `OUT_OF_RANGE` over `FAILED_PRECONDITION` if both codes apply.
+ * Similarly prefer `NOT_FOUND` or `ALREADY_EXISTS` over `FAILED_PRECONDITION`.
+ *
+ * @generated from enum norsk.api.error.Code
+ */
+export enum Code {
+  /**
+   * Not an error; returned on success
+   *
+   * HTTP Mapping: 200 OK
+   *
+   * @generated from enum value: OK = 0;
+   */
+  OK = 0,
+
+  /**
+   * The operation was cancelled, typically by the caller.
+   *
+   * HTTP Mapping: 499 Client Closed Request
+   *
+   * @generated from enum value: CANCELLED = 1;
+   */
+  CANCELLED = 1,
+
+  /**
+   * Unknown error.  For example, this error may be returned when
+   * a `Status` value received from another address space belongs to
+   * an error space that is not known in this address space.  Also
+   * errors raised by APIs that do not return enough error information
+   * may be converted to this error.
+   *
+   * HTTP Mapping: 500 Internal Server Error
+   *
+   * @generated from enum value: UNKNOWN_ERROR = 2;
+   */
+  UNKNOWN_ERROR = 2,
+
+  /**
+   * The client specified an invalid argument.  Note that this differs
+   * from `FAILED_PRECONDITION`.  `INVALID_ARGUMENT` indicates arguments
+   * that are problematic regardless of the state of the system
+   * (e.g., a malformed file name).
+   *
+   * HTTP Mapping: 400 Bad Request
+   *
+   * @generated from enum value: INVALID_ARGUMENT = 3;
+   */
+  INVALID_ARGUMENT = 3,
+
+  /**
+   * The deadline expired before the operation could complete. For operations
+   * that change the state of the system, this error may be returned
+   * even if the operation has completed successfully.  For example, a
+   * successful response from a server could have been delayed long
+   * enough for the deadline to expire.
+   *
+   * HTTP Mapping: 504 Gateway Timeout
+   *
+   * @generated from enum value: DEADLINE_EXCEEDED = 4;
+   */
+  DEADLINE_EXCEEDED = 4,
+
+  /**
+   * Some requested entity (e.g., file or directory) was not found.
+   *
+   * Note to server developers: if a request is denied for an entire class
+   * of users, such as gradual feature rollout or undocumented whitelist,
+   * `NOT_FOUND` may be used. If a request is denied for some users within
+   * a class of users, such as user-based access control, `PERMISSION_DENIED`
+   * must be used.
+   *
+   * HTTP Mapping: 404 Not Found
+   *
+   * @generated from enum value: NOT_FOUND = 5;
+   */
+  NOT_FOUND = 5,
+
+  /**
+   * The entity that a client attempted to create (e.g., file or directory)
+   * already exists.
+   *
+   * HTTP Mapping: 409 Conflict
+   *
+   * @generated from enum value: ALREADY_EXISTS = 6;
+   */
+  ALREADY_EXISTS = 6,
+
+  /**
+   * The caller does not have permission to execute the specified
+   * operation. `PERMISSION_DENIED` must not be used for rejections
+   * caused by exhausting some resource (use `RESOURCE_EXHAUSTED`
+   * instead for those errors). `PERMISSION_DENIED` must not be
+   * used if the caller can not be identified (use `UNAUTHENTICATED`
+   * instead for those errors). This error code does not imply the
+   * request is valid or the requested entity exists or satisfies
+   * other pre-conditions.
+   *
+   * HTTP Mapping: 403 Forbidden
+   *
+   * @generated from enum value: PERMISSION_DENIED = 7;
+   */
+  PERMISSION_DENIED = 7,
+
+  /**
+   * The request does not have valid authentication credentials for the
+   * operation.
+   *
+   * HTTP Mapping: 401 Unauthorized
+   *
+   * @generated from enum value: UNAUTHENTICATED = 16;
+   */
+  UNAUTHENTICATED = 16,
+
+  /**
+   * Some resource has been exhausted, perhaps a per-user quota, or
+   * perhaps the entire file system is out of space.
+   *
+   * HTTP Mapping: 429 Too Many Requests
+   *
+   * @generated from enum value: RESOURCE_EXHAUSTED = 8;
+   */
+  RESOURCE_EXHAUSTED = 8,
+
+  /**
+   * The operation was rejected because the system is not in a state
+   * required for the operation's execution.  For example, the directory
+   * to be deleted is non-empty, an rmdir operation is applied to
+   * a non-directory, etc.
+   *
+   * Service implementors can use the following guidelines to decide
+   * between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`:
+   *  (a) Use `UNAVAILABLE` if the client can retry just the failing call.
+   *  (b) Use `ABORTED` if the client should retry at a higher level
+   *      (e.g., when a client-specified test-and-set fails, indicating the
+   *      client should restart a read-modify-write sequence).
+   *  (c) Use `FAILED_PRECONDITION` if the client should not retry until
+   *      the system state has been explicitly fixed.  E.g., if an "rmdir"
+   *      fails because the directory is non-empty, `FAILED_PRECONDITION`
+   *      should be returned since the client should not retry unless
+   *      the files are deleted from the directory.
+   *
+   * HTTP Mapping: 400 Bad Request
+   *
+   * @generated from enum value: FAILED_PRECONDITION = 9;
+   */
+  FAILED_PRECONDITION = 9,
+
+  /**
+   * The operation was aborted, typically due to a concurrency issue such as
+   * a sequencer check failure or transaction abort.
+   *
+   * See the guidelines above for deciding between `FAILED_PRECONDITION`,
+   * `ABORTED`, and `UNAVAILABLE`.
+   *
+   * HTTP Mapping: 409 Conflict
+   *
+   * @generated from enum value: ABORTED = 10;
+   */
+  ABORTED = 10,
+
+  /**
+   * The operation was attempted past the valid range.  E.g., seeking or
+   * reading past end-of-file.
+   *
+   * Unlike `INVALID_ARGUMENT`, this error indicates a problem that may
+   * be fixed if the system state changes. For example, a 32-bit file
+   * system will generate `INVALID_ARGUMENT` if asked to read at an
+   * offset that is not in the range [0,2^32-1], but it will generate
+   * `OUT_OF_RANGE` if asked to read from an offset past the current
+   * file size.
+   *
+   * There is a fair bit of overlap between `FAILED_PRECONDITION` and
+   * `OUT_OF_RANGE`.  We recommend using `OUT_OF_RANGE` (the more specific
+   * error) when it applies so that callers who are iterating through
+   * a space can easily look for an `OUT_OF_RANGE` error to detect when
+   * they are done.
+   *
+   * HTTP Mapping: 400 Bad Request
+   *
+   * @generated from enum value: OUT_OF_RANGE = 11;
+   */
+  OUT_OF_RANGE = 11,
+
+  /**
+   * The operation is not implemented or is not supported/enabled in this
+   * service.
+   *
+   * HTTP Mapping: 501 Not Implemented
+   *
+   * @generated from enum value: UNIMPLEMENTED = 12;
+   */
+  UNIMPLEMENTED = 12,
+
+  /**
+   * Internal errors.  This means that some invariants expected by the
+   * underlying system have been broken.  This error code is reserved
+   * for serious errors.
+   *
+   * HTTP Mapping: 500 Internal Server Error
+   *
+   * @generated from enum value: INTERNAL = 13;
+   */
+  INTERNAL = 13,
+
+  /**
+   * The service is currently unavailable.  This is most likely a
+   * transient condition, which can be corrected by retrying with
+   * a backoff. Note that it is not always safe to retry
+   * non-idempotent operations.
+   *
+   * See the guidelines above for deciding between `FAILED_PRECONDITION`,
+   * `ABORTED`, and `UNAVAILABLE`.
+   *
+   * HTTP Mapping: 503 Service Unavailable
+   *
+   * @generated from enum value: UNAVAILABLE = 14;
+   */
+  UNAVAILABLE = 14,
+
+  /**
+   * Unrecoverable data loss or corruption.
+   *
+   * HTTP Mapping: 500 Internal Server Error
+   *
+   * @generated from enum value: DATA_LOSS = 15;
+   */
+  DATA_LOSS = 15,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Code)
+proto3.util.setEnumType(Code, "norsk.api.error.Code", [
+  { no: 0, name: "OK" },
+  { no: 1, name: "CANCELLED" },
+  { no: 2, name: "UNKNOWN_ERROR" },
+  { no: 3, name: "INVALID_ARGUMENT" },
+  { no: 4, name: "DEADLINE_EXCEEDED" },
+  { no: 5, name: "NOT_FOUND" },
+  { no: 6, name: "ALREADY_EXISTS" },
+  { no: 7, name: "PERMISSION_DENIED" },
+  { no: 16, name: "UNAUTHENTICATED" },
+  { no: 8, name: "RESOURCE_EXHAUSTED" },
+  { no: 9, name: "FAILED_PRECONDITION" },
+  { no: 10, name: "ABORTED" },
+  { no: 11, name: "OUT_OF_RANGE" },
+  { no: 12, name: "UNIMPLEMENTED" },
+  { no: 13, name: "INTERNAL" },
+  { no: 14, name: "UNAVAILABLE" },
+  { no: 15, name: "DATA_LOSS" },
+]);
+
+/**
+ * `NullValue` is a singleton enumeration to represent the null value for the
+ * `Value` type union.
+ *
+ *  The JSON representation for `NullValue` is JSON `null`.
+ *
+ * @generated from enum norsk.api.error.NullValue
+ */
+export enum NullValue {
+  /**
+   * Null value.
+   *
+   * @generated from enum value: NULL_VALUE = 0;
+   */
+  NULL_VALUE = 0,
+}
+// Retrieve enum metadata with: proto3.getEnumType(NullValue)
+proto3.util.setEnumType(NullValue, "norsk.api.error.NullValue", [
+  { no: 0, name: "NULL_VALUE" },
+]);
+
+/**
+ * `Struct` represents a structured data value, consisting of fields
+ * which map to dynamically typed values. In some languages, `Struct`
+ * might be supported by a native representation. For example, in
+ * scripting languages like JS a struct is represented as an
+ * object. The details of that representation are described together
+ * with the proto support for the language.
+ *
+ * The JSON representation for `Struct` is JSON object.
+ *
+ * @generated from message norsk.api.error.Struct
+ */
+export class Struct extends Message<Struct> {
+  /**
+   * Unordered map of dynamically typed values.
+   *
+   * @generated from field: map<string, norsk.api.error.Value> fields = 1;
+   */
+  fields: { [key: string]: Value } = {};
+
+  constructor(data?: PartialMessage<Struct>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.error.Struct";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "fields", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: Value} },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Struct {
+    return new Struct().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Struct {
+    return new Struct().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Struct {
+    return new Struct().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Struct | PlainMessage<Struct> | undefined, b: Struct | PlainMessage<Struct> | undefined): boolean {
+    return proto3.util.equals(Struct, a, b);
+  }
+}
+
+/**
+ * `Value` represents a dynamically typed value which can be either
+ * null, a number, a string, a boolean, a recursive struct value, or a
+ * list of values. A producer of value is expected to set one of that
+ * variants, absence of any variant indicates an error.
+ *
+ * The JSON representation for `Value` is JSON value.
+ *
+ * @generated from message norsk.api.error.Value
+ */
+export class Value extends Message<Value> {
+  /**
+   * The kind of value.
+   *
+   * @generated from oneof norsk.api.error.Value.kind
+   */
+  kind: {
+    /**
+     * Represents a null value.
+     *
+     * @generated from field: norsk.api.error.NullValue null_value = 1;
+     */
+    value: NullValue;
+    case: "nullValue";
+  } | {
+    /**
+     * Represents a double value.
+     *
+     * @generated from field: double number_value = 2;
+     */
+    value: number;
+    case: "numberValue";
+  } | {
+    /**
+     * Represents a string value.
+     *
+     * @generated from field: string string_value = 3;
+     */
+    value: string;
+    case: "stringValue";
+  } | {
+    /**
+     * Represents a boolean value.
+     *
+     * @generated from field: bool bool_value = 4;
+     */
+    value: boolean;
+    case: "boolValue";
+  } | {
+    /**
+     * Represents a structured value.
+     *
+     * @generated from field: norsk.api.error.Struct struct_value = 5;
+     */
+    value: Struct;
+    case: "structValue";
+  } | {
+    /**
+     * Represents a repeated `Value`.
+     *
+     * @generated from field: norsk.api.error.ListValue list_value = 6;
+     */
+    value: ListValue;
+    case: "listValue";
+  } | {
+    /**
+     * Represents a Code value
+     *
+     * @generated from field: norsk.api.error.Code code_value = 7;
+     */
+    value: Code;
+    case: "codeValue";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<Value>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.error.Value";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "null_value", kind: "enum", T: proto3.getEnumType(NullValue), oneof: "kind" },
+    { no: 2, name: "number_value", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, oneof: "kind" },
+    { no: 3, name: "string_value", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "kind" },
+    { no: 4, name: "bool_value", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "kind" },
+    { no: 5, name: "struct_value", kind: "message", T: Struct, oneof: "kind" },
+    { no: 6, name: "list_value", kind: "message", T: ListValue, oneof: "kind" },
+    { no: 7, name: "code_value", kind: "enum", T: proto3.getEnumType(Code), oneof: "kind" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Value {
+    return new Value().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Value {
+    return new Value().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Value {
+    return new Value().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Value | PlainMessage<Value> | undefined, b: Value | PlainMessage<Value> | undefined): boolean {
+    return proto3.util.equals(Value, a, b);
+  }
+}
+
+/**
+ * `ListValue` is a wrapper around a repeated field of values.
+ *
+ * The JSON representation for `ListValue` is JSON array.
+ *
+ * @generated from message norsk.api.error.ListValue
+ */
+export class ListValue extends Message<ListValue> {
+  /**
+   * Repeated field of dynamically typed values.
+   *
+   * @generated from field: repeated norsk.api.error.Value values = 1;
+   */
+  values: Value[] = [];
+
+  constructor(data?: PartialMessage<ListValue>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.error.ListValue";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "values", kind: "message", T: Value, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListValue {
+    return new ListValue().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListValue {
+    return new ListValue().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListValue {
+    return new ListValue().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ListValue | PlainMessage<ListValue> | undefined, b: ListValue | PlainMessage<ListValue> | undefined): boolean {
+    return proto3.util.equals(ListValue, a, b);
+  }
+}
+
+/**
+ * ///////////////////////////////////////////////////////////////////////////
+ *
+ *
+ * @generated from message norsk.api.error.Status
+ */
+export class Status extends Message<Status> {
+  /**
+   * The status code, which should be an enum value of
+   * [google.rpc.Code][google.rpc.Code].
+   *
+   * @generated from field: norsk.api.error.Code code = 1;
+   */
+  code = Code.OK;
+
+  /**
+   * A developer-facing error message, which should be in English. Any
+   * user-facing error message should be localized and sent in the
+   * [google.rpc.Status.details][google.rpc.Status.details] field, or localized
+   * by the client.
+   *
+   * @generated from field: string message = 2;
+   */
+  message = "";
+
+  /**
+   * A list of messages that carry the error details.  There is a common set of
+   * message types for APIs to use.
+   *
+   * @generated from field: norsk.api.error.Struct details = 3;
+   */
+  details?: Struct;
+
+  constructor(data?: PartialMessage<Status>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.error.Status";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "code", kind: "enum", T: proto3.getEnumType(Code) },
+    { no: 2, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "details", kind: "message", T: Struct },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Status {
+    return new Status().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Status {
+    return new Status().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Status {
+    return new Status().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: Status | PlainMessage<Status> | undefined, b: Status | PlainMessage<Status> | undefined): boolean {
+    return proto3.util.equals(Status, a, b);
+  }
+}
+

package/lib/worker_grpc_pb.d.ts

@@ -1,4 +1,4 @@
-// package: norsk.api.manager.worker
+// package: norsk.api.worker
 // file: worker.proto
 
 /* tslint:disable */
@@ -6,6 +6,7 @@
 
 import * as grpc from "@grpc/grpc-js";
 import * as worker_pb from "./worker_pb";
+import * as shared_common_pb from "./shared/common_pb";
 import * as google_protobuf_timestamp_pb from "@bufbuild/protobuf";
 import * as google_protobuf_empty_pb from "@bufbuild/protobuf";
 
@@ -14,7 +15,7 @@ interface IWorkerService extends grpc.ServiceDefinition<grpc.UntypedServiceImple
 }
 
 interface IWorkerService_INodeControllerStream extends grpc.MethodDefinition<worker_pb.NodeControllerMessage, worker_pb.WorkerMessage> {
-    path: "/norsk.api.manager.worker.Worker/NodeControllerStream";
+    path: "/norsk.api.worker.Worker/NodeControllerStream";
     requestStream: true;
     responseStream: true;
     requestSerialize: grpc.serialize<worker_pb.NodeControllerMessage>;

package/lib/worker_grpc_pb.js

@@ -3,43 +3,44 @@
 'use strict';
 var grpc = require('@grpc/grpc-js');
 var worker_pb = require('./worker_pb.js');
+var shared_common_pb = require('./shared/common_pb.js');
 var google_protobuf_timestamp_pb = require('@bufbuild/protobuf');
 var google_protobuf_empty_pb = require('@bufbuild/protobuf');
 
-function serialize_norsk_api_manager_worker_NodeControllerMessage(arg) {
+function serialize_norsk_api_worker_NodeControllerMessage(arg) {
   if (!(arg instanceof worker_pb.NodeControllerMessage)) {
-    throw new Error('Expected argument of type norsk.api.manager.worker.NodeControllerMessage');
+    throw new Error('Expected argument of type norsk.api.worker.NodeControllerMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_manager_worker_NodeControllerMessage(buffer_arg) {
+function deserialize_norsk_api_worker_NodeControllerMessage(buffer_arg) {
   return worker_pb.NodeControllerMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
-function serialize_norsk_api_manager_worker_WorkerMessage(arg) {
+function serialize_norsk_api_worker_WorkerMessage(arg) {
   if (!(arg instanceof worker_pb.WorkerMessage)) {
-    throw new Error('Expected argument of type norsk.api.manager.worker.WorkerMessage');
+    throw new Error('Expected argument of type norsk.api.worker.WorkerMessage');
   }
   return Buffer.from(arg.toBinary());
 }
 
-function deserialize_norsk_api_manager_worker_WorkerMessage(buffer_arg) {
+function deserialize_norsk_api_worker_WorkerMessage(buffer_arg) {
   return worker_pb.WorkerMessage.fromBinary(new Uint8Array(buffer_arg));
 }
 
 
 var WorkerService = exports.WorkerService = {
   nodeControllerStream: {
-    path: '/norsk.api.manager.worker.Worker/NodeControllerStream',
+    path: '/norsk.api.worker.Worker/NodeControllerStream',
     requestStream: true,
     responseStream: true,
     requestType: worker_pb.NodeControllerMessage,
     responseType: worker_pb.WorkerMessage,
-    requestSerialize: serialize_norsk_api_manager_worker_NodeControllerMessage,
-    requestDeserialize: deserialize_norsk_api_manager_worker_NodeControllerMessage,
-    responseSerialize: serialize_norsk_api_manager_worker_WorkerMessage,
-    responseDeserialize: deserialize_norsk_api_manager_worker_WorkerMessage,
+    requestSerialize: serialize_norsk_api_worker_NodeControllerMessage,
+    requestDeserialize: deserialize_norsk_api_worker_NodeControllerMessage,
+    responseSerialize: serialize_norsk_api_worker_WorkerMessage,
+    responseDeserialize: deserialize_norsk_api_worker_WorkerMessage,
   },
 };