@norskvideo/norsk-api 0.0.327 → 0.0.329

package/lib/media_pb.ts

@@ -1504,6 +1504,44 @@ proto3.util.setEnumType(VideoIOSupport, "norsk.api.media.VideoIOSupport", [
   { no: 1, name: "PLAYBACK" },
 ]);
 
+/**
+ * @generated from enum norsk.api.media.ContextType
+ */
+export enum ContextType {
+  /**
+   * @generated from enum value: CONTEXT_TYPE_FULL = 0;
+   */
+  FULL = 0,
+
+  /**
+   * @generated from enum value: CONTEXT_TYPE_SINGLE_SOURCE = 1;
+   */
+  SINGLE_SOURCE = 1,
+
+  /**
+   * @generated from enum value: CONTEXT_TYPE_SINGLE_PROGRAM = 2;
+   */
+  SINGLE_PROGRAM = 2,
+
+  /**
+   * @generated from enum value: CONTEXT_TYPE_SINGLE_STREAM = 3;
+   */
+  SINGLE_STREAM = 3,
+
+  /**
+   * @generated from enum value: CONTEXT_TYPE_SINGLE_RENDITION = 4;
+   */
+  SINGLE_RENDITION = 4,
+}
+// Retrieve enum metadata with: proto3.getEnumType(ContextType)
+proto3.util.setEnumType(ContextType, "norsk.api.media.ContextType", [
+  { no: 0, name: "CONTEXT_TYPE_FULL" },
+  { no: 1, name: "CONTEXT_TYPE_SINGLE_SOURCE" },
+  { no: 2, name: "CONTEXT_TYPE_SINGLE_PROGRAM" },
+  { no: 3, name: "CONTEXT_TYPE_SINGLE_STREAM" },
+  { no: 4, name: "CONTEXT_TYPE_SINGLE_RENDITION" },
+]);
+
 /**
  * The canonical error codes for gRPC APIs.
  *
@@ -6879,14 +6917,15 @@ export class ComposePart extends Message<ComposePart> {
 
   /**
    * Z-index to determine ordering by which the sources are overlaid
+   * (higher layers appear on top)
    *
    * @generated from field: uint32 z_index = 4;
    */
   zIndex = 0;
 
   /**
-   * Opacity of this overlay (where 0.0 is fully transparent and 1.0 is fully
-   * opaque)
+   * Opacity multiplier of this overlay (where 0.0 is fully transparent and 1.0
+   * is fully opaque)
    *
    * @generated from field: float opacity = 5;
    */
