@bytescale/sdk 3.23.1 → 3.25.0

package/dist/browser/cjs/main.js

@@ -912,6 +912,9 @@ var FileApi = /*#__PURE__*/function (_runtime$BaseAPI) {
         if (params.cache !== undefined) {
           query["cache"] = params.cache;
         }
+        if (params.cacheOnly !== undefined) {
+          query["cache_only"] = params.cacheOnly;
+        }
         if (params.cachePerm !== undefined) {
           query["cache_perm"] = params.cachePerm;
         }
@@ -1078,7 +1081,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes a folder asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes a folder asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolder",
@@ -1104,7 +1107,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes multiple folders asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes multiple folders asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolderBatch",
@@ -1649,29 +1652,47 @@ var UrlBuilder = /*#__PURE__*/function () {
   }, {
     key: "getBaseUrl",
     value: function getBaseUrl(params, prefix) {
-      var cdnUrl = BytescaleApiClientConfigUtils.defaultCdnUrl;
+      var _a, _b;
+      var cdnUrl = (_b = (_a = params.options) === null || _a === void 0 ? void 0 : _a.cdnUrl) !== null && _b !== void 0 ? _b : BytescaleApiClientConfigUtils.defaultCdnUrl;
       return "".concat(cdnUrl, "/").concat(params.accountId, "/").concat(prefix).concat(params.filePath);
     }
   }, {
     key: "getCommonTransformationQueryParams",
     value: function getCommonTransformationQueryParams(trans) {
-      return this.makeQueryParams(["cachePermanently", "artifact"], {
+      return this.makeQueryParams({
+        cacheOnly: null,
+        cachePermanently: null,
+        // Keep this as the last param: this is the convention for transformation URLs (although not required).
+        artifact: null
+      }, {
+        cacheOnly: "cache_only",
         cachePermanently: "cache_perm"
       })(trans);
     }
   }, {
     key: "getCommonQueryParams",
     value: function getCommonQueryParams(params) {
-      return this.makeQueryParams(["cache", "cacheTtl", "version", "forceDownloadPrompt"], {
+      return this.makeQueryParams({
+        cache: null,
+        cacheTtl: null,
+        version: null,
+        forceDownloadPrompt: null
+      }, {
         cacheTtl: "cache_ttl",
         forceDownloadPrompt: "download"
       })(params);
     }
+    /**
+     * Masks the querystring params per the 'keys' array.
+     *
+     * Order sensitive: querystring params will appear per the order of the 'keys' array.
+     */
   }, {
     key: "makeQueryParams",
-    value: function makeQueryParams(keys, keyOverrides) {
+    value: function makeQueryParams(keyPrototype, keyOverrides) {
       return function (data) {
         var result = [];
+        var keys = Object.keys(keyPrototype);
         keys.forEach(function (key) {
           var _a;
           var value = data[key];

package/dist/browser/esm/main.mjs

@@ -897,6 +897,9 @@ var FileApi = /*#__PURE__*/function (_runtime$BaseAPI) {
         if (params.cache !== undefined) {
           query["cache"] = params.cache;
         }
+        if (params.cacheOnly !== undefined) {
+          query["cache_only"] = params.cacheOnly;
+        }
         if (params.cachePerm !== undefined) {
           query["cache_perm"] = params.cachePerm;
         }
@@ -1063,7 +1066,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes a folder asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes a folder asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolder",
@@ -1089,7 +1092,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes multiple folders asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes multiple folders asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolderBatch",
@@ -1634,29 +1637,47 @@ var UrlBuilder = /*#__PURE__*/function () {
   }, {
     key: "getBaseUrl",
     value: function getBaseUrl(params, prefix) {
-      var cdnUrl = BytescaleApiClientConfigUtils.defaultCdnUrl;
+      var _a, _b;
+      var cdnUrl = (_b = (_a = params.options) === null || _a === void 0 ? void 0 : _a.cdnUrl) !== null && _b !== void 0 ? _b : BytescaleApiClientConfigUtils.defaultCdnUrl;
       return "".concat(cdnUrl, "/").concat(params.accountId, "/").concat(prefix).concat(params.filePath);
     }
   }, {
     key: "getCommonTransformationQueryParams",
     value: function getCommonTransformationQueryParams(trans) {
-      return this.makeQueryParams(["cachePermanently", "artifact"], {
+      return this.makeQueryParams({
+        cacheOnly: null,
+        cachePermanently: null,
+        // Keep this as the last param: this is the convention for transformation URLs (although not required).
+        artifact: null
+      }, {
+        cacheOnly: "cache_only",
         cachePermanently: "cache_perm"
       })(trans);
     }
   }, {
     key: "getCommonQueryParams",
     value: function getCommonQueryParams(params) {
-      return this.makeQueryParams(["cache", "cacheTtl", "version", "forceDownloadPrompt"], {
+      return this.makeQueryParams({
+        cache: null,
+        cacheTtl: null,
+        version: null,
+        forceDownloadPrompt: null
+      }, {
         cacheTtl: "cache_ttl",
         forceDownloadPrompt: "download"
       })(params);
     }
+    /**
+     * Masks the querystring params per the 'keys' array.
+     *
+     * Order sensitive: querystring params will appear per the order of the 'keys' array.
+     */
   }, {
     key: "makeQueryParams",
-    value: function makeQueryParams(keys, keyOverrides) {
+    value: function makeQueryParams(keyPrototype, keyOverrides) {
       return function (data) {
         var result = [];
+        var keys = Object.keys(keyPrototype);
         keys.forEach(function (key) {
           var _a;
           var value = data[key];

package/dist/node/cjs/main.js

@@ -912,6 +912,9 @@ var FileApi = /*#__PURE__*/function (_runtime$BaseAPI) {
         if (params.cache !== undefined) {
           query["cache"] = params.cache;
         }
+        if (params.cacheOnly !== undefined) {
+          query["cache_only"] = params.cacheOnly;
+        }
         if (params.cachePerm !== undefined) {
           query["cache_perm"] = params.cachePerm;
         }
@@ -1078,7 +1081,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes a folder asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes a folder asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolder",
@@ -1104,7 +1107,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes multiple folders asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes multiple folders asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolderBatch",
@@ -1649,29 +1652,47 @@ var UrlBuilder = /*#__PURE__*/function () {
   }, {
     key: "getBaseUrl",
     value: function getBaseUrl(params, prefix) {
-      var cdnUrl = BytescaleApiClientConfigUtils.defaultCdnUrl;
+      var _a, _b;
+      var cdnUrl = (_b = (_a = params.options) === null || _a === void 0 ? void 0 : _a.cdnUrl) !== null && _b !== void 0 ? _b : BytescaleApiClientConfigUtils.defaultCdnUrl;
       return "".concat(cdnUrl, "/").concat(params.accountId, "/").concat(prefix).concat(params.filePath);
     }
   }, {
     key: "getCommonTransformationQueryParams",
     value: function getCommonTransformationQueryParams(trans) {
-      return this.makeQueryParams(["cachePermanently", "artifact"], {
+      return this.makeQueryParams({
+        cacheOnly: null,
+        cachePermanently: null,
+        // Keep this as the last param: this is the convention for transformation URLs (although not required).
+        artifact: null
+      }, {
+        cacheOnly: "cache_only",
         cachePermanently: "cache_perm"
       })(trans);
     }
   }, {
     key: "getCommonQueryParams",
     value: function getCommonQueryParams(params) {
-      return this.makeQueryParams(["cache", "cacheTtl", "version", "forceDownloadPrompt"], {
+      return this.makeQueryParams({
+        cache: null,
+        cacheTtl: null,
+        version: null,
+        forceDownloadPrompt: null
+      }, {
         cacheTtl: "cache_ttl",
         forceDownloadPrompt: "download"
       })(params);
     }
+    /**
+     * Masks the querystring params per the 'keys' array.
+     *
+     * Order sensitive: querystring params will appear per the order of the 'keys' array.
+     */
   }, {
     key: "makeQueryParams",
-    value: function makeQueryParams(keys, keyOverrides) {
+    value: function makeQueryParams(keyPrototype, keyOverrides) {
       return function (data) {
         var result = [];
+        var keys = Object.keys(keyPrototype);
         keys.forEach(function (key) {
           var _a;
           var value = data[key];

package/dist/node/esm/main.mjs

@@ -899,6 +899,9 @@ var FileApi = /*#__PURE__*/function (_runtime$BaseAPI) {
         if (params.cache !== undefined) {
           query["cache"] = params.cache;
         }
+        if (params.cacheOnly !== undefined) {
+          query["cache_only"] = params.cacheOnly;
+        }
         if (params.cachePerm !== undefined) {
           query["cache_perm"] = params.cachePerm;
         }
@@ -1065,7 +1068,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes a folder asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes a folder asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolder",
@@ -1091,7 +1094,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes multiple folders asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes multiple folders asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolderBatch",
@@ -1636,29 +1639,47 @@ var UrlBuilder = /*#__PURE__*/function () {
   }, {
     key: "getBaseUrl",
     value: function getBaseUrl(params, prefix) {
-      var cdnUrl = BytescaleApiClientConfigUtils.defaultCdnUrl;
+      var _a, _b;
+      var cdnUrl = (_b = (_a = params.options) === null || _a === void 0 ? void 0 : _a.cdnUrl) !== null && _b !== void 0 ? _b : BytescaleApiClientConfigUtils.defaultCdnUrl;
       return "".concat(cdnUrl, "/").concat(params.accountId, "/").concat(prefix).concat(params.filePath);
     }
   }, {
     key: "getCommonTransformationQueryParams",
     value: function getCommonTransformationQueryParams(trans) {
-      return this.makeQueryParams(["cachePermanently", "artifact"], {
+      return this.makeQueryParams({
+        cacheOnly: null,
+        cachePermanently: null,
+        // Keep this as the last param: this is the convention for transformation URLs (although not required).
+        artifact: null
+      }, {
+        cacheOnly: "cache_only",
         cachePermanently: "cache_perm"
       })(trans);
     }
   }, {
     key: "getCommonQueryParams",
     value: function getCommonQueryParams(params) {
-      return this.makeQueryParams(["cache", "cacheTtl", "version", "forceDownloadPrompt"], {
+      return this.makeQueryParams({
+        cache: null,
+        cacheTtl: null,
+        version: null,
+        forceDownloadPrompt: null
+      }, {
         cacheTtl: "cache_ttl",
         forceDownloadPrompt: "download"
       })(params);
     }
+    /**
+     * Masks the querystring params per the 'keys' array.
+     *
+     * Order sensitive: querystring params will appear per the order of the 'keys' array.
+     */
   }, {
     key: "makeQueryParams",
-    value: function makeQueryParams(keys, keyOverrides) {
+    value: function makeQueryParams(keyPrototype, keyOverrides) {
       return function (data) {
         var result = [];
+        var keys = Object.keys(keyPrototype);
         keys.forEach(function (key) {
           var _a;
           var value = data[key];

package/dist/types/public/shared/UrlBuilder.d.ts

@@ -25,6 +25,11 @@ export declare class UrlBuilder {
     private static getBaseUrl;
     private static getCommonTransformationQueryParams;
     private static getCommonQueryParams;
+    /**
+     * Masks the querystring params per the 'keys' array.
+     *
+     * Order sensitive: querystring params will appear per the order of the 'keys' array.
+     */
     private static makeQueryParams;
     private static getTransformationParams;
     private static addQueryParams;

package/dist/types/public/shared/UrlBuilderTypes.d.ts

@@ -23,11 +23,13 @@ export interface UrlBuilderParams {
 export declare type UrlBuilderOptions = UrlBuilderOptionsRaw | UrlBuilderTransformationOptions;
 export declare type UrlBuilderTransformationOptions = UrlBuilderTransformationApiOptions | UrlBuilderOptionsPreset;
 export declare type UrlBuilderTransformationApiOptions = UrlBuilderOptionsImage | UrlBuilderOptionsVideo | UrlBuilderOptionsAudio | UrlBuilderOptionsArchive;
-export interface UrlBuilderOptionsBase {
+export interface UrlBuilderOptionsBase extends NonDeprecatedCommonQueryParams, DeprecatedCommonQueryParams {
     /**
-     * @deprecated This field has no effect: the 'auth' querystring parameter is no-longer required by the Bytescale CDN. You may remove this field from your code.
+     * The base URL of the Bytescale CDN. (Excludes trailing "/".)
      */
-    auth?: boolean;
+    cdnUrl?: string;
+}
+export interface NonDeprecatedCommonQueryParams {
     /**
      * Specifies whether to use caching for this request, or to always re-request the file.
      *
@@ -59,6 +61,12 @@ export interface UrlBuilderOptionsBase {
      */
     version?: string;
 }
+export interface DeprecatedCommonQueryParams {
+    /**
+     * @deprecated This field has no effect: the 'auth' querystring parameter is no-longer required by the Bytescale CDN. You may remove this field from your code.
+     */
+    auth?: boolean;
+}
 export interface UrlBuilderOptionsRaw extends UrlBuilderOptionsBase {
     transformation?: undefined;
 }
@@ -123,7 +131,8 @@ export interface UrlBuilderOptionsTransformationApi<T> extends UrlBuilderOptions
      */
     transformationParams?: T | T[];
 }
-export interface UrlBuilderOptionsTransformation extends UrlBuilderOptionsBase {
+export declare type UrlBuilderOptionsTransformation = UrlBuilderOptionsTransformationOnly & UrlBuilderOptionsBase;
+export interface UrlBuilderOptionsTransformationOnly {
     /**
      * The transformation artifact to download.
      *
@@ -134,6 +143,16 @@ export interface UrlBuilderOptionsTransformation extends UrlBuilderOptionsBase {
      * Default: "/"
      */
     artifact?: string;
+    /**
+     * Only serve transformations from the cache; do not perform new transformations on cache miss.
+     *
+     * If true, then if the transformation result does not exist in the cache, a 404 will be returned. No transformations will be performed.
+     *
+     * If false, then if the transformation result does not exist in the cache, a new transformation will be performed to produce the result.
+     *
+     * Default: false
+     */
+    cacheOnly?: boolean;
     /**
      * Specifies whether to permanently cache the transformed result in the Bytescale CDN.
      *

package/dist/types/public/shared/generated/apis/FileApi.d.ts

@@ -78,6 +78,16 @@ export interface ProcessFileParams {
      * Default: true
      */
     cache?: boolean;
+    /**
+     * Only serve transformations from the cache; do not perform new transformations on cache miss.
+     *
+     * If `true`, then if the transformation result does not exist in the cache, a 404 will be returned. No transformations will be performed.
+     *
+     * If `false`, then if the transformation result does not exist in the cache, a new transformation will be performed to produce the result.
+     *
+     * Default: `false`
+     */
+    cacheOnly?: boolean;
     /**
      * Specifies whether to cache the transformed result in the Bytescale CDN perma-cache.
      *

package/dist/types/public/shared/generated/apis/FolderApi.d.ts

@@ -57,11 +57,11 @@ export declare class FolderApi extends runtime.BaseAPI {
      */
     copyFolderBatch(params: CopyFolderBatchOperationParams): Promise<AsyncResponse>;
     /**
-     * Deletes a folder asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes a folder asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
     deleteFolder(params: DeleteFolderOperationParams): Promise<AsyncResponse>;
     /**
-     * Deletes multiple folders asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes multiple folders asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
     deleteFolderBatch(params: DeleteFolderBatchOperationParams): Promise<AsyncResponse>;
     /**

package/dist/types/public/shared/generated/models/index.d.ts

@@ -266,15 +266,10 @@ export interface CopyFolderRequest {
      */
     copyFiles?: boolean;
     /**
-     * If `true` then copies files from folders that have overridden storage settings, else skips them.
      *
-     * If the `source` folder overrides its storage settings, then its files will only be copied if this flag is `true`.
+     * If `false` then if a file's parent folder has overridden storage settings, the file won't be copied.
      *
-     * If the `source` folder inherits its storage settings, then its files will be copied regardless of this flag.
-     *
-     * In all cases, files will only be copied if `copyFiles` is also set to `true`.
-     *
-     * You can ignore this setting if your account does not use folders with overridden storage settings, such as custom AWS S3 buckets.
+     * If you don't use folders with custom storage settings (like AWS S3 buckets), you don't need to worry about this setting.
      *
      * Conditional: `copyVirtualFolders` and `copyOverriddenStorage` cannot both be `true`.
      *
@@ -409,9 +404,9 @@ export interface DeleteFolderBatchRequest {
 /**
  * Request body for DeleteFolder.
  *
- * If the folder has overridden storage settings, then no files will be deleted.
- *
  * You can use ListFolder to preview the operation using the `dryRun` parameter.
+ *
+ * *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won't be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.
  * @export
  * @interface DeleteFolderRequest
  */

package/dist/worker/cjs/main.js

@@ -912,6 +912,9 @@ var FileApi = /*#__PURE__*/function (_runtime$BaseAPI) {
         if (params.cache !== undefined) {
           query["cache"] = params.cache;
         }
+        if (params.cacheOnly !== undefined) {
+          query["cache_only"] = params.cacheOnly;
+        }
         if (params.cachePerm !== undefined) {
           query["cache_perm"] = params.cachePerm;
         }
@@ -1078,7 +1081,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes a folder asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes a folder asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolder",
@@ -1104,7 +1107,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes multiple folders asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes multiple folders asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolderBatch",
@@ -1649,29 +1652,47 @@ var UrlBuilder = /*#__PURE__*/function () {
   }, {
     key: "getBaseUrl",
     value: function getBaseUrl(params, prefix) {
-      var cdnUrl = BytescaleApiClientConfigUtils.defaultCdnUrl;
+      var _a, _b;
+      var cdnUrl = (_b = (_a = params.options) === null || _a === void 0 ? void 0 : _a.cdnUrl) !== null && _b !== void 0 ? _b : BytescaleApiClientConfigUtils.defaultCdnUrl;
       return "".concat(cdnUrl, "/").concat(params.accountId, "/").concat(prefix).concat(params.filePath);
     }
   }, {
     key: "getCommonTransformationQueryParams",
     value: function getCommonTransformationQueryParams(trans) {
-      return this.makeQueryParams(["cachePermanently", "artifact"], {
+      return this.makeQueryParams({
+        cacheOnly: null,
+        cachePermanently: null,
+        // Keep this as the last param: this is the convention for transformation URLs (although not required).
+        artifact: null
+      }, {
+        cacheOnly: "cache_only",
         cachePermanently: "cache_perm"
       })(trans);
     }
   }, {
     key: "getCommonQueryParams",
     value: function getCommonQueryParams(params) {
-      return this.makeQueryParams(["cache", "cacheTtl", "version", "forceDownloadPrompt"], {
+      return this.makeQueryParams({
+        cache: null,
+        cacheTtl: null,
+        version: null,
+        forceDownloadPrompt: null
+      }, {
         cacheTtl: "cache_ttl",
         forceDownloadPrompt: "download"
       })(params);
     }
+    /**
+     * Masks the querystring params per the 'keys' array.
+     *
+     * Order sensitive: querystring params will appear per the order of the 'keys' array.
+     */
   }, {
     key: "makeQueryParams",
-    value: function makeQueryParams(keys, keyOverrides) {
+    value: function makeQueryParams(keyPrototype, keyOverrides) {
       return function (data) {
         var result = [];
+        var keys = Object.keys(keyPrototype);
         keys.forEach(function (key) {
           var _a;
           var value = data[key];

package/dist/worker/esm/main.mjs

@@ -897,6 +897,9 @@ var FileApi = /*#__PURE__*/function (_runtime$BaseAPI) {
         if (params.cache !== undefined) {
           query["cache"] = params.cache;
         }
+        if (params.cacheOnly !== undefined) {
+          query["cache_only"] = params.cacheOnly;
+        }
         if (params.cachePerm !== undefined) {
           query["cache_perm"] = params.cachePerm;
         }
@@ -1063,7 +1066,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes a folder asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes a folder asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolder",
@@ -1089,7 +1092,7 @@ var FolderApi = /*#__PURE__*/function (_runtime$BaseAPI) {
       }
     }
     /**
-     * Deletes multiple folders asynchronously.  If the folder has overridden storage settings, then no files will be deleted.  You can use ListFolder to preview the operation using the `dryRun` parameter.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
+     * Deletes multiple folders asynchronously.  You can use ListFolder to preview the operation using the `dryRun` parameter.  *When deleting a folder with external storage:* if the folder at `folderPath` has overridden storage settings (like an AWS S3 bucket), no files will be deleted, regardless of the parameters you pass. Only the mapping will be removed. If the folder at `folderPath` has inherited storage settings but includes subfolders with overridden storage settings, files in those subfolders won\'t be deleted, regardless of the parameters you pass. In summary, files in folders with overridden storage are never deleted, unless you directly delete a subfolder of such a folder.  Requires a `secret_*` API key. Alternatively, you can use a `public_*` API key and JWT-based auth.
      */
   }, {
     key: "deleteFolderBatch",
@@ -1634,29 +1637,47 @@ var UrlBuilder = /*#__PURE__*/function () {
   }, {
     key: "getBaseUrl",
     value: function getBaseUrl(params, prefix) {
-      var cdnUrl = BytescaleApiClientConfigUtils.defaultCdnUrl;
+      var _a, _b;
+      var cdnUrl = (_b = (_a = params.options) === null || _a === void 0 ? void 0 : _a.cdnUrl) !== null && _b !== void 0 ? _b : BytescaleApiClientConfigUtils.defaultCdnUrl;
       return "".concat(cdnUrl, "/").concat(params.accountId, "/").concat(prefix).concat(params.filePath);
     }
   }, {
     key: "getCommonTransformationQueryParams",
     value: function getCommonTransformationQueryParams(trans) {
-      return this.makeQueryParams(["cachePermanently", "artifact"], {
+      return this.makeQueryParams({
+        cacheOnly: null,
+        cachePermanently: null,
+        // Keep this as the last param: this is the convention for transformation URLs (although not required).
+        artifact: null
+      }, {
+        cacheOnly: "cache_only",
         cachePermanently: "cache_perm"
       })(trans);
     }
   }, {
     key: "getCommonQueryParams",
     value: function getCommonQueryParams(params) {
-      return this.makeQueryParams(["cache", "cacheTtl", "version", "forceDownloadPrompt"], {
+      return this.makeQueryParams({
+        cache: null,
+        cacheTtl: null,
+        version: null,
+        forceDownloadPrompt: null
+      }, {
         cacheTtl: "cache_ttl",
         forceDownloadPrompt: "download"
       })(params);
     }
+    /**
+     * Masks the querystring params per the 'keys' array.
+     *
+     * Order sensitive: querystring params will appear per the order of the 'keys' array.
+     */
   }, {
     key: "makeQueryParams",
-    value: function makeQueryParams(keys, keyOverrides) {
+    value: function makeQueryParams(keyPrototype, keyOverrides) {
       return function (data) {
         var result = [];
+        var keys = Object.keys(keyPrototype);
         keys.forEach(function (key) {
           var _a;
           var value = data[key];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytescale/sdk",
-  "version": "3.23.1",
+  "version": "3.25.0",
   "description": "Bytescale JavaScript SDK",
   "author": "Bytescale <hello@bytescale.com> (https://www.bytescale.com)",
   "license": "MIT",

package/tests/utils/RandomStream.ts

@@ -15,10 +15,21 @@ import * as Path from "path";
 function createRandomStream(sizeInBytes: number): NodeJS.ReadableStream {
   const dictionary = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".split("");
 
+  // Ensure the chunk size is small enough to cause enough entropy (as we pick a new character for reach chunk).
+  const minRandomBlocks = 10;
+  const maxChunkSize = Math.min(64 * 1024, Math.ceil(sizeInBytes / minRandomBlocks));
+
   let producedSize = 0;
   let iteration = 0;
   return new Readable({
-    read(readSize) {
+    read(requestedReadSize) {
+      const maxRequestedReadSize = Math.min(requestedReadSize, maxChunkSize);
+
+      // This ensures streams of the same size are unique, else they would have the same contents, assuming chunk size is the same.
+      // We use 0.8-1 to prevent really small chunks, which may create inefficiencies.
+      const randomness = randomBetween(0.8, 1);
+
+      let readSize = Math.ceil(maxRequestedReadSize * randomness);
       let shouldEnd = false;
 
       if (producedSize + readSize >= sizeInBytes) {
@@ -48,6 +59,10 @@ function createRandomStream(sizeInBytes: number): NodeJS.ReadableStream {
   });
 }
 
+function randomBetween(min: number, max: number): number {
+  return Math.random() * (max - min) + min;
+}
+
 async function writeToDisk(reader: NodeJS.ReadableStream, path: string): Promise<void> {
   await new Promise((resolve, reject) => {
     const writer = fs.createWriteStream(path);