@milaboratories/pl-drivers 1.12.7 → 1.12.9

package/dist/proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.client.js

@@ -1,11 +1,10 @@
 import { Streaming } from "./protocol.js";
 import { stackIntercept } from "@protobuf-ts/runtime-rpc";
-
 //#region src/proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.client.ts
 /**
 *
-* Streaming provides access to online data stream from item in storage. Whenever item is appended with data,
-* the caller receives this fresh data in stream from server.
+* Streaming provides access to an online data stream from an item in storage. Whenever data is appended to an item,
+* the caller receives this fresh data in a stream from the server.
 *
 *
 * @generated from protobuf service MiLaboratories.Controller.Shared.Streaming
@@ -18,68 +17,47 @@ var StreamingClient = class {
 		this._transport = _transport;
 	}
 	/**
-	* StreamBinary provides stream of binary file. Each response message keeps
-	* one single chunk of binary data from data source. See StreamingAPI.Binary message
-	* for more info on available options.
-	*
-	* @generated from protobuf rpc: StreamBinary
-	*/
-	streamBinary(input, options) {
-		const method = this.methods[0], opt = this._transport.mergeOptions(options);
-		return stackIntercept("serverStreaming", this._transport, method, opt, input);
-	}
-	/**
-	* ReadBinary allows to read remote item in chunks using stream-like API.
-	* The difference to StreamBinary is that the client receives single response for each
-	* call and has to send new calls to the server to get fresh data from remote item.
-	* Each response (each chunk from server) keeps not more than 3.9MiB of data.
+	* ReadBinary allows reading a remote item in chunks using a stream-like API.
+	* The client receives a single response for each call and has to send new calls
+	* to the server to get fresh data from the remote item.
+	* Each response (each chunk from the server) contains no more than 3.9MiB of data.
 	*
 	* @generated from protobuf rpc: ReadBinary
 	*/
 	readBinary(input, options) {
-		const method = this.methods[1], opt = this._transport.mergeOptions(options);
+		const method = this.methods[0], opt = this._transport.mergeOptions(options);
 		return stackIntercept("unary", this._transport, method, opt, input);
 	}
 	/**
-	* StreamText provides stream of textual file, splitting the data by newline symbol.
-	* Each response message keeps one single line of text from data source.
-	*
-	* @generated from protobuf rpc: StreamText
-	*/
-	streamText(input, options) {
-		const method = this.methods[2], opt = this._transport.mergeOptions(options);
-		return stackIntercept("serverStreaming", this._transport, method, opt, input);
-	}
-	/**
-	* ReadBinary allows to read remote item in chunks using stream-like API.
-	* The difference to StreamBinary is that the client receives single response for each
-	* call and has to send new calls to the server to get fresh data from remote item.
-	* Each response (each chunk from server) keeps not more than 3.9MiB of data.
+	* ReadText allows reading a remote item in chunks using a stream-like API.
+	* The client receives a single response for each call and has to send new calls
+	* to the server to get fresh data from the remote item.
+	* Each response (each chunk from the server) contains no more than 3.9MiB of data.
 	*
 	* @generated from protobuf rpc: ReadText
 	*/
 	readText(input, options) {
-		const method = this.methods[3], opt = this._transport.mergeOptions(options);
+		const method = this.methods[1], opt = this._transport.mergeOptions(options);
 		return stackIntercept("unary", this._transport, method, opt, input);
 	}
 	/**
-	* LastLines provides single message with the last lines from data source.
-	* When search pattern is specified, the last lines matching the given pattern are returned.
-	* The lines are returned in reversed order, as server reads data source from the end.
-	* Consider it as equivalent to 'tac <file> | grep <search> | head -n <line_count>'
+	* LastLines provides a single message with the last lines from the data source.
+	* When a search pattern is specified, the last lines matching the given pattern are returned.
+	* The lines are returned in reverse order, as the server reads the data source from the end.
+	* Consider it equivalent to 'tac <file> | grep <search> | head -n <line_count>'
 	* The <new_offset> returned in the response points to the _beginning_ of the last
-	* line found, so client can continue reading the file backwards in subsequent calls.
-	* This means, that use of this <new_offset> in ReadText() will return you the same line
-	* returned last in LastLines() data.
+	* line found, so the client can continue reading the file backwards in subsequent calls.
+	* This means that the use of this <new_offset> in ReadText() will return the last line
+	* returned in the LastLines() response.
 	*
 	* @generated from protobuf rpc: LastLines
 	*/
 	lastLines(input, options) {
-		const method = this.methods[4], opt = this._transport.mergeOptions(options);
+		const method = this.methods[2], opt = this._transport.mergeOptions(options);
 		return stackIntercept("unary", this._transport, method, opt, input);
 	}
 };
-
 //#endregion
 export { StreamingClient };
+
 //# sourceMappingURL=protocol.client.js.map