@@ -7187,7 +7226,7 @@ export class ComposeVideoMessage extends Message<ComposeVideoMessage> {
 
 /**
  * *
- * Configure an Compose Media Node.
+ * Configure a Compose Media Node.
  *
  * @generated from message norsk.api.media.ComposeVideoConfiguration
  */
@@ -7224,7 +7263,7 @@ export class ComposeVideoConfiguration extends Message<ComposeVideoConfiguration
    * in percentage terms, or a notional resolution can be used that is
    * independant of the source resolutions that may be provided.
    *
-   * if set here, this reference resolution will be applied to 
+   * if set here, this reference resolution will be applied to
    * any parts that do not have their own reference resolution specified
    *
    * If not provided the source and destination rectangles are in terms of the
@@ -7393,7 +7432,7 @@ proto3.util.setEnumType(ComposeVideoConfiguration_MissingStreamBehaviour, "norsk
  */
 export class ComposeVideoUpdateConfiguration extends Message<ComposeVideoUpdateConfiguration> {
   /**
-   * The parts (images/overlays) to include in the composition
+   * Update the parts (images/overlays) to include in the composition
    *
    * @generated from field: repeated norsk.api.media.ComposePart parts = 1;
    */
@@ -17170,18 +17209,18 @@ export class SubscribeSource extends Message<SubscribeSource> {
  */
 export class Subscription extends Message<Subscription> {
   /**
-   * The individual subscription components
+   * An arbitrary id of the subscription, to enable correlating of the corresponding subscription response
    *
-   * @generated from field: repeated norsk.api.media.SubscribeSource sources = 2;
+   * @generated from field: string id = 1;
    */
-  sources: SubscribeSource[] = [];
+  id = "";
 
   /**
-   * An arbitrary id of the subscription, to enable correlating of the corresponding subscription response
+   * The individual subscription components
    *
-   * @generated from field: string id = 3;
+   * @generated from field: repeated norsk.api.media.SubscribeSource sources = 2;
    */
-  id = "";
+  sources: SubscribeSource[] = [];
 
   constructor(data?: PartialMessage<Subscription>) {
     super();
@@ -17191,8 +17230,8 @@ export class Subscription extends Message<Subscription> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.media.Subscription";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 2, name: "sources", kind: "message", T: SubscribeSource, repeated: true },
-    { no: 3, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Subscription {
@@ -17219,18 +17258,18 @@ export class Subscription extends Message<Subscription> {
  */
 export class SubscriptionResponse extends Message<SubscriptionResponse> {
   /**
-   * The subscription status
+   * The id of the subscription which this message is a response to
    *
-   * @generated from field: norsk.api.media.Status status = 2;
+   * @generated from field: string id = 1;
    */
-  status?: Status;
+  id = "";
 
   /**
-   * The id of the subscription which this message is a response to
+   * The error that prevented the subscription, if any
    *
-   * @generated from field: string id = 3;
+   * @generated from field: norsk.api.media.SubscriptionError error = 2;
    */
-  id = "";
+  error?: SubscriptionError;
 
   constructor(data?: PartialMessage<SubscriptionResponse>) {
     super();
@@ -17240,8 +17279,8 @@ export class SubscriptionResponse extends Message<SubscriptionResponse> {
   static readonly runtime = proto3;
   static readonly typeName = "norsk.api.media.SubscriptionResponse";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 2, name: "status", kind: "message", T: Status },
-    { no: 3, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "error", kind: "message", T: SubscriptionError },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionResponse {
@@ -17261,6 +17300,380 @@ export class SubscriptionResponse extends Message<SubscriptionResponse> {
   }
 }
 
+/**
+ * @generated from message norsk.api.media.SubscriptionError
+ */
+export class SubscriptionError extends Message<SubscriptionError> {
+  /**
+   * @generated from oneof norsk.api.media.SubscriptionError.error
+   */
+  error: {
+    /**
+     * An opaque internal error
+     *
+     * @generated from field: string internal = 1;
+     */
+    value: string;
+    case: "internal";
+  } | {
+    /**
+     * The media node requesting the subscription does not exist
+     *
+     * @generated from field: norsk.api.media.MediaNodeId unknown_subscriber = 2;
+     */
+    value: MediaNodeId;
+    case: "unknownSubscriber";
+  } | {
+    /**
+     * Multiple stream keys found for the context type
+     *
+     * @generated from field: norsk.api.media.SubscriptionError.MultipleStreams multiple_streams = 3;
+     */
+    value: SubscriptionError_MultipleStreams;
+    case: "multipleStreams";
+  } | {
+    /**
+     * Per-source errors
+     *
+     * @generated from field: norsk.api.media.SubscriptionError.SourceSubscriptionErrors source_subscription_error = 4;
+     */
+    value: SubscriptionError_SourceSubscriptionErrors;
+    case: "sourceSubscriptionError";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<SubscriptionError>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubscriptionError";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "internal", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "error" },
+    { no: 2, name: "unknown_subscriber", kind: "message", T: MediaNodeId, oneof: "error" },
+    { no: 3, name: "multiple_streams", kind: "message", T: SubscriptionError_MultipleStreams, oneof: "error" },
+    { no: 4, name: "source_subscription_error", kind: "message", T: SubscriptionError_SourceSubscriptionErrors, oneof: "error" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionError {
+    return new SubscriptionError().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscriptionError {
+    return new SubscriptionError().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscriptionError {
+    return new SubscriptionError().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubscriptionError | PlainMessage<SubscriptionError> | undefined, b: SubscriptionError | PlainMessage<SubscriptionError> | undefined): boolean {
+    return proto3.util.equals(SubscriptionError, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SubscriptionError.MultipleStreams
+ */
+export class SubscriptionError_MultipleStreams extends Message<SubscriptionError_MultipleStreams> {
+  /**
+   * @generated from field: norsk.api.media.ContextType context_type = 1;
+   */
+  contextType = ContextType.FULL;
+
+  /**
+   * @generated from field: repeated norsk.api.media.StreamKey stream_keys = 2;
+   */
+  streamKeys: StreamKey[] = [];
+
+  constructor(data?: PartialMessage<SubscriptionError_MultipleStreams>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubscriptionError.MultipleStreams";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "context_type", kind: "enum", T: proto3.getEnumType(ContextType) },
+    { no: 2, name: "stream_keys", kind: "message", T: StreamKey, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionError_MultipleStreams {
+    return new SubscriptionError_MultipleStreams().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscriptionError_MultipleStreams {
+    return new SubscriptionError_MultipleStreams().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscriptionError_MultipleStreams {
+    return new SubscriptionError_MultipleStreams().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubscriptionError_MultipleStreams | PlainMessage<SubscriptionError_MultipleStreams> | undefined, b: SubscriptionError_MultipleStreams | PlainMessage<SubscriptionError_MultipleStreams> | undefined): boolean {
+    return proto3.util.equals(SubscriptionError_MultipleStreams, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SubscriptionError.SourceSubscriptionErrors
+ */
+export class SubscriptionError_SourceSubscriptionErrors extends Message<SubscriptionError_SourceSubscriptionErrors> {
+  /**
+   * @generated from field: repeated norsk.api.media.SourceSubscriptionError errors = 1;
+   */
+  errors: SourceSubscriptionError[] = [];
+
+  constructor(data?: PartialMessage<SubscriptionError_SourceSubscriptionErrors>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SubscriptionError.SourceSubscriptionErrors";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "errors", kind: "message", T: SourceSubscriptionError, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscriptionError_SourceSubscriptionErrors {
+    return new SubscriptionError_SourceSubscriptionErrors().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscriptionError_SourceSubscriptionErrors {
+    return new SubscriptionError_SourceSubscriptionErrors().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscriptionError_SourceSubscriptionErrors {
+    return new SubscriptionError_SourceSubscriptionErrors().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SubscriptionError_SourceSubscriptionErrors | PlainMessage<SubscriptionError_SourceSubscriptionErrors> | undefined, b: SubscriptionError_SourceSubscriptionErrors | PlainMessage<SubscriptionError_SourceSubscriptionErrors> | undefined): boolean {
+    return proto3.util.equals(SubscriptionError_SourceSubscriptionErrors, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SourceSubscriptionError
+ */
+export class SourceSubscriptionError extends Message<SourceSubscriptionError> {
+  /**
+   * @generated from oneof norsk.api.media.SourceSubscriptionError.error
+   */
+  error: {
+    /**
+     * An opaque internal error
+     *
+     * @generated from field: string internal = 1;
+     */
+    value: string;
+    case: "internal";
+  } | {
+    /**
+     * The media node does not exist (maybe it crashed)
+     *
+     * @generated from field: norsk.api.media.MediaNodeId unknown_source_id = 2;
+     */
+    value: MediaNodeId;
+    case: "unknownSourceId";
+  } | {
+    /**
+     * The media node exists, but does not have the stream key
+     *
+     * @generated from field: norsk.api.media.SourceSubscriptionError.SourceStream unknown_source_stream = 3;
+     */
+    value: SourceSubscriptionError_SourceStream;
+    case: "unknownSourceStream";
+  } | {
+    /**
+     * The media node is not set up to receive data on this pin (which may be auto-detected)
+     *
+     * @generated from field: norsk.api.media.SourceSubscriptionError.NoSubscriberPin no_subscriber_pin = 4;
+     */
+    value: SourceSubscriptionError_NoSubscriberPin;
+    case: "noSubscriberPin";
+  } | {
+    /**
+     * Norsk does not support conversion from the media types of the source to the media types accepted by the subscriber
+     *
+     * @generated from field: norsk.api.media.SourceSubscriptionError.UnsupportedConversion unsupported_conversion = 5;
+     */
+    value: SourceSubscriptionError_UnsupportedConversion;
+    case: "unsupportedConversion";
+  } | { case: undefined; value?: undefined } = { case: undefined };
+
+  constructor(data?: PartialMessage<SourceSubscriptionError>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SourceSubscriptionError";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "internal", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "error" },
+    { no: 2, name: "unknown_source_id", kind: "message", T: MediaNodeId, oneof: "error" },
+    { no: 3, name: "unknown_source_stream", kind: "message", T: SourceSubscriptionError_SourceStream, oneof: "error" },
+    { no: 4, name: "no_subscriber_pin", kind: "message", T: SourceSubscriptionError_NoSubscriberPin, oneof: "error" },
+    { no: 5, name: "unsupported_conversion", kind: "message", T: SourceSubscriptionError_UnsupportedConversion, oneof: "error" },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SourceSubscriptionError {
+    return new SourceSubscriptionError().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SourceSubscriptionError {
+    return new SourceSubscriptionError().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SourceSubscriptionError {
+    return new SourceSubscriptionError().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SourceSubscriptionError | PlainMessage<SourceSubscriptionError> | undefined, b: SourceSubscriptionError | PlainMessage<SourceSubscriptionError> | undefined): boolean {
+    return proto3.util.equals(SourceSubscriptionError, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SourceSubscriptionError.SourceStream
+ */
+export class SourceSubscriptionError_SourceStream extends Message<SourceSubscriptionError_SourceStream> {
+  /**
+   * @generated from field: norsk.api.media.MediaNodeId media_node_id = 1;
+   */
+  mediaNodeId?: MediaNodeId;
+
+  /**
+   * @generated from field: norsk.api.media.StreamKey stream_key = 2;
+   */
+  streamKey?: StreamKey;
+
+  constructor(data?: PartialMessage<SourceSubscriptionError_SourceStream>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SourceSubscriptionError.SourceStream";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "media_node_id", kind: "message", T: MediaNodeId },
+    { no: 2, name: "stream_key", kind: "message", T: StreamKey },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SourceSubscriptionError_SourceStream {
+    return new SourceSubscriptionError_SourceStream().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SourceSubscriptionError_SourceStream {
+    return new SourceSubscriptionError_SourceStream().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SourceSubscriptionError_SourceStream {
+    return new SourceSubscriptionError_SourceStream().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SourceSubscriptionError_SourceStream | PlainMessage<SourceSubscriptionError_SourceStream> | undefined, b: SourceSubscriptionError_SourceStream | PlainMessage<SourceSubscriptionError_SourceStream> | undefined): boolean {
+    return proto3.util.equals(SourceSubscriptionError_SourceStream, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SourceSubscriptionError.NoSubscriberPin
+ */
+export class SourceSubscriptionError_NoSubscriberPin extends Message<SourceSubscriptionError_NoSubscriberPin> {
+  /**
+   * @generated from field: norsk.api.media.SourceSubscriptionError.SourceStream source_stream = 1;
+   */
+  sourceStream?: SourceSubscriptionError_SourceStream;
+
+  /**
+   * @generated from field: string pin = 2;
+   */
+  pin = "";
+
+  /**
+   * @generated from field: repeated string subscriber_pins = 3;
+   */
+  subscriberPins: string[] = [];
+
+  constructor(data?: PartialMessage<SourceSubscriptionError_NoSubscriberPin>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SourceSubscriptionError.NoSubscriberPin";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "source_stream", kind: "message", T: SourceSubscriptionError_SourceStream },
+    { no: 2, name: "pin", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "subscriber_pins", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SourceSubscriptionError_NoSubscriberPin {
+    return new SourceSubscriptionError_NoSubscriberPin().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SourceSubscriptionError_NoSubscriberPin {
+    return new SourceSubscriptionError_NoSubscriberPin().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SourceSubscriptionError_NoSubscriberPin {
+    return new SourceSubscriptionError_NoSubscriberPin().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SourceSubscriptionError_NoSubscriberPin | PlainMessage<SourceSubscriptionError_NoSubscriberPin> | undefined, b: SourceSubscriptionError_NoSubscriberPin | PlainMessage<SourceSubscriptionError_NoSubscriberPin> | undefined): boolean {
+    return proto3.util.equals(SourceSubscriptionError_NoSubscriberPin, a, b);
+  }
+}
+
+/**
+ * @generated from message norsk.api.media.SourceSubscriptionError.UnsupportedConversion
+ */
+export class SourceSubscriptionError_UnsupportedConversion extends Message<SourceSubscriptionError_UnsupportedConversion> {
+  /**
+   * @generated from field: norsk.api.media.SourceSubscriptionError.SourceStream source_stream = 1;
+   */
+  sourceStream?: SourceSubscriptionError_SourceStream;
+
+  /**
+   * @generated from field: repeated string source_types = 2;
+   */
+  sourceTypes: string[] = [];
+
+  /**
+   * @generated from field: repeated string subscriber_types = 3;
+   */
+  subscriberTypes: string[] = [];
+
+  constructor(data?: PartialMessage<SourceSubscriptionError_UnsupportedConversion>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime = proto3;
+  static readonly typeName = "norsk.api.media.SourceSubscriptionError.UnsupportedConversion";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "source_stream", kind: "message", T: SourceSubscriptionError_SourceStream },
+    { no: 2, name: "source_types", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    { no: 3, name: "subscriber_types", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SourceSubscriptionError_UnsupportedConversion {
+    return new SourceSubscriptionError_UnsupportedConversion().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SourceSubscriptionError_UnsupportedConversion {
+    return new SourceSubscriptionError_UnsupportedConversion().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SourceSubscriptionError_UnsupportedConversion {
+    return new SourceSubscriptionError_UnsupportedConversion().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SourceSubscriptionError_UnsupportedConversion | PlainMessage<SourceSubscriptionError_UnsupportedConversion> | undefined, b: SourceSubscriptionError_UnsupportedConversion | PlainMessage<SourceSubscriptionError_UnsupportedConversion> | undefined): boolean {
+    return proto3.util.equals(SourceSubscriptionError_UnsupportedConversion, a, b);
+  }
+}
+
 /**
  * `Struct` represents a structured data value, consisting of fields
  * which map to dynamically typed values. In some languages, `Struct`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/norsk-api",
-  "version": "0.0.327",
+  "version": "0.0.329",
   "license": "MIT",
   "dependencies": {
     "@bufbuild/protobuf": "^0.3.0",