@qrvey/object-storage 2.0.4-1170 → 2.0.5-1175

package/dist/cjs/index.js

@@ -1,16 +1,17 @@
 'use strict';
 
-var stream = require('stream');
+var stream2 = require('stream');
 var storageBlob = require('@azure/storage-blob');
 var clientS3 = require('@aws-sdk/client-s3');
 var credentialProviderNode = require('@aws-sdk/credential-provider-node');
 var s3RequestPresigner = require('@aws-sdk/s3-request-presigner');
 var libStorage = require('@aws-sdk/lib-storage');
 var nodeHttpHandler = require('@smithy/node-http-handler');
+var basicFtp = require('basic-ftp');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var stream__default = /*#__PURE__*/_interopDefault(stream);
+var stream2__default = /*#__PURE__*/_interopDefault(stream2);
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -37,6 +38,13 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -148,9 +156,10 @@ var _BlobStorageService = class _BlobStorageService {
    * Retrieves the properties of a blob from the container by its name.
    *
    * @param {string} blobName - The name of the blob.
+   * @param {ObjectStorageOptions} options - The options for the object storage service.
    * @return {Promise<GetObjectResponse>} A promise that resolves to the blob properties.
    */
-  constructor(containerName) {
+  constructor(containerName, options) {
     __publicField(this, "blobServiceClient");
     __publicField(this, "containerName");
     this.containerName = containerName;
@@ -161,7 +170,7 @@ var _BlobStorageService = class _BlobStorageService {
     if (!connectionString) {
       connectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
     }
-    this.blobServiceClient = storageBlob.BlobServiceClient.fromConnectionString(connectionString);
+    this.blobServiceClient = storageBlob.BlobServiceClient.fromConnectionString((options == null ? void 0 : options.connectionString) || connectionString);
   }
   /**
    * Creates a writable stream for uploading a file to the Blob storage.
@@ -170,7 +179,7 @@ var _BlobStorageService = class _BlobStorageService {
    * @return {CreateUploadWriteStreamResponse} An object containing the key of the uploaded blob, the writable stream, and a promise that resolves when the upload is complete.
    */
   createUploadWriteStream(blobName) {
-    const streamPassThrough = new stream__default.default.PassThrough();
+    const streamPassThrough = new stream2__default.default.PassThrough();
     const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
     const blockBlobClient = containerClient.getBlockBlobClient(blobName);
     const uploadPromise = blockBlobClient.uploadStream(streamPassThrough, void 0, void 0, {
@@ -553,11 +562,10 @@ var _BlobStorageService = class _BlobStorageService {
    * Completes a multipart upload by committing the blocks to create the blob.
    *
    * @param {string} blobName - The name of the blob for which the multipart upload is being completed.
-   * @param {string} uploadId - The ID of the multipart upload to be completed.
    * @return {Promise<void>} A Promise that resolves when the multipart upload is successfully completed.
    * @throws {Error} If no block IDs are found in the metadata.
    */
-  async completeMultipartUpload(blobName, uploadId) {
+  async completeMultipartUpload(blobName) {
     var _a;
     const containerClient = this.blobServiceClient.getContainerClient(this.containerName);
     const blobClient = containerClient.getBlockBlobClient(blobName);
@@ -806,6 +814,23 @@ var _S3StorageService = class _S3StorageService {
    * @returns A promise that resolves to the response containing the key of the uploaded object.
    */
   async upload(key, body, metadata) {
+    if (body instanceof stream2__default.default.Readable) {
+      const upload = new libStorage.Upload({
+        client: this.s3Client,
+        params: {
+          Bucket: this.bucketName,
+          Key: key,
+          Body: body,
+          Metadata: metadata
+        },
+        queueSize: 5,
+        partSize: 8 * 1024 * 1024
+      });
+      await upload.done();
+      return {
+        key
+      };
+    }
     const command = new clientS3.PutObjectCommand({
       Bucket: this.bucketName,
       Key: key,
@@ -824,7 +849,7 @@ var _S3StorageService = class _S3StorageService {
    * @return {CreateUploadWriteStreamResponse} An object containing the key of the uploaded object, the writable stream, and a promise that resolves when the upload is complete.
    */
   createUploadWriteStream(key) {
-    const streamPassThrough = new stream__default.default.PassThrough();
+    const streamPassThrough = new stream2__default.default.PassThrough();
     const params = {
       Bucket: this.bucketName,
       Key: key,
@@ -981,11 +1006,348 @@ var _S3StorageService = class _S3StorageService {
 };
 __name(_S3StorageService, "S3StorageService");
 var S3StorageService = _S3StorageService;
+var SftpClient = __require("ssh2-sftp-client");
+var _SftpStorageService = class _SftpStorageService {
+  constructor(bucketName, options) {
+    __publicField(this, "client");
+    __publicField(this, "bucketName");
+    __publicField(this, "options");
+    this.bucketName = bucketName;
+    this.options = options || {};
+    this.client = new SftpClient();
+  }
+  async initializeClient() {
+    const host = this.options.host || process.env.SFTP_HOST;
+    const port = parseInt(String(this.options.port || process.env.SFTP_PORT));
+    const user = this.options.user || process.env.SFTP_USER;
+    const password = this.options.password || process.env.SFTP_PASSWORD;
+    const privateKey = this.options.privateKey || process.env.SFTP_PRIVATE_KEY;
+    if (!password && !privateKey) {
+      throw new Error("Either password or private key must be provided for SFTP connection");
+    }
+    await this.client.connect({
+      host,
+      port,
+      username: user,
+      password,
+      privateKey,
+      readyTimeout: 4e3,
+      retries: 1,
+      retry_factor: 2,
+      retry_minTimeout: 2e3
+    });
+  }
+  async withClient(fn) {
+    try {
+      await this.initializeClient();
+      return await fn();
+    } finally {
+      await this.client.end().catch(() => {
+      });
+    }
+  }
+  async list(options) {
+    return this.withClient(async () => {
+      const prefix = options.prefix || "";
+      const path = this.bucketName + (prefix ? "/" + prefix : "");
+      const list = await this.client.list(path);
+      const items = list.map((item) => ({
+        key: item.name,
+        lastModified: item.modifyTime ? new Date(item.modifyTime) : /* @__PURE__ */ new Date(),
+        size: item.size,
+        eTag: ""
+      }));
+      return {
+        items,
+        pagination: null,
+        count: items.length
+      };
+    });
+  }
+  async ensureDirectoriesExist(remotePath) {
+    var _a, _b;
+    const parts = remotePath.split("/");
+    parts.pop();
+    let current = "";
+    for (const part of parts) {
+      if (!part)
+        continue;
+      current += `/${part}`;
+      try {
+        await this.client.stat(current);
+      } catch (err) {
+        const isNoEntry = err.code === "ENOENT" || ((_a = err.message) == null ? void 0 : _a.includes("No such file")) || ((_b = err.message) == null ? void 0 : _b.includes("does not exist"));
+        if (isNoEntry) {
+          try {
+            await this.client.mkdir(current);
+          } catch (mkdirErr) {
+            throw new Error(`Failed to create directory ${current}: ${mkdirErr.message}`);
+          }
+        } else {
+          throw new Error(`Failed to check directory ${current}: ${err.message}`);
+        }
+      }
+    }
+  }
+  async upload(key, body) {
+    return this.withClient(async () => {
+      let remotePath = `${this.bucketName}/${key}`;
+      remotePath = remotePath + "";
+      await this.ensureDirectoriesExist(remotePath);
+      if (body instanceof stream2.Readable) {
+        await this.client.put(body, remotePath);
+      } else if (body instanceof Buffer) {
+        await this.client.put(Buffer.from(body), remotePath);
+      } else {
+        await this.client.put(Buffer.from(String(body)), remotePath);
+      }
+      return {
+        key
+      };
+    });
+  }
+  async delete(key) {
+    return this.withClient(async () => {
+      await this.client.delete(`${this.bucketName}/${key}`);
+      return true;
+    });
+  }
+  async getObject(key) {
+    await this.initializeClient();
+    const remotePath = `${this.bucketName}/${key}`;
+    const stats = await this.client.stat(remotePath);
+    const data = await this.client.get(remotePath);
+    let stream3;
+    if (Buffer.isBuffer(data) || typeof data === "string") {
+      stream3 = stream2.Readable.from(data);
+    } else if (data instanceof stream2.Readable) {
+      stream3 = data;
+    } else {
+      throw new Error("Unsupported stream type returned by SFTP client");
+    }
+    const cleanup = /* @__PURE__ */ __name(async () => {
+      try {
+        await this.client.end();
+      } catch (e) {
+      }
+    }, "cleanup");
+    stream3.on("end", cleanup);
+    stream3.on("error", cleanup);
+    return {
+      body: stream3,
+      contentLength: stats.size,
+      lastModified: stats.modifyTime ? new Date(stats.modifyTime) : /* @__PURE__ */ new Date(),
+      metadata: {}
+    };
+  }
+  listAll(options) {
+    throw new Error("Method not implemented.");
+  }
+  getHeadObject(key) {
+    throw new Error("Method not implemented.");
+  }
+  getDownloadUrl(key, expiresInMinutes) {
+    throw new Error("Method not implemented.");
+  }
+  getUploadUrl(key, expiresInMinutes) {
+    throw new Error("Method not implemented.");
+  }
+  createUploadWriteStream(key) {
+    throw new Error("Method not implemented.");
+  }
+  getHeadBucket() {
+    throw new Error("Method not implemented.");
+  }
+  generateUploadIdMultipart(key) {
+    throw new Error("Method not implemented.");
+  }
+  listMultipartUploadsForBucket() {
+    throw new Error("Method not implemented.");
+  }
+  listMultipartUploadsForKey(key, uploadId) {
+    throw new Error("Method not implemented.");
+  }
+  uploadMultipart(key, file, partNumber, uploadId) {
+    throw new Error("Method not implemented.");
+  }
+  completeMultipartUpload(key, uploadId) {
+    throw new Error("Method not implemented.");
+  }
+  abortMultipartUpload(key, uploadId) {
+    throw new Error("Method not implemented.");
+  }
+  getMultipartUploadPresignedUrl(key, uploadId, partNumber, expiresInMinutes) {
+    throw new Error("Method not implemented.");
+  }
+};
+__name(_SftpStorageService, "SftpStorageService");
+var SftpStorageService = _SftpStorageService;
+var _FtpStorageService = class _FtpStorageService {
+  constructor(bucketName, options) {
+    __publicField(this, "client");
+    __publicField(this, "bucketName");
+    __publicField(this, "options");
+    this.bucketName = bucketName;
+    this.options = options || {};
+    this.client = new basicFtp.Client();
+  }
+  listAll(options) {
+    throw new Error("Method not implemented.");
+  }
+  async initializeClient() {
+    var _a, _b, _c, _d, _e;
+    const host = ((_a = this == null ? void 0 : this.options) == null ? void 0 : _a.host) || process.env.FTP_HOST;
+    const port = parseInt(String(((_b = this == null ? void 0 : this.options) == null ? void 0 : _b.port) || process.env.FTP_PORT), 10);
+    const user = ((_c = this == null ? void 0 : this.options) == null ? void 0 : _c.user) || process.env.FTP_USER;
+    const password = ((_d = this == null ? void 0 : this.options) == null ? void 0 : _d.password) || process.env.FTP_PASSWORD;
+    await this.client.access({
+      host,
+      port,
+      user,
+      password,
+      secure: ((_e = this == null ? void 0 : this.options) == null ? void 0 : _e.secure) || false
+    });
+  }
+  async withClient(fn) {
+    try {
+      await this.initializeClient();
+      return await fn();
+    } finally {
+      this.client.close();
+    }
+  }
+  async list(options) {
+    return this.withClient(async () => {
+      const prefix = options.prefix || "";
+      const path = `${this.bucketName}/${prefix}`;
+      try {
+        const list = await this.client.list(path);
+        const items = list.map((item) => ({
+          key: prefix + item.name,
+          lastModified: item.modifiedAt || /* @__PURE__ */ new Date(),
+          size: item.size,
+          eTag: ""
+        }));
+        return {
+          items,
+          pagination: null,
+          count: items.length
+        };
+      } catch (e) {
+        return {
+          items: [],
+          pagination: null,
+          count: 0
+        };
+      }
+    });
+  }
+  async getObject(key) {
+    await this.initializeClient();
+    const passThrough = new stream2.PassThrough();
+    const path = `${this.bucketName}/${key}`;
+    const stats = await this.client.size(path);
+    this.client.downloadTo(passThrough, path).then(() => passThrough.end()).catch((err) => passThrough.emit("error", err));
+    const cleanup = /* @__PURE__ */ __name(() => {
+      this.client.close();
+    }, "cleanup");
+    passThrough.on("end", cleanup);
+    passThrough.on("error", cleanup);
+    return {
+      body: passThrough,
+      contentLength: stats,
+      lastModified: /* @__PURE__ */ new Date(),
+      metadata: {}
+    };
+  }
+  async upload(key, body) {
+    return this.withClient(async () => {
+      await this.client.cd("/");
+      try {
+        await this.client.cd(this.bucketName);
+      } catch (e) {
+        await this.client.send(`MKD ${this.bucketName}`);
+        await this.client.cd(this.bucketName);
+      }
+      const parts = key.split("/");
+      parts.pop();
+      for (const part of parts) {
+        if (!part)
+          continue;
+        try {
+          await this.client.cd(part);
+        } catch (e) {
+          await this.client.send(`MKD ${part}`);
+          await this.client.cd(part);
+        }
+      }
+      await this.client.cd("/");
+      const fullPath = `${this.bucketName}/${key}`;
+      const stream3 = body instanceof stream2.Readable ? body : stream2.Readable.from([
+        body
+      ]);
+      await this.client.uploadFrom(stream3, fullPath);
+      return {
+        key
+      };
+    });
+  }
+  async delete(key) {
+    return this.withClient(async () => {
+      await this.client.remove(`${this.bucketName}/${key}`);
+      return true;
+    });
+  }
+  async close() {
+    this.client.close();
+  }
+  // Unsupported Operations
+  async getDownloadUrl(_key, _expiresInMinutes) {
+    throw new Error("FTP does not support pre-signed URLs");
+  }
+  async getUploadUrl(_key, _expiresInMinutes) {
+    throw new Error("FTP does not support pre-signed URLs");
+  }
+  async getHeadObject(_key) {
+    throw new Error("Operation not supported");
+  }
+  createUploadWriteStream(_key) {
+    throw new Error("Operation not supported");
+  }
+  async getHeadBucket() {
+    throw new Error("Operation not supported");
+  }
+  async generateUploadIdMultipart(_key) {
+    throw new Error("Multipart upload is not supported");
+  }
+  async listMultipartUploadsForBucket() {
+    throw new Error("Multipart upload is not supported");
+  }
+  async listMultipartUploadsForKey(_key, _uploadId) {
+    throw new Error("Multipart upload is not supported");
+  }
+  async uploadMultipart(_key, _file, _partNumber, _uploadId) {
+    throw new Error("Multipart upload is not supported");
+  }
+  async completeMultipartUpload(_key, _uploadId) {
+    throw new Error("Multipart upload is not supported");
+  }
+  async abortMultipartUpload(_key, _uploadId) {
+    throw new Error("Method not implemented.");
+  }
+  async getMultipartUploadPresignedUrl(_key, _uploadId, _partNumber, _expiresInMinutes) {
+    throw new Error("Multipart upload is not supported");
+  }
+};
+__name(_FtpStorageService, "FtpStorageService");
+var FtpStorageService = _FtpStorageService;
 
 // src/shared/utils/constants.ts
 var OBJECT_STORAGE_SERVICE_TYPES = {
   AWS_S3: "aws_s3",
-  AZURE_BLOB_STORAGE: "azure_blob_storage"
+  AZURE_BLOB_STORAGE: "azure_blob_storage",
+  FTP: "ftp",
+  SFTP: "sftp"
 };
 
 // src/services/objectStorageFactory.service.ts
@@ -997,7 +1359,11 @@ var _ObjectStorageFactory = class _ObjectStorageFactory {
       case OBJECT_STORAGE_SERVICE_TYPES.AWS_S3:
         return new S3StorageService(bucketName, options);
       case OBJECT_STORAGE_SERVICE_TYPES.AZURE_BLOB_STORAGE:
-        return new BlobStorageService(bucketName);
+        return new BlobStorageService(bucketName, options);
+      case OBJECT_STORAGE_SERVICE_TYPES.FTP:
+        return new FtpStorageService(bucketName, options);
+      case OBJECT_STORAGE_SERVICE_TYPES.SFTP:
+        return new SftpStorageService(bucketName, options);
       default:
         throw new Error(`Unsupported object storage provider: ${provider}`);
     }
@@ -1023,38 +1389,44 @@ var _ObjectStorageService = class _ObjectStorageService {
    *
    * @param {ListRequestOptions} options - The options to apply to the list operation.
    * @param {string} [bucketName] - The name of the bucket to list objects from. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<ListResponse>} A promise that resolves to the list of objects.
    */
-  static async list(options, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.list(options));
+  static async list(options, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.list(options));
   }
   /**
    * Retrieves a list of all objects from the object storage service.
    *
    * @param {ListRequestOptions} options - The options to apply to the list operation.
    * @param {string} [bucketName] - The name of the bucket to list objects from. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<ListResponse>} A promise that resolves to the list of all objects.
    */
-  static async listAll(options, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.listAll(options));
+  static async listAll(options, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.listAll(options));
   }
   /**
    * Retrieves an object from the object storage service.
    *
    * @param {string} key - The key of the object to retrieve.
    * @param {string} [bucketName] - The name of the bucket where the object is stored. If not provided, the default bucket name will be used.
+   * @param {IGetObjectOptions} [options] - The options to apply to the get operation.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<GetObjectResponse>} A promise that resolves to the retrieved object.
    */
-  static async getObject(key, bucketName, options) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.getObject(key, options));
+  static async getObject(key, bucketName, options, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.getObject(key, options));
   }
   /**
    * Retrieves an object info (without file content) from the object storage service.
    * @param key - The key of the object to retrieve.
+   * @param bucketName - The name of the bucket where the object is stored. If not provided, the default bucket name will be used.
+   * @param objectStorageOptions - The options for the object storage service.
    * @returns A promise that resolves to the info of the file.
    */
-  static async getHeadObject(key, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.getHeadObject(key));
+  static async getHeadObject(key, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.getHeadObject(key));
   }
   /**
    * Retrieves a signed URL for the specified object in the object storage service.
@@ -1062,10 +1434,11 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {string} key - The key of the object for which to generate the signed URL.
    * @param {number} expiresInMinutes - The number of minutes until the signed URL expires.
    * @param {string} [bucketName] - The name of the bucket where the object is stored. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<string>} A promise that resolves to the generated signed URL.
    */
-  static async getDownloadUrl(key, expiresInMinutes, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.getDownloadUrl(key, expiresInMinutes));
+  static async getDownloadUrl(key, expiresInMinutes, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.getDownloadUrl(key, expiresInMinutes));
   }
   /**
    * Retrieves an upload URL for the specified object in the object storage service.
@@ -1073,10 +1446,11 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {string} key - The key of the object for which to generate the upload URL.
    * @param {number} expiresInMinutes - The number of minutes until the upload URL expires.
    * @param {string} [bucketName] - The name of the bucket where the object will be stored. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<string>} A promise that resolves to the generated upload URL.
    */
-  static async getUploadUrl(key, expiresInMinutes, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.getUploadUrl(key, expiresInMinutes));
+  static async getUploadUrl(key, expiresInMinutes, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.getUploadUrl(key, expiresInMinutes));
   }
   /**
    * Uploads a file to the object storage service.
@@ -1085,30 +1459,33 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {FileContent} body - The content of the file to upload.
    * @param {Object} [metadata] - Optional metadata to associate with the object.
    * @param {string} [bucketName] - The name of the bucket where the object will be stored. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<UploadResponse>} A promise that resolves to the response of the upload operation.
    */
-  static async upload(key, body, metadata, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.upload(key, body, metadata));
+  static async upload(key, body, metadata, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.upload(key, body, metadata));
   }
   /**
    * Creates an upload write stream for the specified key in the object storage service.
    *
    * @param {string} key - The key of the object to create the upload write stream for.
    * @param {string} [bucketName] - The name of the bucket where the object will be stored. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<CreateUploadWriteStreamResponse>} A promise that resolves to the response of the upload operation.
    */
-  static async createUploadWriteStream(key, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.createUploadWriteStream(key));
+  static async createUploadWriteStream(key, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.createUploadWriteStream(key));
   }
   /**
    * Deletes an object or multiple objects from the object storage service.
    *
    * @param {string | string[]} key - The key or array of keys of the objects to delete.
    * @param {string} [bucketName] - The name of the bucket where the objects are stored. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<{ key: string; deleted: boolean; error?: string }[] | boolean>} A promise that resolves to an array of objects containing the key, deleted status, and an optional error message for each object deleted, or a boolean value indicating the success of the deletion.
    */
-  static async delete(key, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then(async (instance) => {
+  static async delete(key, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then(async (instance) => {
       if (Array.isArray(key)) {
         const deleteBlobPromises = key.map(async (blobName) => {
           var _a;
@@ -1136,20 +1513,22 @@ var _ObjectStorageService = class _ObjectStorageService {
    * Retrieves the head bucket from the object storage service.
    *
    * @param {string} [bucketName] - The name of the bucket. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<HeadBucketResponse>} A promise that resolves to the head bucket response.
    */
-  static async getHeadBucket(bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.getHeadBucket());
+  static async getHeadBucket(bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.getHeadBucket());
   }
   /**
    * Generates a unique upload ID for a multipart upload.
    *
    * @param {string} key - The key of the object to upload.
    * @param {string} [bucketName] - The name of the bucket. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<string>} A promise that resolves to the generated upload ID.
    */
-  static async generateUploadIdMultipart(key, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.generateUploadIdMultipart(key));
+  static async generateUploadIdMultipart(key, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.generateUploadIdMultipart(key));
   }
   /**
    * Retrieves a list of multipart uploads for a specified key in the object storage service.
@@ -1157,19 +1536,21 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {string} key - The key of the object to retrieve uploads for.
    * @param {string} [bucketName] - The name of the bucket. If not provided, the default bucket name will be used.
    * @param {string} [uploadId] - The upload ID to filter the results by.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<ListPartsMultipartUploadResponse>} A promise that resolves to the list of multipart uploads for the specified key.
    */
-  static async listMultipartUploadsForKey(key, bucketName, uploadId) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.listMultipartUploadsForKey(key, uploadId));
+  static async listMultipartUploadsForKey(key, bucketName, uploadId, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.listMultipartUploadsForKey(key, uploadId));
   }
   /**
    * Retrieves a list of all multipart uploads for a specified bucket in the object storage service.
    *
    * @param {string} [bucketName] - The name of the bucket. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<ListMultipartUploadsResponse>} A promise that resolves to the list of multipart uploads for the specified bucket.
    */
-  static async listMultipartUploadsForBucket(bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.listMultipartUploadsForBucket());
+  static async listMultipartUploadsForBucket(bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.listMultipartUploadsForBucket());
   }
   /**
    * Uploads a multipart file to the specified bucket in the object storage service.
@@ -1179,10 +1560,11 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {number} partNumber - The number of the part being uploaded.
    * @param {string} [uploadId] - The ID of the multipart upload.
    * @param {string} [bucketName] - The name of the bucket to upload the file to. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<string>} A Promise that resolves to the base64 encoded block ID of the uploaded part.
    */
-  static async uploadMultipart(key, file, partNumber, uploadId, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.uploadMultipart(key, file, partNumber, uploadId));
+  static async uploadMultipart(key, file, partNumber, uploadId, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.uploadMultipart(key, file, partNumber, uploadId));
   }
   /**
    * Completes a multipart upload for the specified object in the object storage service.
@@ -1190,10 +1572,11 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {string} key - The key of the object to complete the multipart upload for.
    * @param {string} uploadId - The ID of the multipart upload to complete.
    * @param {string} [bucketName] - The name of the bucket to complete the multipart upload in. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<void>} A Promise that resolves when the multipart upload is completed.
    */
-  static async completeMultipartUpload(key, uploadId, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.completeMultipartUpload(key, uploadId));
+  static async completeMultipartUpload(key, uploadId, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.completeMultipartUpload(key, uploadId));
   }
   /**
    * Aborts a multipart upload for the specified object in the object storage service.
@@ -1201,10 +1584,11 @@ var _ObjectStorageService = class _ObjectStorageService {
    * @param {string} key - The key of the object to abort the multipart upload for.
    * @param {string} uploadId - The ID of the multipart upload to abort.
    * @param {string} [bucketName] - The name of the bucket to abort the multipart upload in. If not provided, the default bucket name will be used.
+   * @param {ObjectStorageOptions} [objectStorageOptions] - The options for the object storage service.
    * @return {Promise<void>} A Promise that resolves when the multipart upload is aborted.
    */
-  static async abortMultipartUpload(key, uploadId, bucketName) {
-    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName).then((instance) => instance.abortMultipartUpload(key, uploadId));
+  static async abortMultipartUpload(key, uploadId, bucketName, objectStorageOptions) {
+    return _ObjectStorageService.getObjectStorageServiceInstance(bucketName, objectStorageOptions).then((instance) => instance.abortMultipartUpload(key, uploadId));
   }
   /**
    * Retrieves a presigned URL for a specific part of a multipart upload.