@milaboratories/pl-drivers 1.12.7 → 1.12.8

package/src/proto-rest/lsapi.ts

@@ -35,59 +35,64 @@ export interface components {
       /** @description resource_id of 'LS/<Storage>' resource */
       resourceId: string;
       /**
-       * @description location to list, absolute to storage root. Only items, that have <full_name> starting
-       *      from <location> are included into list response.
+       * Format: bytes
+       * @description Signature proving the caller is authorized to access this resource.
+       */
+      resourceSignature: string;
+      /**
+       * @description Location to list, relative to the storage root. Only items that have <full_name> starting
+       *      with <location> are included in the list response.
        */
       location: string;
     };
     List_Response: {
       /**
-       * @description List of the full (absolute to storage root) names of items from storage.
+       * @description List of the full (relative to storage root) names of items from storage.
        *      E.g., for 'fs' storage each name will consist of names of all directories, where the
        *      item is located, and the item name itself.
        *      The delimiter, used in names, is storage-specific and is NOT guaranteed to be '/'.
        */
       items: components["schemas"]["LsAPI_ListItem"][];
       /**
-       * @description delimiter is path separator, used in this storage. Client can use it to parse item names into parts,
+       * @description The delimiter is the path separator used in this storage. The client can use it to parse item names into parts,
        *      to extract directory names.
        */
       delimiter: string;
     };
     LsAPI_ListItem: {
-      /** @description name of the item in storage, without any prefixes */
+      /** @description Name of the item in storage, without any prefixes. */
       name: string;
       /**
-       * @description size of item in bytes
-       *      is always zero for directories (is_dir = true)
+       * @description Size of the item in bytes.
+       *      Is always zero for directories (is_dir = true).
        */
       size: string;
-      /** @description is_dir is true for item, that can have subitems. */
+      /** @description is_dir is true for an item that can have subitems. */
       isDir: boolean;
       /**
-       * @description full_name is the name of item absolute to storage root.
-       *      it is <directory> + <name>
+       * @description full_name is the full name of the item, relative to the storage root.
+       *      It is <directory> + <name>.
        *      The <delimiter>, used in names, is storage-specific and is NOT guaranteed to be '/'.
        */
       fullName: string;
       /**
-       * @description directory, the item is located in. The value here is always a prefix of name:
+       * @description The directory the item is located in. The value here is always a prefix of name:
        *      name.HasPrefix(directory) is always true.
        */
       directory: string;
       /**
        * Format: date-time
-       * @description last_modified keeps the item last modification timestamp
+       * @description last_modified keeps the item's last modification timestamp.
        */
       lastModified: string;
       /**
-       * @description version of item in storage.
-       *      When storage supports versioning or provides checksums for the data stored,
+       * @description Version of item in storage.
+       *      When the storage supports versioning or provides checksums for the data stored,
        *      the <version> field keeps that data.
-       *      If not - it keeps the any simple combination of item attributes, that helps to
-       *      detect if the contents of item has changed, e.g. <size>+<mtime>.
-       *      Anyway, client should not try to interpret this field, but should provide it to the Platform
-       *      in operations with given item (like BlobImportInternal) to help Platform with deduplication.
+       *      If not, it keeps any simple combination of item attributes that helps to
+       *      detect if the contents of the item have changed, e.g. <size>+<mtime>.
+       *      Anyway, the client should not try to interpret this field, but should provide it to the Platform
+       *      in operations with a given item (like BlobImportInternal) to help the Platform with deduplication.
        */
       version: string;
     };

package/src/proto-rest/progressapi.ts

