@milaboratories/pl-drivers 1.12.7 → 1.12.8

package/src/proto-rest/uploadapi.ts

@@ -14,9 +14,9 @@ export interface paths {
     get?: never;
     put?: never;
     /**
-     * @description Finalize informs Controller that the upload process is done.
-     *      Returns an error, if the total size of all uploaded chunks is not equal to
-     *      size of the upload given in Init.
+     * @description Finalize informs the Controller that the upload process is done.
+     *      Returns an error if the total size of all uploaded chunks is not equal to
+     *      the size of the upload given in Init.
      */
     post: operations["Upload_Finalize"];
     delete?: never;
@@ -35,7 +35,7 @@ export interface paths {
     get?: never;
     put?: never;
     /**
-     * @description GetPartURL provides URL for uploading chunk of the data.
+     * @description GetPartURL provides a URL for uploading a chunk of the data.
      *      Clients are expected to put their data directly to the given location.
      */
     post: operations["Upload_GetPartURL"];
@@ -54,7 +54,7 @@ export interface paths {
     };
     get?: never;
     put?: never;
-    /** @description Init upload, making controller to do all required preparation steps. */
+    /** @description Initialize the upload, making the controller do all required preparation steps. */
     post: operations["Upload_Init"];
     delete?: never;
     options?: never;
@@ -62,6 +62,28 @@ export interface paths {
     patch?: never;
     trace?: never;
   };
+  "/v1/upload/reset": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * @description Reset the current upload progress (remove uploaded parts and so on) to start over.
+     *      This is useful when a checksum mismatch is detected by the client during upload
+     *      and the data requires a full re-upload.
+     *      The server never resets the upload on its own; it is always the client's initiative.
+     */
+    post: operations["Upload_Reset"];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   "/v1/upload/update-progress": {
     parameters: {
       query?: never;
@@ -71,7 +93,7 @@ export interface paths {
     };
     get?: never;
     put?: never;
-    /** @description UpdateProgress of the upload, so other clients can see how it is going. */
+    /** @description Update the progress of the upload, so other clients can see how it is going. */
     post: operations["Upload_UpdateProgress"];
     delete?: never;
     options?: never;
@@ -85,6 +107,26 @@ export interface components {
   schemas: {
     Finalize_Request: {
       resourceId: string;
+      /**
+       * Format: bytes
+       * @description Signature proving the caller is authorized to access this resource.
+       */
+      resourceSignature: string;
+      /**
+       * Format: enum
+       * @description The client can send the final checksum of the whole file to verify the upload.
+       *      The algorithm used to calculate this final checksum must match the algorithm from
+       *      Init.Response. The server may reject the request on a mismatch
+       *      (meaning the server does not support the given algorithm).
+       */
+      checksumAlgorithm: number;
+      /**
+       * Format: bytes
+       * @description Checksum of the whole file for validation. When provided, the server may verify the upload before
+       *      marking it final. This is optional behavior that depends on the particular storage driver
+       *      used on the backend side for this upload. See the storage driver's implementation for more details.
+       */
+      checksum: string;
     };
     Finalize_Response: Record<string, never>;
     GetPartURL_HTTPHeader: {
@@ -92,31 +134,36 @@ export interface components {
       value: string;
     };
     GetPartURL_Request: {
-      /** @description Id of upload resource */
+      /** @description ID of the upload resource */
       resourceId: string;
       /**
-       * @description Part to be uploaded. It is responsibility of the Client to watch after already uploaded parts:
-       *      - client can request an URL for the same part twice (request -> request) without errors;
-       *      - client can request an URL for alrady uploaded part (request -> upload -> request) without errors.
+       * Format: bytes
+       * @description Signature proving the caller is authorized to access this resource.
+       */
+      resourceSignature: string;
+      /**
+       * @description Part to be uploaded. It is the responsibility of the client to keep track of already uploaded parts:
+       *      - client can request a URL for the same part twice (request -> request) without errors;
+       *      - client can request a URL for an already uploaded part (request -> upload -> request) without errors.
        *
        *      Parts enumeration starts from 1.
        */
       partNumber: string;
       /**
-       * @description Size of the part uploaded by client earlier. Allows controller to count upload progress
-       *      based on client's input.
-       *      Client is free to never sent this value (send zeroes in each request).
+       * @description Size of the part uploaded by the client earlier. Allows the controller to count upload progress
+       *      based on the client's input.
+       *      The client is free to never send this value (send zeroes in each request).
        */
       uploadedPartSize: string;
       /**
-       * @description Do we need to presign URL for internal use.
-       *      Controllers could use this if they are trying to download something from internal network.
-       *      For backward compatibility, by default pl backend will presign external urls.
+       * @description Whether to presign the URL for internal use.
+       *      Controllers could use this if they are trying to upload something from the internal network.
+       *      For backward compatibility, by default the pl backend will presign external URLs.
        */
       isInternalUse: boolean;
       /**
-       * @description Checksum is not used for now, but it is here for case
-       *      where signing checksum header is required.
+       * @description Checksum is not used for now, but it is here for the case
+       *      where signing the checksum header is required.
        */
       partChecksum: string;
     };
@@ -126,21 +173,21 @@ export interface components {
       /** @description HTTP method to use for chunk upload, say 'PUT' or 'POST'. */
       method: string;
       /**
-       * @description List of headers with their values, MANDATORY to be sent by the client for the upload.
-       *      The destination service (the one, that will handle upload request for specific part)
-       *      may reject the request if it would not keep the given headers.
+       * @description List of headers with their values that MUST be sent by the client for the upload.
+       *      The destination service (the one that will handle the upload request for a specific part)
+       *      may reject the request if it does not include the given headers.
        */
       headers: components["schemas"]["GetPartURL_HTTPHeader"][];
       /**
        * @description The number of the _first_ byte in the chunk.
        *      Absolute position from the start of the file ( file.seek(<chunk_start>, SEEK_START) ).
-       *      The client is expected to send [<chunk_start>; <chunk_end>) range.
+       *      The client is expected to send the [<chunk_start>; <chunk_end>) range.
        */
       chunkStart: string;
       /**
        * @description The number of the byte _after_ the last to be sent in the chunk.
        *      Absolute position from the start of the file.
-       *      The client is expected to send [<chunk_start>; <chunk_end>) range.
+       *      The client is expected to send the [<chunk_start>; <chunk_end>) range.
        */
       chunkEnd: string;
     };
@@ -152,36 +199,53 @@ export interface components {
       [key: string]: unknown;
     };
     Init_Request: {
-      /** @description Id of upload resource */
+      /** @description ID of the upload resource */
       resourceId: string;
+      /**
+       * Format: bytes
+       * @description Signature proving the caller is authorized to access this resource.
+       */
+      resourceSignature: string;
     };
     Init_Response: {
       /**
        * @description Number of parts in this upload.
-       *      For parallel upload support, client can generate any number of part upload URLs
-       *      at the moment and upload them in parallel.
+       *      For parallel upload support, the client can generate any number of part upload URLs
+       *      at once and upload them in parallel.
        *      <parts_count> keeps the number of chunks supported by this upload.
        *      The parts count is calculated from the planned size of the upload, controller
-       *      configuration and underlying storage restrictions.
+       *      configuration, and underlying storage restrictions.
        */
       partsCount: string;
       partSize: string;
       /**
        * Format: enum
-       * @description Checksum algorithm to use for the part upload.
+       * @description Checksum algorithm to use for each part upload and final verification.
        */
       checksumAlgorithm: number;
-      /** @description Header name to use for the checksum. */
+      /**
+       * @description Header name to use for the checksum in each part upload request.
+       *      A non-empty value combined with checksum_algorithm enables each part upload verification.
+       */
       checksumHeader: string;
       /**
-       * @description List of IDs of parts that were already uploaded by client.
-       *      Helps client to recover upload and skip already done parts
+       * @description List of IDs of parts that were already uploaded by the client.
+       *      Helps the client recover the upload and skip already uploaded parts
        *      after being interrupted in the middle of the upload
-       *      (say, because of the restart).
+       *      (say, because of a restart).
        *      Parts enumeration starts from 1.
        */
       uploadedParts: string[];
     };
+    Reset_Request: {
+      resourceId: string;
+      /**
+       * Format: bytes
+       * @description Signature proving the caller is authorized to access this resource.
+       */
+      resourceSignature: string;
+    };
+    Reset_Response: Record<string, never>;
     /** @description The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors). */
     Status: {
       /**
@@ -195,18 +259,23 @@ export interface components {
       details: components["schemas"]["GoogleProtobufAny"][];
     };
     UpdateProgress_Request: {
-      /** @description Id of upload resource */
+      /** @description ID of the upload resource */
       resourceId: string;
       /**
-       * @description Amount of bytes, uploaded since the earlier call to UpdateProgress.
-       *      This value is just blindly added to the 'bytes_processed' of progress report,
+       * Format: bytes
+       * @description Signature proving the caller is authorized to access this resource.
+       */
+      resourceSignature: string;
+      /**
+       * @description Number of bytes uploaded since the earlier call to UpdateProgress.
+       *      This value is just blindly added to the 'bytes_processed' of the progress report,
        *      so other clients can see the upload progress.
-       *      If client uploads the data in several streams (several chunks in parallel), it
+       *      If the client uploads the data in several streams (several chunks in parallel), it
        *      can safely send progress updates individually for each of the streams, just counting
-       *      bytes uploaded by particular stream.
+       *      bytes uploaded by a particular stream.
        *
-       *      Negative value can be used to report about upload retry: when upload was interrupted,
-       *      part of the uploaded data is lost and require re-upload.
+       *      A negative value can be used to report an upload retry: when the upload was interrupted,
+       *      part of the uploaded data is lost and requires a re-upload.
        */
       bytesProcessed: string;
     };
@@ -319,6 +388,39 @@ export interface operations {
       };
     };
   };
+  Upload_Reset: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        "application/json": components["schemas"]["Reset_Request"];
+      };
+    };
+    responses: {
+      /** @description OK */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": components["schemas"]["Reset_Response"];
+        };
+      };
+      /** @description Default error response */
+      default: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": components["schemas"]["Status"];
+        };
+      };
+    };
+  };
   Upload_UpdateProgress: {
     parameters: {
       query?: never;