package/dist/proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.client.js.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.client.js","names":[],"sources":["../../../../../../../../../src/proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.client.ts"],"sourcesContent":["// @generated by protobuf-ts 2.11.1 with parameter client_generic,optimize_speed,generate_dependencies,force_server_none\n// @generated from protobuf file \"github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.proto\" (package \"MiLaboratories.Controller.Shared\", syntax proto3)\n// tslint:disable\nimport type { RpcTransport } from \"@protobuf-ts/runtime-rpc\";\nimport type { ServiceInfo } from \"@protobuf-ts/runtime-rpc\";\nimport { Streaming } from \"./protocol\";\nimport type { StreamingAPI_LastLines } from \"./protocol\";\nimport type { StreamingAPI_ReadText } from \"./protocol\";\nimport type { StreamingAPI_StreamText } from \"./protocol\";\nimport type { StreamingAPI_ReadBinary } from \"./protocol\";\nimport type { UnaryCall } from \"@protobuf-ts/runtime-rpc\";\nimport { stackIntercept } from \"@protobuf-ts/runtime-rpc\";\nimport type { StreamingAPI_Response } from \"./protocol\";\nimport type { StreamingAPI_StreamBinary } from \"./protocol\";\nimport type { ServerStreamingCall } from \"@protobuf-ts/runtime-rpc\";\nimport type { RpcOptions } from \"@protobuf-ts/runtime-rpc\";\n/**\n *\n * Streaming provides access to online data stream from item in storage. Whenever item is appended with data,\n * the caller receives this fresh data in stream from server.\n *\n *\n * @generated from protobuf service MiLaboratories.Controller.Shared.Streaming\n */\nexport interface IStreamingClient {\n    /**\n     * StreamBinary provides stream of binary file. Each response message keeps\n     * one single chunk of binary data from data source. See StreamingAPI.Binary message\n     * for more info on available options.\n     *\n     * @generated from protobuf rpc: StreamBinary\n     */\n    streamBinary(input: StreamingAPI_StreamBinary, options?: RpcOptions): ServerStreamingCall<StreamingAPI_StreamBinary, StreamingAPI_Response>;\n    /**\n     * ReadBinary allows to read remote item in chunks using stream-like API.\n     * The difference to StreamBinary is that the client receives single response for each\n     * call and has to send new calls to the server to get fresh data from remote item.\n     * Each response (each chunk from server) keeps not more than 3.9MiB of data.\n     *\n     * @generated from protobuf rpc: ReadBinary\n     */\n    readBinary(input: StreamingAPI_ReadBinary, options?: RpcOptions): UnaryCall<StreamingAPI_ReadBinary, StreamingAPI_Response>;\n    /**\n     * StreamText provides stream of textual file, splitting the data by newline symbol.\n     * Each response message keeps one single line of text from data source.\n     *\n     * @generated from protobuf rpc: StreamText\n     */\n    streamText(input: StreamingAPI_StreamText, options?: RpcOptions): ServerStreamingCall<StreamingAPI_StreamText, StreamingAPI_Response>;\n    /**\n     * ReadBinary allows to read remote item in chunks using stream-like API.\n     * The difference to StreamBinary is that the client receives single response for each\n     * call and has to send new calls to the server to get fresh data from remote item.\n     * Each response (each chunk from server) keeps not more than 3.9MiB of data.\n     *\n     * @generated from protobuf rpc: ReadText\n     */\n    readText(input: StreamingAPI_ReadText, options?: RpcOptions): UnaryCall<StreamingAPI_ReadText, StreamingAPI_Response>;\n    /**\n     * LastLines provides single message with the last lines from data source.\n     * When search pattern is specified, the last lines matching the given pattern are returned.\n     * The lines are returned in reversed order, as server reads data source from the end.\n     * Consider it as equivalent to 'tac <file> | grep <search> | head -n <line_count>'\n     * The <new_offset> returned in the response points to the _beginning_ of the last\n     * line found, so client can continue reading the file backwards in subsequent calls.\n     * This means, that use of this <new_offset> in ReadText() will return you the same line\n     * returned last in LastLines() data.\n     *\n     * @generated from protobuf rpc: LastLines\n     */\n    lastLines(input: StreamingAPI_LastLines, options?: RpcOptions): UnaryCall<StreamingAPI_LastLines, StreamingAPI_Response>;\n}\n/**\n *\n * Streaming provides access to online data stream from item in storage. Whenever item is appended with data,\n * the caller receives this fresh data in stream from server.\n *\n *\n * @generated from protobuf service MiLaboratories.Controller.Shared.Streaming\n */\nexport class StreamingClient implements IStreamingClient, ServiceInfo {\n    typeName = Streaming.typeName;\n    methods = Streaming.methods;\n    options = Streaming.options;\n    constructor(private readonly _transport: RpcTransport) {\n    }\n    /**\n     * StreamBinary provides stream of binary file. Each response message keeps\n     * one single chunk of binary data from data source. See StreamingAPI.Binary message\n     * for more info on available options.\n     *\n     * @generated from protobuf rpc: StreamBinary\n     */\n    streamBinary(input: StreamingAPI_StreamBinary, options?: RpcOptions): ServerStreamingCall<StreamingAPI_StreamBinary, StreamingAPI_Response> {\n        const method = this.methods[0], opt = this._transport.mergeOptions(options);\n        return stackIntercept<StreamingAPI_StreamBinary, StreamingAPI_Response>(\"serverStreaming\", this._transport, method, opt, input);\n    }\n    /**\n     * ReadBinary allows to read remote item in chunks using stream-like API.\n     * The difference to StreamBinary is that the client receives single response for each\n     * call and has to send new calls to the server to get fresh data from remote item.\n     * Each response (each chunk from server) keeps not more than 3.9MiB of data.\n     *\n     * @generated from protobuf rpc: ReadBinary\n     */\n    readBinary(input: StreamingAPI_ReadBinary, options?: RpcOptions): UnaryCall<StreamingAPI_ReadBinary, StreamingAPI_Response> {\n        const method = this.methods[1], opt = this._transport.mergeOptions(options);\n        return stackIntercept<StreamingAPI_ReadBinary, StreamingAPI_Response>(\"unary\", this._transport, method, opt, input);\n    }\n    /**\n     * StreamText provides stream of textual file, splitting the data by newline symbol.\n     * Each response message keeps one single line of text from data source.\n     *\n     * @generated from protobuf rpc: StreamText\n     */\n    streamText(input: StreamingAPI_StreamText, options?: RpcOptions): ServerStreamingCall<StreamingAPI_StreamText, StreamingAPI_Response> {\n        const method = this.methods[2], opt = this._transport.mergeOptions(options);\n        return stackIntercept<StreamingAPI_StreamText, StreamingAPI_Response>(\"serverStreaming\", this._transport, method, opt, input);\n    }\n    /**\n     * ReadBinary allows to read remote item in chunks using stream-like API.\n     * The difference to StreamBinary is that the client receives single response for each\n     * call and has to send new calls to the server to get fresh data from remote item.\n     * Each response (each chunk from server) keeps not more than 3.9MiB of data.\n     *\n     * @generated from protobuf rpc: ReadText\n     */\n    readText(input: StreamingAPI_ReadText, options?: RpcOptions): UnaryCall<StreamingAPI_ReadText, StreamingAPI_Response> {\n        const method = this.methods[3], opt = this._transport.mergeOptions(options);\n        return stackIntercept<StreamingAPI_ReadText, StreamingAPI_Response>(\"unary\", this._transport, method, opt, input);\n    }\n    /**\n     * LastLines provides single message with the last lines from data source.\n     * When search pattern is specified, the last lines matching the given pattern are returned.\n     * The lines are returned in reversed order, as server reads data source from the end.\n     * Consider it as equivalent to 'tac <file> | grep <search> | head -n <line_count>'\n     * The <new_offset> returned in the response points to the _beginning_ of the last\n     * line found, so client can continue reading the file backwards in subsequent calls.\n     * This means, that use of this <new_offset> in ReadText() will return you the same line\n     * returned last in LastLines() data.\n     *\n     * @generated from protobuf rpc: LastLines\n     */\n    lastLines(input: StreamingAPI_LastLines, options?: RpcOptions): UnaryCall<StreamingAPI_LastLines, StreamingAPI_Response> {\n        const method = this.methods[4], opt = this._transport.mergeOptions(options);\n        return stackIntercept<StreamingAPI_LastLines, StreamingAPI_Response>(\"unary\", this._transport, method, opt, input);\n    }\n}\n"],"mappings":";;;;;;;;;;;;AAgFA,IAAa,kBAAb,MAAsE;CAClE,WAAW,UAAU;CACrB,UAAU,UAAU;CACpB,UAAU,UAAU;CACpB,YAAY,AAAiB,YAA0B;EAA1B;;;;;;;;;CAS7B,aAAa,OAAkC,SAA6F;EACxI,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAAiE,mBAAmB,KAAK,YAAY,QAAQ,KAAK,MAAM;;;;;;;;;;CAUnI,WAAW,OAAgC,SAAiF;EACxH,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAA+D,SAAS,KAAK,YAAY,QAAQ,KAAK,MAAM;;;;;;;;CAQvH,WAAW,OAAgC,SAA2F;EAClI,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAA+D,mBAAmB,KAAK,YAAY,QAAQ,KAAK,MAAM;;;;;;;;;;CAUjI,SAAS,OAA8B,SAA+E;EAClH,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAA6D,SAAS,KAAK,YAAY,QAAQ,KAAK,MAAM;;;;;;;;;;;;;;CAcrH,UAAU,OAA+B,SAAgF;EACrH,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAA8D,SAAS,KAAK,YAAY,QAAQ,KAAK,MAAM"}
+{"version":3,"file":"protocol.client.js","names":[],"sources":["../../../../../../../../../src/proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.client.ts"],"sourcesContent":["// @generated by protobuf-ts 2.11.1 with parameter client_generic,optimize_speed,generate_dependencies,force_server_none\n// @generated from protobuf file \"github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.proto\" (package \"MiLaboratories.Controller.Shared\", syntax proto3)\n// tslint:disable\nimport type { RpcTransport } from \"@protobuf-ts/runtime-rpc\";\nimport type { ServiceInfo } from \"@protobuf-ts/runtime-rpc\";\nimport { Streaming } from \"./protocol\";\nimport type { StreamingAPI_LastLines } from \"./protocol\";\nimport type { StreamingAPI_ReadText } from \"./protocol\";\nimport { stackIntercept } from \"@protobuf-ts/runtime-rpc\";\nimport type { StreamingAPI_Response } from \"./protocol\";\nimport type { StreamingAPI_ReadBinary } from \"./protocol\";\nimport type { UnaryCall } from \"@protobuf-ts/runtime-rpc\";\nimport type { RpcOptions } from \"@protobuf-ts/runtime-rpc\";\n/**\n *\n * Streaming provides access to an online data stream from an item in storage. Whenever data is appended to an item,\n * the caller receives this fresh data in a stream from the server.\n *\n *\n * @generated from protobuf service MiLaboratories.Controller.Shared.Streaming\n */\nexport interface IStreamingClient {\n    /**\n     * ReadBinary allows reading a remote item in chunks using a stream-like API.\n     * The client receives a single response for each call and has to send new calls\n     * to the server to get fresh data from the remote item.\n     * Each response (each chunk from the server) contains no more than 3.9MiB of data.\n     *\n     * @generated from protobuf rpc: ReadBinary\n     */\n    readBinary(input: StreamingAPI_ReadBinary, options?: RpcOptions): UnaryCall<StreamingAPI_ReadBinary, StreamingAPI_Response>;\n    /**\n     * ReadText allows reading a remote item in chunks using a stream-like API.\n     * The client receives a single response for each call and has to send new calls\n     * to the server to get fresh data from the remote item.\n     * Each response (each chunk from the server) contains no more than 3.9MiB of data.\n     *\n     * @generated from protobuf rpc: ReadText\n     */\n    readText(input: StreamingAPI_ReadText, options?: RpcOptions): UnaryCall<StreamingAPI_ReadText, StreamingAPI_Response>;\n    /**\n     * LastLines provides a single message with the last lines from the data source.\n     * When a search pattern is specified, the last lines matching the given pattern are returned.\n     * The lines are returned in reverse order, as the server reads the data source from the end.\n     * Consider it equivalent to 'tac <file> | grep <search> | head -n <line_count>'\n     * The <new_offset> returned in the response points to the _beginning_ of the last\n     * line found, so the client can continue reading the file backwards in subsequent calls.\n     * This means that the use of this <new_offset> in ReadText() will return the last line\n     * returned in the LastLines() response.\n     *\n     * @generated from protobuf rpc: LastLines\n     */\n    lastLines(input: StreamingAPI_LastLines, options?: RpcOptions): UnaryCall<StreamingAPI_LastLines, StreamingAPI_Response>;\n}\n/**\n *\n * Streaming provides access to an online data stream from an item in storage. Whenever data is appended to an item,\n * the caller receives this fresh data in a stream from the server.\n *\n *\n * @generated from protobuf service MiLaboratories.Controller.Shared.Streaming\n */\nexport class StreamingClient implements IStreamingClient, ServiceInfo {\n    typeName = Streaming.typeName;\n    methods = Streaming.methods;\n    options = Streaming.options;\n    constructor(private readonly _transport: RpcTransport) {\n    }\n    /**\n     * ReadBinary allows reading a remote item in chunks using a stream-like API.\n     * The client receives a single response for each call and has to send new calls\n     * to the server to get fresh data from the remote item.\n     * Each response (each chunk from the server) contains no more than 3.9MiB of data.\n     *\n     * @generated from protobuf rpc: ReadBinary\n     */\n    readBinary(input: StreamingAPI_ReadBinary, options?: RpcOptions): UnaryCall<StreamingAPI_ReadBinary, StreamingAPI_Response> {\n        const method = this.methods[0], opt = this._transport.mergeOptions(options);\n        return stackIntercept<StreamingAPI_ReadBinary, StreamingAPI_Response>(\"unary\", this._transport, method, opt, input);\n    }\n    /**\n     * ReadText allows reading a remote item in chunks using a stream-like API.\n     * The client receives a single response for each call and has to send new calls\n     * to the server to get fresh data from the remote item.\n     * Each response (each chunk from the server) contains no more than 3.9MiB of data.\n     *\n     * @generated from protobuf rpc: ReadText\n     */\n    readText(input: StreamingAPI_ReadText, options?: RpcOptions): UnaryCall<StreamingAPI_ReadText, StreamingAPI_Response> {\n        const method = this.methods[1], opt = this._transport.mergeOptions(options);\n        return stackIntercept<StreamingAPI_ReadText, StreamingAPI_Response>(\"unary\", this._transport, method, opt, input);\n    }\n    /**\n     * LastLines provides a single message with the last lines from the data source.\n     * When a search pattern is specified, the last lines matching the given pattern are returned.\n     * The lines are returned in reverse order, as the server reads the data source from the end.\n     * Consider it equivalent to 'tac <file> | grep <search> | head -n <line_count>'\n     * The <new_offset> returned in the response points to the _beginning_ of the last\n     * line found, so the client can continue reading the file backwards in subsequent calls.\n     * This means that the use of this <new_offset> in ReadText() will return the last line\n     * returned in the LastLines() response.\n     *\n     * @generated from protobuf rpc: LastLines\n     */\n    lastLines(input: StreamingAPI_LastLines, options?: RpcOptions): UnaryCall<StreamingAPI_LastLines, StreamingAPI_Response> {\n        const method = this.methods[2], opt = this._transport.mergeOptions(options);\n        return stackIntercept<StreamingAPI_LastLines, StreamingAPI_Response>(\"unary\", this._transport, method, opt, input);\n    }\n}\n"],"mappings":";;;;;;;;;;;AA8DA,IAAa,kBAAb,MAAsE;CAClE,WAAW,UAAU;CACrB,UAAU,UAAU;CACpB,UAAU,UAAU;CACpB,YAAY,YAA2C;AAA1B,OAAA,aAAA;;;;;;;;;;CAU7B,WAAW,OAAgC,SAAiF;EACxH,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAA+D,SAAS,KAAK,YAAY,QAAQ,KAAK,MAAM;;;;;;;;;;CAUvH,SAAS,OAA8B,SAA+E;EAClH,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAA6D,SAAS,KAAK,YAAY,QAAQ,KAAK,MAAM;;;;;;;;;;;;;;CAcrH,UAAU,OAA+B,SAAgF;EACrH,MAAM,SAAS,KAAK,QAAQ,IAAI,MAAM,KAAK,WAAW,aAAa,QAAQ;AAC3E,SAAO,eAA8D,SAAS,KAAK,YAAY,QAAQ,KAAK,MAAM"}