@@ -42,6 +42,8 @@ export interface components {
   schemas: {
     GetStatus_Request: {
       resourceId: string;
+      /** Format: bytes */
+      resourceSignature: string;
     };
     GetStatus_Response: {
       report: components["schemas"]["ProgressAPI_Report"];
@@ -64,6 +66,8 @@ export interface components {
     };
     RealtimeStatus_Request: {
       resourceId: string;
+      /** Format: bytes */
+      resourceSignature: string;
       updateInterval: string;
     };
     RealtimeStatus_Response: {

package/src/proto-rest/streamingapi.ts

@@ -14,14 +14,14 @@ export interface paths {
     get?: never;
     put?: never;
     /**
-     * @description 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>'
+     * @description 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.
      */
     post: operations["Streaming_LastLines"];
     delete?: never;
@@ -40,10 +40,10 @@ export interface paths {
     get?: never;
     put?: never;
     /**
-     * @description 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.
+     * @description 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.
      */
     post: operations["Streaming_ReadBinary"];
     delete?: never;
@@ -62,10 +62,10 @@ export interface paths {
     get?: never;
     put?: never;
     /**
-     * @description 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.
+     * @description 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.
      */
     post: operations["Streaming_ReadText"];
     delete?: never;
@@ -74,47 +74,6 @@ export interface paths {
     patch?: never;
     trace?: never;
   };
-  "/v1/stream/binary": {
-    parameters: {
-      query?: never;
-      header?: never;
-      path?: never;
-      cookie?: never;
-    };
-    get?: never;
-    put?: never;
-    /**
-     * @description 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.
-     */
-    post: operations["Streaming_StreamBinary"];
-    delete?: never;
-    options?: never;
-    head?: never;
-    patch?: never;
-    trace?: never;
-  };
-  "/v1/stream/text": {
-    parameters: {
-      query?: never;
-      header?: never;
-      path?: never;
-      cookie?: never;
-    };
-    get?: never;
-    put?: never;
-    /**
-     * @description StreamText provides stream of textual file, splitting the data by newline symbol.
-     *      Each response message keeps one single line of text from data source.
-     */
-    post: operations["Streaming_StreamText"];
-    delete?: never;
-    options?: never;
-    head?: never;
-    patch?: never;
-    trace?: never;
-  };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -139,38 +98,48 @@ export interface components {
       details: components["schemas"]["GoogleProtobufAny"][];
     };
     StreamingAPI_LastLines: {
-      /** @description <resource_id> of Stream resource, that keeps info on item to be streamed. */
+      /** @description <resource_id> of Stream resource that keeps info on item to be streamed. */
       resourceId: string;
       /**
-       * @description <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.
+       * Format: bytes
+       * @description Signature proving the caller is authorized to access this resource.
+       */
+      resourceSignature: string;
+      /**
+       * @description <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.
        */
       offset: string;
       /**
        * Format: int32
-       * @description <line_count> makes streamer to return up to <line_count> lines to the client.
+       * @description <line_count> makes the streamer return up to <line_count> lines to the client.
        *      Default value: 1
        */
       lineCount: number;
       /**
-       * @description <search> is substring for line search pattern.
-       *      This option makes controller to send to the client only lines, that
-       *      have given substring.
+       * @description <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.
        */
       search: string;
       /**
-       * @description <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.
+       * @description <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.
        */
       searchRe: string;
     };
     StreamingAPI_ReadBinary: {
-      /** @description <resource_id> of Stream resource, that keeps info on item to be streamed. */
+      /** @description <resource_id> of Stream resource that keeps info on item to be streamed. */
       resourceId: string;
-      /** @description <offset> makes streamer to perform seek operation to given offset before sending the data. */
+      /**
+       * Format: bytes
+       * @description Signature proving the caller is authorized to access this resource.
+       */
+      resourceSignature: string;
+      /** @description <offset> makes the streamer perform a seek operation to the given offset before sending the data. */
       offset: string;
       /**
        * Format: uint32
@@ -182,116 +151,67 @@ export interface components {
       chunkSize: number;
     };
     StreamingAPI_ReadText: {
-      /** @description <resource_id> of Stream resource, that keeps info on item to be streamed. */
+      /** @description <resource_id> of Stream resource that keeps info on item to be streamed. */
       resourceId: string;
       /**
-       * @description <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.
+       * Format: bytes
+       * @description Signature proving the caller is authorized to access this resource.
+       */
+      resourceSignature: string;
+      /**
+       * @description <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.
        */
       offset: string;
       /**
-       * @description <read_limit> allows client to limit total data sent from server.
+       * @description <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)
        */
       readLimit: string;
       /**
-       * @description <search> is substring for line search pattern.
-       *      This option makes controller to send to the client only lines, that
-       *      have given substring.
+       * @description <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.
        */
       search: string;
       /**
-       * @description <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.
+       * @description <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.
        */
       searchRe: string;
     };
     StreamingAPI_Response: {
       /**
        * Format: bytes
-       * @description data chunk from item, starting from the <new_offset> of the previous message in the same stream.
+       * @description data chunk from the item, starting from the <new_offset> of the previous message in the same stream.
        */
       data: string;
       /**
        * @description <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.
        */
       size: string;
       /**
        * @description <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>)
        */
       newOffset: string;
     };
-    StreamingAPI_StreamBinary: {
-      /** @description <resource_id> of Stream resource, that keeps info on item to be streamed. */
-      resourceId: string;
-      /** @description <offset> makes streamer to perform seek operation to given offset before sending the data. */
-      offset: string;
-      /**
-       * Format: uint32
-       * @description <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)
-       */
-      chunkSize: number;
-      /**
-       * @description <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.
-       */
-      readLimit: string;
-    };
-    StreamingAPI_StreamText: {
-      /** @description <resource_id> of Stream resource, that keeps info on item to be streamed. */
-      resourceId: string;
-      /**
-       * @description <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: string;
-      /**
-       * @description <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>'.
-       */
-      readLimit: string;
-      /**
-       * @description <search> is substring for line search pattern.
-       *      This option makes controller to send to the client only lines, that
-       *      have given substring.
-       */
-      search: string;
-      /**
-       * @description <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.
-       */
-      searchRe: string;
-    };
   };
   responses: never;
   parameters: never;
@@ -400,70 +320,4 @@ export interface operations {
       };
     };
   };
-  Streaming_StreamBinary: {
-    parameters: {
-      query?: never;
-      header?: never;
-      path?: never;
-      cookie?: never;
-    };
-    requestBody: {
-      content: {
-        "application/json": components["schemas"]["StreamingAPI_StreamBinary"];
-      };
-    };
-    responses: {
-      /** @description OK */
-      200: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": components["schemas"]["StreamingAPI_Response"];
-        };
-      };
-      /** @description Default error response */
-      default: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": components["schemas"]["Status"];
-        };
-      };
-    };
-  };
-  Streaming_StreamText: {
-    parameters: {
-      query?: never;
-      header?: never;
-      path?: never;
-      cookie?: never;
-    };
-    requestBody: {
-      content: {
-        "application/json": components["schemas"]["StreamingAPI_StreamText"];
-      };
-    };
-    responses: {
-      /** @description OK */
-      200: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": components["schemas"]["StreamingAPI_Response"];
-        };
-      };
-      /** @description Default error response */
-      default: {
-        headers: {
-          [name: string]: unknown;
-        };
-        content: {
-          "application/json": components["schemas"]["Status"];
-        };
-      };
-    };
-  };
 }