package/dist/proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.d.ts

@@ -3,54 +3,23 @@ import { BinaryReadOptions, BinaryWriteOptions, IBinaryReader, IBinaryWriter, Me
 
 //#region src/proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.d.ts
 /**
- * @generated from protobuf message MiLaboratories.Controller.Shared.StreamingAPI.StreamBinary
+ * @generated from protobuf message MiLaboratories.Controller.Shared.StreamingAPI.ReadBinary
  */
-interface StreamingAPI_StreamBinary {
+interface StreamingAPI_ReadBinary {
   /**
-   * <resource_id> of Stream resource, that keeps info on item to be streamed.
+   * <resource_id> of Stream resource that keeps info on item to be streamed.
    *
    * @generated from protobuf field: uint64 resource_id = 1
    */
   resourceId: bigint;
   /**
-   * <offset> makes streamer to perform seek operation to given offset before sending the data.
-   *
-   * @generated from protobuf field: int64 offset = 2
-   */
-  offset: bigint;
-  /**
-   * <chunk_size> limits the maximum size of <data> for each response message in stream.
-   *
-   * Default value: 32 768 (32 KiB)
-   * Max value: 3900 * 1024 (3.9 MiB)
+   * Signature proving the caller is authorized to access this resource.
    *
-   * @generated from protobuf field: optional uint32 chunk_size = 11
+   * @generated from protobuf field: optional bytes resource_signature = 3
    */
-  chunkSize?: number;
+  resourceSignature?: Uint8Array;
   /**
-   * <read_limit> allows client to limit total data sent from server.
-   * This limit is aggregation of all data, sent in all chunks.
-   * E.g. to read 2000 bytes of data in chunks of at most
-   * 130 bytes, use <chunk_size> = 130; <read_limit> = 2000.
-   * For storage item of appropriate size this settings will result in
-   * 16 messages from server: 15 of 130 bytes and one of 50 bytes.
-   *
-   * @generated from protobuf field: optional int64 read_limit = 20
-   */
-  readLimit?: bigint;
-}
-/**
- * @generated from protobuf message MiLaboratories.Controller.Shared.StreamingAPI.ReadBinary
- */
-interface StreamingAPI_ReadBinary {
-  /**
-   * <resource_id> of Stream resource, that keeps info on item to be streamed.
-   *
-   * @generated from protobuf field: uint64 resource_id = 1
-   */
-  resourceId: bigint;
-  /**
-   * <offset> makes streamer to perform seek operation to given offset before sending the data.
+   * <offset> makes the streamer perform a seek operation to the given offset before sending the data.
    *
    * @generated from protobuf field: int64 offset = 2
    */
@@ -66,94 +35,54 @@ interface StreamingAPI_ReadBinary {
   chunkSize?: number;
 }
 /**
- * @generated from protobuf message MiLaboratories.Controller.Shared.StreamingAPI.StreamText
+ * @generated from protobuf message MiLaboratories.Controller.Shared.StreamingAPI.ReadText
  */
-interface StreamingAPI_StreamText {
+interface StreamingAPI_ReadText {
   /**
-   * <resource_id> of Stream resource, that keeps info on item to be streamed.
+   * <resource_id> of Stream resource that keeps info on item to be streamed.
    *
    * @generated from protobuf field: uint64 resource_id = 1
    */
   resourceId: bigint;
   /**
-   * <offset> makes streamer to perform seek operation to given offset before sending the contents.
-   * This offset is taken in BYTES, as it eases streaming recovery after client reconnection or controller restart.
-   * Client can just use the <new_offset> value of the last response from server to continue streaming after reconnection.
+   * Signature proving the caller is authorized to access this resource.
    *
-   * @generated from protobuf field: int64 offset = 2
+   * @generated from protobuf field: optional bytes resource_signature = 3
    */
-  offset: bigint;
+  resourceSignature?: Uint8Array;
   /**
-   * <read_limit> allows client to limit total data sent from server.
-   * This limit is aggregation of all data, sent in all chunks, measured
-   * in lines of text.
-   * E.g. to read top 1000 lines from stream source, use <read_limit> = 1000.
-   * When both <read_limit> and <search>/<search_re> are set, the <read_limit> is applied first.
-   * this is equivalent to 'head -n <read_limit> | grep <search>'.
-   *
-   * @generated from protobuf field: optional int64 read_limit = 20
-   */
-  readLimit?: bigint;
-  /**
-   * <search> is substring for line search pattern.
-   * This option makes controller to send to the client only lines, that
-   * have given substring.
-   *
-   * @generated from protobuf field: optional string search = 21
-   */
-  search?: string;
-  /**
-   * <search_re> is regular expression for line search pattern.
-   * This option makes controller to send to the client only lines, that
-   * match given regular expression.
-   *
-   * @generated from protobuf field: optional string search_re = 22
-   */
-  searchRe?: string;
-}
-/**
- * @generated from protobuf message MiLaboratories.Controller.Shared.StreamingAPI.ReadText
- */
-interface StreamingAPI_ReadText {
-  /**
-   * <resource_id> of Stream resource, that keeps info on item to be streamed.
-   *
-   * @generated from protobuf field: uint64 resource_id = 1
-   */
-  resourceId: bigint;
-  /**
-   * <offset> makes streamer to perform seek operation to given offset before sending the contents.
-   * This offset is taken in BYTES, as it eases streaming recovery after client reconnection or controller restart.
-   * Client can just use the <new_offset> value of the last response from server to continue streaming after reconnection.
+   * <offset> makes the streamer perform a seek operation to the given offset before sending the contents.
+   * This offset is taken in BYTES, as it eases streaming recovery after a client reconnection or controller restart.
+   * The client can just use the <new_offset> value of the last response from the server to continue streaming after reconnection.
    *
    * @generated from protobuf field: int64 offset = 2
    */
   offset: bigint;
   /**
-   * <read_limit> allows client to limit total data sent from server.
+   * <read_limit> allows the client to limit total data sent from the server.
    * Measured in lines of text.
    * E.g. to read top 1000 lines from stream source, use <read_limit> = 1000.
    * When both <read_limit> and <search>/<search_re> are set, the <read_limit> is applied first.
-   * this is equivalent to 'head -n <read_limit> | grep <search>'.
-   * At most 3.9 MiB (3900 * 1024 KiB) of data is returned in single read regardless of <read_limit> option
+   * This is equivalent to 'head -n <read_limit> | grep <search>'.
+   * At most 3.9 MiB (3900 KiB) of data is returned in a single read regardless of the <read_limit> option
    * Only full lines of text are returned except for the last line from the completed source
-   * (the one that is not expected to have new data, like blob in storage)
+   * (the one that is not expected to have new data, like a blob in storage)
    *
    * @generated from protobuf field: optional int64 read_limit = 20
    */
   readLimit?: bigint;
   /**
-   * <search> is substring for line search pattern.
-   * This option makes controller to send to the client only lines, that
-   * have given substring.
+   * <search> is a substring for the line search pattern.
+   * This option makes the controller send to the client only lines that
+   * have the given substring.
    *
    * @generated from protobuf field: optional string search = 21
    */
   search?: string;
   /**
-   * <search_re> is regular expression for line search pattern.
-   * This option makes controller to send to the client only lines, that
-   * match given regular expression.
+   * <search_re> is a regular expression for the line search pattern.
+   * This option makes the controller send to the client only lines that
+   * match the given regular expression.
    *
    * @generated from protobuf field: optional string search_re = 22
    */
@@ -164,39 +93,45 @@ interface StreamingAPI_ReadText {
  */
 interface StreamingAPI_LastLines {
   /**
-   * <resource_id> of Stream resource, that keeps info on item to be streamed.
+   * <resource_id> of Stream resource that keeps info on item to be streamed.
    *
    * @generated from protobuf field: uint64 resource_id = 1
    */
   resourceId: bigint;
   /**
-   * <offset> makes streamer to perform seek operation to given offset before sending the contents.
-   * This offset is taken in BYTES, as it eases streaming recovery after client reconnection or controller restart.
-   * By default, LastLines starts to treat the data source from the very last byte available in data stream
-   * at the moment of call, but client can set the server to start from earlier position.
+   * Signature proving the caller is authorized to access this resource.
+   *
+   * @generated from protobuf field: optional bytes resource_signature = 4
+   */
+  resourceSignature?: Uint8Array;
+  /**
+   * <offset> makes the streamer perform a seek operation to the given offset before sending the contents.
+   * This offset is taken in BYTES, as it eases streaming recovery after a client reconnection or controller restart.
+   * By default, LastLines starts reading the data source from the very last byte available in the data stream
+   * at the moment of the call, but the client can set the server to start from an earlier position.
    *
    * @generated from protobuf field: optional int64 offset = 2
    */
   offset?: bigint;
   /**
-   * <line_count> makes streamer to return up to <line_count> lines to the client.
+   * <line_count> makes the streamer return up to <line_count> lines to the client.
    * Default value: 1
    *
    * @generated from protobuf field: optional int32 line_count = 3
    */
   lineCount?: number;
   /**
-   * <search> is substring for line search pattern.
-   * This option makes controller to send to the client only lines, that
-   * have given substring.
+   * <search> is a substring for the line search pattern.
+   * This option makes the controller send to the client only lines that
+   * have the given substring.
    *
    * @generated from protobuf field: optional string search = 21
    */
   search?: string;
   /**
-   * <search_re> is regular expression for line search pattern.
-   * This option makes controller to send to the client only lines, that
-   * match given regular expression.
+   * <search_re> is a regular expression for the line search pattern.
+   * This option makes the controller send to the client only lines that
+   * match the given regular expression.
    *
    * @generated from protobuf field: optional string search_re = 22
    */
@@ -207,16 +142,16 @@ interface StreamingAPI_LastLines {
  */
 interface StreamingAPI_Response {
   /**
-   * data chunk from item, starting from the <new_offset> of the previous message in the same stream.
+   * data chunk from the item, starting from the <new_offset> of the previous message in the same stream.
    *
    * @generated from protobuf field: bytes data = 1
    */
   data: Uint8Array;
   /**
    * <size> is the actual size of the streamed item at the moment of this message.
-   * This might be not a final amount of streamed data, as stream source can be updated
-   * by other independent process (e.g., data is written to log file).
-   * This field in combination with <new_offset> shows, how far the client is from the end
+   * This might not be the final amount of streamed data, as the stream source can be updated
+   * by another independent process (e.g., data is written to a log file).
+   * This field in combination with <new_offset> shows how far the client is from the end
    * of the data right now.
    *
    * @generated from protobuf field: uint64 size = 2
@@ -224,9 +159,9 @@ interface StreamingAPI_Response {
   size: bigint;
   /**
    * <new_offset> is the new offset in bytes from the start of the streamed item,
-   * including size of <data> in current response.
-   * Call to Stream rpc with <offset> = <new_offset> will continue
-   * streaming from the place of last received message
+   * including the size of <data> in the current response.
+   * A call to the Stream RPC with <offset> = <new_offset> will continue
+   * streaming from the place of the last received message
    * (e.g. <offset> = <new_offset> - 1 will repeat the last byte of
    * previously received <data>)
    *
@@ -234,16 +169,6 @@ interface StreamingAPI_Response {
    */
   newOffset: bigint;
 }
-declare class StreamingAPI_StreamBinary$Type extends MessageType<StreamingAPI_StreamBinary> {
-  constructor();
-  create(value?: PartialMessage<StreamingAPI_StreamBinary>): StreamingAPI_StreamBinary;
-  internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamingAPI_StreamBinary): StreamingAPI_StreamBinary;
-  internalBinaryWrite(message: StreamingAPI_StreamBinary, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
-}
-/**
- * @generated MessageType for protobuf message MiLaboratories.Controller.Shared.StreamingAPI.StreamBinary
- */
-declare const StreamingAPI_StreamBinary: StreamingAPI_StreamBinary$Type;
 declare class StreamingAPI_ReadBinary$Type extends MessageType<StreamingAPI_ReadBinary> {
   constructor();
   create(value?: PartialMessage<StreamingAPI_ReadBinary>): StreamingAPI_ReadBinary;
@@ -254,16 +179,6 @@ declare class StreamingAPI_ReadBinary$Type extends MessageType<StreamingAPI_Read
  * @generated MessageType for protobuf message MiLaboratories.Controller.Shared.StreamingAPI.ReadBinary
  */
 declare const StreamingAPI_ReadBinary: StreamingAPI_ReadBinary$Type;
-declare class StreamingAPI_StreamText$Type extends MessageType<StreamingAPI_StreamText> {
-  constructor();
-  create(value?: PartialMessage<StreamingAPI_StreamText>): StreamingAPI_StreamText;
-  internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StreamingAPI_StreamText): StreamingAPI_StreamText;
-  internalBinaryWrite(message: StreamingAPI_StreamText, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
-}
-/**
- * @generated MessageType for protobuf message MiLaboratories.Controller.Shared.StreamingAPI.StreamText
- */
-declare const StreamingAPI_StreamText: StreamingAPI_StreamText$Type;
 declare class StreamingAPI_ReadText$Type extends MessageType<StreamingAPI_ReadText> {
   constructor();
   create(value?: PartialMessage<StreamingAPI_ReadText>): StreamingAPI_ReadText;
@@ -295,5 +210,5 @@ declare class StreamingAPI_Response$Type extends MessageType<StreamingAPI_Respon
  */
 declare const StreamingAPI_Response: StreamingAPI_Response$Type;
 //#endregion
-export { StreamingAPI_LastLines, StreamingAPI_ReadBinary, StreamingAPI_ReadText, StreamingAPI_Response, StreamingAPI_StreamBinary, StreamingAPI_StreamText };
+export { StreamingAPI_LastLines, StreamingAPI_ReadBinary, StreamingAPI_ReadText, StreamingAPI_Response };
 //# sourceMappingURL=protocol.d.ts.map

package/dist/proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","names":[],"sources":["../../../../../../../../../src/proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.ts"],"mappings":";;;;;;;UAqBiB,uBAAA;EAgCqB;;;;;EA1BlC,UAAA;EA8CA;;;;;EAxCA,iBAAA,GAAoB,UAAA;EA0EP;;;;;EApEb,MAAA;EAgFoB;;;;;;;AAqCxB;EA5GI,SAAA;AAAA;;;;UAKa,qBAAA;EAkIb;;;AAuCgD;;EAnKhD,UAAA;EAqKmD;;;;;EA/JnD,iBAAA,GAAoB,UAAA;EAgL2E;;;;;;;EAxK/F,MAAA;EAuJkD;;;;;;;;;;;;EA1IlD,SAAA;EA2JmE;;;;;;;EAnJnE,MAAA;EA+K8D;;;;;;;EAvK9D,QAAA;AAAA;;;;UAKa,sBAAA;EA0LgB;;;;;EApL7B,UAAA;EAuM2B;;;;;EAjM3B,iBAAA,GAAoB,UAAA;EAmOgE;;;;;;;;EA1NpF,MAAA;EAgLe;;;;;;EAzKf,SAAA;EAiL0C;;;;;;;EAzK1C,MAAA;EA2MoB;;;;;;;EAnMpB,QAAA;AAAA;;;;UAKa,qBAAA;EA4NX;;;;;EAtNF,IAAA,EAAM,UAAA;EAiOkD;;;;;;;;;EAvNxD,IAAA;EA4MiD;;;;;;;;;;EAjMjD,SAAA;AAAA;AAAA,cAyCE,4BAAA,SAAqC,WAAA,CAAY,uBAAA;;EASnD,MAAA,CAAO,KAAA,GAAQ,cAAA,CAAe,uBAAA,IAA2B,uBAAA;EAQzD,kBAAA,CAAmB,MAAA,EAAQ,aAAA,EAAe,MAAA,UAAgB,OAAA,EAAS,iBAAA,EAAmB,MAAA,GAAS,uBAAA,GAA0B,uBAAA;EA4BzH,mBAAA,CAAoB,OAAA,EAAS,uBAAA,EAAyB,MAAA,EAAQ,aAAA,EAAe,OAAA,EAAS,kBAAA,GAAqB,aAAA;AAAA;;AA2L/G;;cArKa,uBAAA,EAAuB,4BAAA;AAAA,cAE9B,0BAAA,SAAmC,WAAA,CAAY,qBAAA;;EAWjD,MAAA,CAAO,KAAA,GAAQ,cAAA,CAAe,qBAAA,IAAyB,qBAAA;EAQvD,kBAAA,CAAmB,MAAA,EAAQ,aAAA,EAAe,MAAA,UAAgB,OAAA,EAAS,iBAAA,EAAmB,MAAA,GAAS,qBAAA,GAAwB,qBAAA;EAkCvH,mBAAA,CAAoB,OAAA,EAAS,qBAAA,EAAuB,MAAA,EAAQ,aAAA,EAAe,OAAA,EAAS,kBAAA,GAAqB,aAAA;AAAA;;;;cA4BhG,qBAAA,EAAqB,0BAAA;AAAA,cAE5B,2BAAA,SAAoC,WAAA,CAAY,sBAAA;;EAWlD,MAAA,CAAO,KAAA,GAAQ,cAAA,CAAe,sBAAA,IAA0B,sBAAA;EAOxD,kBAAA,CAAmB,MAAA,EAAQ,aAAA,EAAe,MAAA,UAAgB,OAAA,EAAS,iBAAA,EAAmB,MAAA,GAAS,sBAAA,GAAyB,sBAAA;EAkCxH,mBAAA,CAAoB,OAAA,EAAS,sBAAA,EAAwB,MAAA,EAAQ,aAAA,EAAe,OAAA,EAAS,kBAAA,GAAqB,aAAA;AAAA;;;;cA4BjG,sBAAA,EAAsB,2BAAA;AAAA,cAE7B,0BAAA,SAAmC,WAAA,CAAY,qBAAA;;EAQjD,MAAA,CAAO,KAAA,GAAQ,cAAA,CAAe,qBAAA,IAAyB,qBAAA;EASvD,kBAAA,CAAmB,MAAA,EAAQ,aAAA,EAAe,MAAA,UAAgB,OAAA,EAAS,iBAAA,EAAmB,MAAA,GAAS,qBAAA,GAAwB,qBAAA;EAyBvH,mBAAA,CAAoB,OAAA,EAAS,qBAAA,EAAuB,MAAA,EAAQ,aAAA,EAAe,OAAA,EAAS,kBAAA,GAAqB,aAAA;AAAA;;;;cAmBhG,qBAAA,EAAqB,0BAAA"}