@hanzo/s3 0.6.3 → 8.0.7

package/dist/main/internal/client.js

@@ -0,0 +1,3014 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var crypto = _interopRequireWildcard(require("crypto"), true);
+var fs = _interopRequireWildcard(require("fs"), true);
+var http = _interopRequireWildcard(require("http"), true);
+var https = _interopRequireWildcard(require("https"), true);
+var path = _interopRequireWildcard(require("path"), true);
+var stream = _interopRequireWildcard(require("stream"), true);
+var async = _interopRequireWildcard(require("async"), true);
+var _blockStream = require("block-stream2");
+var _browserOrNode = require("browser-or-node");
+var _lodash = require("lodash");
+var qs = _interopRequireWildcard(require("query-string"), true);
+var _xml2js = require("xml2js");
+var _CredentialProvider = require("../CredentialProvider.js");
+var errors = _interopRequireWildcard(require("../errors.js"), true);
+var _helpers = require("../helpers.js");
+var _notification = require("../notification.js");
+var _signing = require("../signing.js");
+var _async2 = require("./async.js");
+var _copyConditions = require("./copy-conditions.js");
+var _extensions = require("./extensions.js");
+var _helper = require("./helper.js");
+var _joinHostPort = require("./join-host-port.js");
+var _postPolicy = require("./post-policy.js");
+var _request = require("./request.js");
+var _response = require("./response.js");
+var _s3Endpoints = require("./s3-endpoints.js");
+var xmlParsers = _interopRequireWildcard(require("./xml-parser.js"), true);
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const xml = new _xml2js.Builder({
+  renderOpts: {
+    pretty: false
+  },
+  headless: true
+});
+
+// will be replaced by bundler.
+const Package = {
+  version: "8.0.7" || 'development'
+};
+const requestOptionProperties = ['agent', 'ca', 'cert', 'ciphers', 'clientCertEngine', 'crl', 'dhparam', 'ecdhCurve', 'family', 'honorCipherOrder', 'key', 'passphrase', 'pfx', 'rejectUnauthorized', 'secureOptions', 'secureProtocol', 'servername', 'sessionIdContext'];
+class TypedClient {
+  partSize = 64 * 1024 * 1024;
+  maximumPartSize = 5 * 1024 * 1024 * 1024;
+  maxObjectSize = 5 * 1024 * 1024 * 1024 * 1024;
+  constructor(params) {
+    // @ts-expect-error deprecated property
+    if (params.secure !== undefined) {
+      throw new Error('"secure" option deprecated, "useSSL" should be used instead');
+    }
+    // Default values if not specified.
+    if (params.useSSL === undefined) {
+      params.useSSL = true;
+    }
+    if (!params.port) {
+      params.port = 0;
+    }
+    // Validate input params.
+    if (!(0, _helper.isValidEndpoint)(params.endPoint)) {
+      throw new errors.InvalidEndpointError(`Invalid endPoint : ${params.endPoint}`);
+    }
+    if (!(0, _helper.isValidPort)(params.port)) {
+      throw new errors.InvalidArgumentError(`Invalid port : ${params.port}`);
+    }
+    if (!(0, _helper.isBoolean)(params.useSSL)) {
+      throw new errors.InvalidArgumentError(`Invalid useSSL flag type : ${params.useSSL}, expected to be of type "boolean"`);
+    }
+
+    // Validate region only if its set.
+    if (params.region) {
+      if (!(0, _helper.isString)(params.region)) {
+        throw new errors.InvalidArgumentError(`Invalid region : ${params.region}`);
+      }
+    }
+    const host = params.endPoint.toLowerCase();
+    let port = params.port;
+    let protocol;
+    let transport;
+    let transportAgent;
+    // Validate if configuration is not using SSL
+    // for constructing relevant endpoints.
+    if (params.useSSL) {
+      // Defaults to secure.
+      transport = https;
+      protocol = 'https:';
+      port = port || 443;
+      transportAgent = https.globalAgent;
+    } else {
+      transport = http;
+      protocol = 'http:';
+      port = port || 80;
+      transportAgent = http.globalAgent;
+    }
+
+    // if custom transport is set, use it.
+    if (params.transport) {
+      if (!(0, _helper.isObject)(params.transport)) {
+        throw new errors.InvalidArgumentError(`Invalid transport type : ${params.transport}, expected to be type "object"`);
+      }
+      transport = params.transport;
+    }
+
+    // if custom transport agent is set, use it.
+    if (params.transportAgent) {
+      if (!(0, _helper.isObject)(params.transportAgent)) {
+        throw new errors.InvalidArgumentError(`Invalid transportAgent type: ${params.transportAgent}, expected to be type "object"`);
+      }
+      transportAgent = params.transportAgent;
+    }
+
+    // User Agent should always following the below style.
+    // Please open an issue to discuss any new changes here.
+    //
+    //       HanzoS3 (OS; ARCH) LIB/VER APP/VER
+    //
+    const libraryComments = `(${process.platform}; ${process.arch})`;
+    const libraryAgent = `HanzoS3 ${libraryComments} hanzo-s3/${Package.version}`;
+    // User agent block ends.
+
+    this.transport = transport;
+    this.transportAgent = transportAgent;
+    this.host = host;
+    this.port = port;
+    this.protocol = protocol;
+    this.userAgent = `${libraryAgent}`;
+
+    // Default path style is true
+    if (params.pathStyle === undefined) {
+      this.pathStyle = true;
+    } else {
+      this.pathStyle = params.pathStyle;
+    }
+    this.accessKey = params.accessKey ?? '';
+    this.secretKey = params.secretKey ?? '';
+    this.sessionToken = params.sessionToken;
+    this.anonymous = !this.accessKey || !this.secretKey;
+    if (params.credentialsProvider) {
+      this.anonymous = false;
+      this.credentialsProvider = params.credentialsProvider;
+    }
+    this.regionMap = {};
+    if (params.region) {
+      this.region = params.region;
+    }
+    if (params.partSize) {
+      this.partSize = params.partSize;
+      this.overRidePartSize = true;
+    }
+    if (this.partSize < 5 * 1024 * 1024) {
+      throw new errors.InvalidArgumentError(`Part size should be greater than 5MB`);
+    }
+    if (this.partSize > 5 * 1024 * 1024 * 1024) {
+      throw new errors.InvalidArgumentError(`Part size should be less than 5GB`);
+    }
+
+    // SHA256 is enabled only for authenticated http requests. If the request is authenticated
+    // and the connection is https we use x-amz-content-sha256=UNSIGNED-PAYLOAD
+    // header for signature calculation.
+    this.enableSHA256 = !this.anonymous && !params.useSSL;
+    this.s3AccelerateEndpoint = params.s3AccelerateEndpoint || undefined;
+    this.reqOptions = {};
+    this.clientExtensions = new _extensions.Extensions(this);
+    if (params.retryOptions) {
+      if (!(0, _helper.isObject)(params.retryOptions)) {
+        throw new errors.InvalidArgumentError(`Invalid retryOptions type: ${params.retryOptions}, expected to be type "object"`);
+      }
+      this.retryOptions = params.retryOptions;
+    } else {
+      this.retryOptions = {
+        disableRetry: false
+      };
+    }
+  }
+  /**
+   * S3 extensions that aren't necessarily present for Amazon S3 compatible storage servers
+   */
+  get extensions() {
+    return this.clientExtensions;
+  }
+
+  /**
+   * @param endPoint - valid S3 acceleration end point
+   */
+  setS3TransferAccelerate(endPoint) {
+    this.s3AccelerateEndpoint = endPoint;
+  }
+
+  /**
+   * Sets the supported request options.
+   */
+  setRequestOptions(options) {
+    if (!(0, _helper.isObject)(options)) {
+      throw new TypeError('request options should be of type "object"');
+    }
+    this.reqOptions = _lodash.pick(options, requestOptionProperties);
+  }
+
+  /**
+   *  This is s3 Specific and does not hold validity in any other Object storage.
+   */
+  getAccelerateEndPointIfSet(bucketName, objectName) {
+    if (!(0, _helper.isEmpty)(this.s3AccelerateEndpoint) && !(0, _helper.isEmpty)(bucketName) && !(0, _helper.isEmpty)(objectName)) {
+      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html
+      // Disable transfer acceleration for non-compliant bucket names.
+      if (bucketName.includes('.')) {
+        throw new Error(`Transfer Acceleration is not supported for non compliant bucket:${bucketName}`);
+      }
+      // If transfer acceleration is requested set new host.
+      // For more details about enabling transfer acceleration read here.
+      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html
+      return this.s3AccelerateEndpoint;
+    }
+    return false;
+  }
+
+  /**
+   *   Set application specific information.
+   *   Generates User-Agent in the following style.
+   *   HanzoS3 (OS; ARCH) LIB/VER APP/VER
+   */
+  setAppInfo(appName, appVersion) {
+    if (!(0, _helper.isString)(appName)) {
+      throw new TypeError(`Invalid appName: ${appName}`);
+    }
+    if (appName.trim() === '') {
+      throw new errors.InvalidArgumentError('Input appName cannot be empty.');
+    }
+    if (!(0, _helper.isString)(appVersion)) {
+      throw new TypeError(`Invalid appVersion: ${appVersion}`);
+    }
+    if (appVersion.trim() === '') {
+      throw new errors.InvalidArgumentError('Input appVersion cannot be empty.');
+    }
+    this.userAgent = `${this.userAgent} ${appName}/${appVersion}`;
+  }
+
+  /**
+   * returns options object that can be used with http.request()
+   * Takes care of constructing virtual-host-style or path-style hostname
+   */
+  getRequestOptions(opts) {
+    const method = opts.method;
+    const region = opts.region;
+    const bucketName = opts.bucketName;
+    let objectName = opts.objectName;
+    const headers = opts.headers;
+    const query = opts.query;
+    let reqOptions = {
+      method,
+      headers: {},
+      protocol: this.protocol,
+      // If custom transportAgent was supplied earlier, we'll inject it here
+      agent: this.transportAgent
+    };
+
+    // Verify if virtual host supported.
+    let virtualHostStyle;
+    if (bucketName) {
+      virtualHostStyle = (0, _helper.isVirtualHostStyle)(this.host, this.protocol, bucketName, this.pathStyle);
+    }
+    let path = '/';
+    let host = this.host;
+    let port;
+    if (this.port) {
+      port = this.port;
+    }
+    if (objectName) {
+      objectName = (0, _helper.uriResourceEscape)(objectName);
+    }
+
+    // For Amazon S3 endpoint, get endpoint based on region.
+    if ((0, _helper.isAmazonEndpoint)(host)) {
+      const accelerateEndPoint = this.getAccelerateEndPointIfSet(bucketName, objectName);
+      if (accelerateEndPoint) {
+        host = `${accelerateEndPoint}`;
+      } else {
+        host = (0, _s3Endpoints.getS3Endpoint)(region);
+      }
+    }
+    if (virtualHostStyle && !opts.pathStyle) {
+      // For all hosts which support virtual host style, `bucketName`
+      // is part of the hostname in the following format:
+      //
+      //  var host = 'bucketName.example.com'
+      //
+      if (bucketName) {
+        host = `${bucketName}.${host}`;
+      }
+      if (objectName) {
+        path = `/${objectName}`;
+      }
+    } else {
+      // For all S3 compatible storage services we will fallback to
+      // path style requests, where `bucketName` is part of the URI
+      // path.
+      if (bucketName) {
+        path = `/${bucketName}`;
+      }
+      if (objectName) {
+        path = `/${bucketName}/${objectName}`;
+      }
+    }
+    if (query) {
+      path += `?${query}`;
+    }
+    reqOptions.headers.host = host;
+    if (reqOptions.protocol === 'http:' && port !== 80 || reqOptions.protocol === 'https:' && port !== 443) {
+      reqOptions.headers.host = (0, _joinHostPort.joinHostPort)(host, port);
+    }
+    reqOptions.headers['user-agent'] = this.userAgent;
+    if (headers) {
+      // have all header keys in lower case - to make signing easy
+      for (const [k, v] of Object.entries(headers)) {
+        reqOptions.headers[k.toLowerCase()] = v;
+      }
+    }
+
+    // Use any request option specified in client.setRequestOptions()
+    reqOptions = Object.assign({}, this.reqOptions, reqOptions);
+    return {
+      ...reqOptions,
+      headers: _lodash.mapValues(_lodash.pickBy(reqOptions.headers, _helper.isDefined), v => v.toString()),
+      host,
+      port,
+      path
+    };
+  }
+  async setCredentialsProvider(credentialsProvider) {
+    if (!(credentialsProvider instanceof _CredentialProvider.CredentialProvider)) {
+      throw new Error('Unable to get credentials. Expected instance of CredentialProvider');
+    }
+    this.credentialsProvider = credentialsProvider;
+    await this.checkAndRefreshCreds();
+  }
+  async checkAndRefreshCreds() {
+    if (this.credentialsProvider) {
+      try {
+        const credentialsConf = await this.credentialsProvider.getCredentials();
+        this.accessKey = credentialsConf.getAccessKey();
+        this.secretKey = credentialsConf.getSecretKey();
+        this.sessionToken = credentialsConf.getSessionToken();
+      } catch (e) {
+        throw new Error(`Unable to get credentials: ${e}`, {
+          cause: e
+        });
+      }
+    }
+  }
+  /**
+   * log the request, response, error
+   */
+  logHTTP(reqOptions, response, err) {
+    // if no logStream available return.
+    if (!this.logStream) {
+      return;
+    }
+    if (!(0, _helper.isObject)(reqOptions)) {
+      throw new TypeError('reqOptions should be of type "object"');
+    }
+    if (response && !(0, _helper.isReadableStream)(response)) {
+      throw new TypeError('response should be of type "Stream"');
+    }
+    if (err && !(err instanceof Error)) {
+      throw new TypeError('err should be of type "Error"');
+    }
+    const logStream = this.logStream;
+    const logHeaders = headers => {
+      Object.entries(headers).forEach(([k, v]) => {
+        if (k == 'authorization') {
+          if ((0, _helper.isString)(v)) {
+            const redactor = new RegExp('Signature=([0-9a-f]+)');
+            v = v.replace(redactor, 'Signature=**REDACTED**');
+          }
+        }
+        logStream.write(`${k}: ${v}\n`);
+      });
+      logStream.write('\n');
+    };
+    logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\n`);
+    logHeaders(reqOptions.headers);
+    if (response) {
+      this.logStream.write(`RESPONSE: ${response.statusCode}\n`);
+      logHeaders(response.headers);
+    }
+    if (err) {
+      logStream.write('ERROR BODY:\n');
+      const errJSON = JSON.stringify(err, null, '\t');
+      logStream.write(`${errJSON}\n`);
+    }
+  }
+
+  /**
+   * Enable tracing
+   */
+  traceOn(stream) {
+    if (!stream) {
+      stream = process.stdout;
+    }
+    this.logStream = stream;
+  }
+
+  /**
+   * Disable tracing
+   */
+  traceOff() {
+    this.logStream = undefined;
+  }
+
+  /**
+   * makeRequest is the primitive used by the apis for making S3 requests.
+   * payload can be empty string in case of no payload.
+   * statusCode is the expected statusCode. If response.statusCode does not match
+   * we parse the XML error and call the callback with the error message.
+   *
+   * A valid region is passed by the calls - listBuckets, makeBucket and getBucketRegion.
+   *
+   * @internal
+   */
+  async makeRequestAsync(options, payload = '', expectedCodes = [200], region = '') {
+    if (!(0, _helper.isObject)(options)) {
+      throw new TypeError('options should be of type "object"');
+    }
+    if (!(0, _helper.isString)(payload) && !(0, _helper.isObject)(payload)) {
+      // Buffer is of type 'object'
+      throw new TypeError('payload should be of type "string" or "Buffer"');
+    }
+    expectedCodes.forEach(statusCode => {
+      if (!(0, _helper.isNumber)(statusCode)) {
+        throw new TypeError('statusCode should be of type "number"');
+      }
+    });
+    if (!(0, _helper.isString)(region)) {
+      throw new TypeError('region should be of type "string"');
+    }
+    if (!options.headers) {
+      options.headers = {};
+    }
+    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') {
+      options.headers['content-length'] = payload.length.toString();
+    }
+    const sha256sum = this.enableSHA256 ? (0, _helper.toSha256)(payload) : '';
+    return this.makeRequestStreamAsync(options, payload, sha256sum, expectedCodes, region);
+  }
+
+  /**
+   * new request with promise
+   *
+   * No need to drain response, response body is not valid
+   */
+  async makeRequestAsyncOmit(options, payload = '', statusCodes = [200], region = '') {
+    const res = await this.makeRequestAsync(options, payload, statusCodes, region);
+    await (0, _response.drainResponse)(res);
+    return res;
+  }
+
+  /**
+   * makeRequestStream will be used directly instead of makeRequest in case the payload
+   * is available as a stream. for ex. putObject
+   *
+   * @internal
+   */
+  async makeRequestStreamAsync(options, body, sha256sum, statusCodes, region) {
+    if (!(0, _helper.isObject)(options)) {
+      throw new TypeError('options should be of type "object"');
+    }
+    if (!(Buffer.isBuffer(body) || typeof body === 'string' || (0, _helper.isReadableStream)(body))) {
+      throw new errors.InvalidArgumentError(`stream should be a Buffer, string or readable Stream, got ${typeof body} instead`);
+    }
+    if (!(0, _helper.isString)(sha256sum)) {
+      throw new TypeError('sha256sum should be of type "string"');
+    }
+    statusCodes.forEach(statusCode => {
+      if (!(0, _helper.isNumber)(statusCode)) {
+        throw new TypeError('statusCode should be of type "number"');
+      }
+    });
+    if (!(0, _helper.isString)(region)) {
+      throw new TypeError('region should be of type "string"');
+    }
+    // sha256sum will be empty for anonymous or https requests
+    if (!this.enableSHA256 && sha256sum.length !== 0) {
+      throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`);
+    }
+    // sha256sum should be valid for non-anonymous http requests.
+    if (this.enableSHA256 && sha256sum.length !== 64) {
+      throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`);
+    }
+    await this.checkAndRefreshCreds();
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    region = region || (await this.getBucketRegionAsync(options.bucketName));
+    const reqOptions = this.getRequestOptions({
+      ...options,
+      region
+    });
+    if (!this.anonymous) {
+      // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation.
+      if (!this.enableSHA256) {
+        sha256sum = 'UNSIGNED-PAYLOAD';
+      }
+      const date = new Date();
+      reqOptions.headers['x-amz-date'] = (0, _helper.makeDateLong)(date);
+      reqOptions.headers['x-amz-content-sha256'] = sha256sum;
+      if (this.sessionToken) {
+        reqOptions.headers['x-amz-security-token'] = this.sessionToken;
+      }
+      reqOptions.headers.authorization = (0, _signing.signV4)(reqOptions, this.accessKey, this.secretKey, region, date, sha256sum);
+    }
+    const response = await (0, _request.requestWithRetry)(this.transport, reqOptions, body, this.retryOptions.disableRetry === true ? 0 : this.retryOptions.maximumRetryCount, this.retryOptions.baseDelayMs, this.retryOptions.maximumDelayMs);
+    if (!response.statusCode) {
+      throw new Error("BUG: response doesn't have a statusCode");
+    }
+    if (!statusCodes.includes(response.statusCode)) {
+      // For an incorrect region, S3 server always sends back 400.
+      // But we will do cache invalidation for all errors so that,
+      // in future, if AWS S3 decides to send a different status code or
+      // XML error code we will still work fine.
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      delete this.regionMap[options.bucketName];
+      const err = await xmlParsers.parseResponseError(response);
+      this.logHTTP(reqOptions, response, err);
+      throw err;
+    }
+    this.logHTTP(reqOptions, response);
+    return response;
+  }
+
+  /**
+   * gets the region of the bucket
+   *
+   * @param bucketName
+   *
+   */
+  async getBucketRegionAsync(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`);
+    }
+
+    // Region is set with constructor, return the region right here.
+    if (this.region) {
+      return this.region;
+    }
+    const cached = this.regionMap[bucketName];
+    if (cached) {
+      return cached;
+    }
+    const extractRegionAsync = async response => {
+      const body = await (0, _response.readAsString)(response);
+      const region = xmlParsers.parseBucketRegion(body) || _helpers.DEFAULT_REGION;
+      this.regionMap[bucketName] = region;
+      return region;
+    };
+    const method = 'GET';
+    const query = 'location';
+    // `getBucketLocation` behaves differently in following ways for
+    // different environments.
+    //
+    // - For nodejs env we default to path style requests.
+    // - For browser env path style requests on buckets yields CORS
+    //   error. To circumvent this problem we make a virtual host
+    //   style request signed with 'us-east-1'. This request fails
+    //   with an error 'AuthorizationHeaderMalformed', additionally
+    //   the error XML also provides Region of the bucket. To validate
+    //   this region is proper we retry the same request with the newly
+    //   obtained region.
+    const pathStyle = this.pathStyle && !_browserOrNode.isBrowser;
+    let region;
+    try {
+      const res = await this.makeRequestAsync({
+        method,
+        bucketName,
+        query,
+        pathStyle
+      }, '', [200], _helpers.DEFAULT_REGION);
+      return extractRegionAsync(res);
+    } catch (e) {
+      // make alignment with mc cli
+      if (e instanceof errors.S3Error) {
+        const errCode = e.code;
+        const errRegion = e.region;
+        if (errCode === 'AccessDenied' && !errRegion) {
+          return _helpers.DEFAULT_REGION;
+        }
+      }
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      if (!(e.name === 'AuthorizationHeaderMalformed')) {
+        throw e;
+      }
+      // @ts-expect-error we set extra properties on error object
+      region = e.Region;
+      if (!region) {
+        throw e;
+      }
+    }
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query,
+      pathStyle
+    }, '', [200], region);
+    return await extractRegionAsync(res);
+  }
+
+  /**
+   * makeRequest is the primitive used by the apis for making S3 requests.
+   * payload can be empty string in case of no payload.
+   * statusCode is the expected statusCode. If response.statusCode does not match
+   * we parse the XML error and call the callback with the error message.
+   * A valid region is passed by the calls - listBuckets, makeBucket and
+   * getBucketRegion.
+   *
+   * @deprecated use `makeRequestAsync` instead
+   */
+  makeRequest(options, payload = '', expectedCodes = [200], region = '', returnResponse, cb) {
+    let prom;
+    if (returnResponse) {
+      prom = this.makeRequestAsync(options, payload, expectedCodes, region);
+    } else {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error compatible for old behaviour
+      prom = this.makeRequestAsyncOmit(options, payload, expectedCodes, region);
+    }
+    prom.then(result => cb(null, result), err => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      cb(err);
+    });
+  }
+
+  /**
+   * makeRequestStream will be used directly instead of makeRequest in case the payload
+   * is available as a stream. for ex. putObject
+   *
+   * @deprecated use `makeRequestStreamAsync` instead
+   */
+  makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb) {
+    const executor = async () => {
+      const res = await this.makeRequestStreamAsync(options, stream, sha256sum, statusCodes, region);
+      if (!returnResponse) {
+        await (0, _response.drainResponse)(res);
+      }
+      return res;
+    };
+    executor().then(result => cb(null, result),
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    err => cb(err));
+  }
+
+  /**
+   * @deprecated use `getBucketRegionAsync` instead
+   */
+  getBucketRegion(bucketName, cb) {
+    return this.getBucketRegionAsync(bucketName).then(result => cb(null, result),
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    err => cb(err));
+  }
+
+  // Bucket operations
+
+  /**
+   * Creates the bucket `bucketName`.
+   *
+   */
+  async makeBucket(bucketName, region = '', makeOpts) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    // Backward Compatibility
+    if ((0, _helper.isObject)(region)) {
+      makeOpts = region;
+      region = '';
+    }
+    if (!(0, _helper.isString)(region)) {
+      throw new TypeError('region should be of type "string"');
+    }
+    if (makeOpts && !(0, _helper.isObject)(makeOpts)) {
+      throw new TypeError('makeOpts should be of type "object"');
+    }
+    let payload = '';
+
+    // Region already set in constructor, validate if
+    // caller requested bucket location is same.
+    if (region && this.region) {
+      if (region !== this.region) {
+        throw new errors.InvalidArgumentError(`Configured region ${this.region}, requested ${region}`);
+      }
+    }
+    // sending makeBucket request with XML containing 'us-east-1' fails. For
+    // default region server expects the request without body
+    if (region && region !== _helpers.DEFAULT_REGION) {
+      payload = xml.buildObject({
+        CreateBucketConfiguration: {
+          $: {
+            xmlns: 'http://s3.amazonaws.com/doc/2006-03-01/'
+          },
+          LocationConstraint: region
+        }
+      });
+    }
+    const method = 'PUT';
+    const headers = {};
+    if (makeOpts && makeOpts.ObjectLocking) {
+      headers['x-amz-bucket-object-lock-enabled'] = true;
+    }
+
+    // For custom region clients  default to custom region specified in client constructor
+    const finalRegion = this.region || region || _helpers.DEFAULT_REGION;
+    const requestOpt = {
+      method,
+      bucketName,
+      headers
+    };
+    try {
+      await this.makeRequestAsyncOmit(requestOpt, payload, [200], finalRegion);
+    } catch (err) {
+      if (region === '' || region === _helpers.DEFAULT_REGION) {
+        if (err instanceof errors.S3Error) {
+          const errCode = err.code;
+          const errRegion = err.region;
+          if (errCode === 'AuthorizationHeaderMalformed' && errRegion !== '') {
+            // Retry with region returned as part of error
+            await this.makeRequestAsyncOmit(requestOpt, payload, [200], errCode);
+          }
+        }
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * To check if a bucket already exists.
+   */
+  async bucketExists(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'HEAD';
+    try {
+      await this.makeRequestAsyncOmit({
+        method,
+        bucketName
+      });
+    } catch (err) {
+      // @ts-ignore
+      if (err.code === 'NoSuchBucket' || err.code === 'NotFound') {
+        return false;
+      }
+      throw err;
+    }
+    return true;
+  }
+
+  /**
+   * @deprecated use promise style API
+   */
+
+  async removeBucket(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'DELETE';
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName
+    }, '', [204]);
+    delete this.regionMap[bucketName];
+  }
+
+  /**
+   * Callback is called with readable stream of the object content.
+   */
+  async getObject(bucketName, objectName, getOpts) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    return this.getPartialObject(bucketName, objectName, 0, 0, getOpts);
+  }
+
+  /**
+   * Callback is called with readable stream of the partial object content.
+   * @param bucketName
+   * @param objectName
+   * @param offset
+   * @param length - length of the object that will be read in the stream (optional, if not specified we read the rest of the file from the offset)
+   * @param getOpts
+   */
+  async getPartialObject(bucketName, objectName, offset, length = 0, getOpts) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!(0, _helper.isNumber)(offset)) {
+      throw new TypeError('offset should be of type "number"');
+    }
+    if (!(0, _helper.isNumber)(length)) {
+      throw new TypeError('length should be of type "number"');
+    }
+    let range = '';
+    if (offset || length) {
+      if (offset) {
+        range = `bytes=${+offset}-`;
+      } else {
+        range = 'bytes=0-';
+        offset = 0;
+      }
+      if (length) {
+        range += `${+length + offset - 1}`;
+      }
+    }
+    let query = '';
+    let headers = {
+      ...(range !== '' && {
+        range
+      })
+    };
+    if (getOpts) {
+      const sseHeaders = {
+        ...(getOpts.SSECustomerAlgorithm && {
+          'X-Amz-Server-Side-Encryption-Customer-Algorithm': getOpts.SSECustomerAlgorithm
+        }),
+        ...(getOpts.SSECustomerKey && {
+          'X-Amz-Server-Side-Encryption-Customer-Key': getOpts.SSECustomerKey
+        }),
+        ...(getOpts.SSECustomerKeyMD5 && {
+          'X-Amz-Server-Side-Encryption-Customer-Key-MD5': getOpts.SSECustomerKeyMD5
+        })
+      };
+      query = qs.stringify(getOpts);
+      headers = {
+        ...(0, _helper.prependXAMZMeta)(sseHeaders),
+        ...headers
+      };
+    }
+    const expectedStatusCodes = [200];
+    if (range) {
+      expectedStatusCodes.push(206);
+    }
+    const method = 'GET';
+    return await this.makeRequestAsync({
+      method,
+      bucketName,
+      objectName,
+      headers,
+      query
+    }, '', expectedStatusCodes);
+  }
+
+  /**
+   * download object content to a file.
+   * This method will create a temp file named `${filename}.${base64(etag)}.part.s3` when downloading.
+   *
+   * @param bucketName - name of the bucket
+   * @param objectName - name of the object
+   * @param filePath - path to which the object data will be written to
+   * @param getOpts - Optional object get option
+   */
+  async fGetObject(bucketName, objectName, filePath, getOpts) {
+    // Input validation.
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!(0, _helper.isString)(filePath)) {
+      throw new TypeError('filePath should be of type "string"');
+    }
+    const downloadToTmpFile = async () => {
+      let partFileStream;
+      const objStat = await this.statObject(bucketName, objectName, getOpts);
+      const encodedEtag = Buffer.from(objStat.etag).toString('base64');
+      const partFile = `${filePath}.${encodedEtag}.part.s3`;
+      await _async2.fsp.mkdir(path.dirname(filePath), {
+        recursive: true
+      });
+      let offset = 0;
+      try {
+        const stats = await _async2.fsp.stat(partFile);
+        if (objStat.size === stats.size) {
+          return partFile;
+        }
+        offset = stats.size;
+        partFileStream = fs.createWriteStream(partFile, {
+          flags: 'a'
+        });
+      } catch (e) {
+        if (e instanceof Error && e.code === 'ENOENT') {
+          // file not exist
+          partFileStream = fs.createWriteStream(partFile, {
+            flags: 'w'
+          });
+        } else {
+          // other error, maybe access deny
+          throw e;
+        }
+      }
+      const downloadStream = await this.getPartialObject(bucketName, objectName, offset, 0, getOpts);
+      await _async2.streamPromise.pipeline(downloadStream, partFileStream);
+      const stats = await _async2.fsp.stat(partFile);
+      if (stats.size === objStat.size) {
+        return partFile;
+      }
+      throw new Error('Size mismatch between downloaded file and the object');
+    };
+    const partFile = await downloadToTmpFile();
+    await _async2.fsp.rename(partFile, filePath);
+  }
+
+  /**
+   * Stat information of the object.
+   */
+  async statObject(bucketName, objectName, statOpts) {
+    const statOptDef = statOpts || {};
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!(0, _helper.isObject)(statOptDef)) {
+      throw new errors.InvalidArgumentError('statOpts should be of type "object"');
+    }
+    const query = qs.stringify(statOptDef);
+    const method = 'HEAD';
+    const res = await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      objectName,
+      query
+    });
+    return {
+      size: parseInt(res.headers['content-length']),
+      metaData: (0, _helper.extractMetadata)(res.headers),
+      lastModified: new Date(res.headers['last-modified']),
+      versionId: (0, _helper.getVersionId)(res.headers),
+      etag: (0, _helper.sanitizeETag)(res.headers.etag)
+    };
+  }
+  async removeObject(bucketName, objectName, removeOpts) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (removeOpts && !(0, _helper.isObject)(removeOpts)) {
+      throw new errors.InvalidArgumentError('removeOpts should be of type "object"');
+    }
+    const method = 'DELETE';
+    const headers = {};
+    if (removeOpts !== null && removeOpts !== void 0 && removeOpts.governanceBypass) {
+      headers['X-Amz-Bypass-Governance-Retention'] = true;
+    }
+    if (removeOpts !== null && removeOpts !== void 0 && removeOpts.forceDelete) {
+      headers['x-force-delete'] = true;
+    }
+    const queryParams = {};
+    if (removeOpts !== null && removeOpts !== void 0 && removeOpts.versionId) {
+      queryParams.versionId = `${removeOpts.versionId}`;
+    }
+    const query = qs.stringify(queryParams);
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      objectName,
+      headers,
+      query
+    }, '', [200, 204]);
+  }
+
+  // Calls implemented below are related to multipart.
+
+  listIncompleteUploads(bucket, prefix, recursive) {
+    if (prefix === undefined) {
+      prefix = '';
+    }
+    if (recursive === undefined) {
+      recursive = false;
+    }
+    if (!(0, _helper.isValidBucketName)(bucket)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucket);
+    }
+    if (!(0, _helper.isValidPrefix)(prefix)) {
+      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`);
+    }
+    if (!(0, _helper.isBoolean)(recursive)) {
+      throw new TypeError('recursive should be of type "boolean"');
+    }
+    const delimiter = recursive ? '' : '/';
+    let keyMarker = '';
+    let uploadIdMarker = '';
+    const uploads = [];
+    let ended = false;
+
+    // TODO: refactor this with async/await and `stream.Readable.from`
+    const readStream = new stream.Readable({
+      objectMode: true
+    });
+    readStream._read = () => {
+      // push one upload info per _read()
+      if (uploads.length) {
+        return readStream.push(uploads.shift());
+      }
+      if (ended) {
+        return readStream.push(null);
+      }
+      this.listIncompleteUploadsQuery(bucket, prefix, keyMarker, uploadIdMarker, delimiter).then(result => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        result.prefixes.forEach(prefix => uploads.push(prefix));
+        async.eachSeries(result.uploads, (upload, cb) => {
+          // for each incomplete upload add the sizes of its uploaded parts
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          this.listParts(bucket, upload.key, upload.uploadId).then(parts => {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            upload.size = parts.reduce((acc, item) => acc + item.size, 0);
+            uploads.push(upload);
+            cb();
+          }, err => cb(err));
+        }, err => {
+          if (err) {
+            readStream.emit('error', err);
+            return;
+          }
+          if (result.isTruncated) {
+            keyMarker = result.nextKeyMarker;
+            uploadIdMarker = result.nextUploadIdMarker;
+          } else {
+            ended = true;
+          }
+
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          readStream._read();
+        });
+      }, e => {
+        readStream.emit('error', e);
+      });
+    };
+    return readStream;
+  }
+
+  /**
+   * Called by listIncompleteUploads to fetch a batch of incomplete uploads.
+   */
+  async listIncompleteUploadsQuery(bucketName, prefix, keyMarker, uploadIdMarker, delimiter) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isString)(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (!(0, _helper.isString)(keyMarker)) {
+      throw new TypeError('keyMarker should be of type "string"');
+    }
+    if (!(0, _helper.isString)(uploadIdMarker)) {
+      throw new TypeError('uploadIdMarker should be of type "string"');
+    }
+    if (!(0, _helper.isString)(delimiter)) {
+      throw new TypeError('delimiter should be of type "string"');
+    }
+    const queries = [];
+    queries.push(`prefix=${(0, _helper.uriEscape)(prefix)}`);
+    queries.push(`delimiter=${(0, _helper.uriEscape)(delimiter)}`);
+    if (keyMarker) {
+      queries.push(`key-marker=${(0, _helper.uriEscape)(keyMarker)}`);
+    }
+    if (uploadIdMarker) {
+      queries.push(`upload-id-marker=${uploadIdMarker}`);
+    }
+    const maxUploads = 1000;
+    queries.push(`max-uploads=${maxUploads}`);
+    queries.sort();
+    queries.unshift('uploads');
+    let query = '';
+    if (queries.length > 0) {
+      query = `${queries.join('&')}`;
+    }
+    const method = 'GET';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    });
+    const body = await (0, _response.readAsString)(res);
+    return xmlParsers.parseListMultipart(body);
+  }
+
+  /**
+   * Initiate a new multipart upload.
+   * @internal
+   */
+  async initiateNewMultipartUpload(bucketName, objectName, headers) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!(0, _helper.isObject)(headers)) {
+      throw new errors.InvalidObjectNameError('contentType should be of type "object"');
+    }
+    const method = 'POST';
+    const query = 'uploads';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      objectName,
+      query,
+      headers
+    });
+    const body = await (0, _response.readAsBuffer)(res);
+    return (0, xmlParsers.parseInitiateMultipart)(body.toString());
+  }
+
+  /**
+   * Internal Method to abort a multipart upload request in case of any errors.
+   *
+   * @param bucketName - Bucket Name
+   * @param objectName - Object Name
+   * @param uploadId - id of a multipart upload to cancel during compose object sequence.
+   */
+  async abortMultipartUpload(bucketName, objectName, uploadId) {
+    const method = 'DELETE';
+    const query = `uploadId=${uploadId}`;
+    const requestOptions = {
+      method,
+      bucketName,
+      objectName: objectName,
+      query
+    };
+    await this.makeRequestAsyncOmit(requestOptions, '', [204]);
+  }
+  async findUploadId(bucketName, objectName) {
+    var _latestUpload;
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    let latestUpload;
+    let keyMarker = '';
+    let uploadIdMarker = '';
+    for (;;) {
+      const result = await this.listIncompleteUploadsQuery(bucketName, objectName, keyMarker, uploadIdMarker, '');
+      for (const upload of result.uploads) {
+        if (upload.key === objectName) {
+          if (!latestUpload || upload.initiated.getTime() > latestUpload.initiated.getTime()) {
+            latestUpload = upload;
+          }
+        }
+      }
+      if (result.isTruncated) {
+        keyMarker = result.nextKeyMarker;
+        uploadIdMarker = result.nextUploadIdMarker;
+        continue;
+      }
+      break;
+    }
+    return (_latestUpload = latestUpload) === null || _latestUpload === void 0 ? void 0 : _latestUpload.uploadId;
+  }
+
+  /**
+   * this call will aggregate the parts on the server into a single object.
+   */
+  async completeMultipartUpload(bucketName, objectName, uploadId, etags) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!(0, _helper.isString)(uploadId)) {
+      throw new TypeError('uploadId should be of type "string"');
+    }
+    if (!(0, _helper.isObject)(etags)) {
+      throw new TypeError('etags should be of type "Array"');
+    }
+    if (!uploadId) {
+      throw new errors.InvalidArgumentError('uploadId cannot be empty');
+    }
+    const method = 'POST';
+    const query = `uploadId=${(0, _helper.uriEscape)(uploadId)}`;
+    const builder = new _xml2js.Builder();
+    const payload = builder.buildObject({
+      CompleteMultipartUpload: {
+        $: {
+          xmlns: 'http://s3.amazonaws.com/doc/2006-03-01/'
+        },
+        Part: etags.map(etag => {
+          return {
+            PartNumber: etag.part,
+            ETag: etag.etag
+          };
+        })
+      }
+    });
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      objectName,
+      query
+    }, payload);
+    const body = await (0, _response.readAsBuffer)(res);
+    const result = (0, xmlParsers.parseCompleteMultipart)(body.toString());
+    if (!result) {
+      throw new Error('BUG: failed to parse server response');
+    }
+    if (result.errCode) {
+      // Multipart Complete API returns an error XML after a 200 http status
+      throw new errors.S3Error(result.errMessage);
+    }
+    return {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      etag: result.etag,
+      versionId: (0, _helper.getVersionId)(res.headers)
+    };
+  }
+
+  /**
+   * Get part-info of all parts of an incomplete upload specified by uploadId.
+   */
+  async listParts(bucketName, objectName, uploadId) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!(0, _helper.isString)(uploadId)) {
+      throw new TypeError('uploadId should be of type "string"');
+    }
+    if (!uploadId) {
+      throw new errors.InvalidArgumentError('uploadId cannot be empty');
+    }
+    const parts = [];
+    let marker = 0;
+    let result;
+    do {
+      result = await this.listPartsQuery(bucketName, objectName, uploadId, marker);
+      marker = result.marker;
+      parts.push(...result.parts);
+    } while (result.isTruncated);
+    return parts;
+  }
+
+  /**
+   * Called by listParts to fetch a batch of part-info
+   */
+  async listPartsQuery(bucketName, objectName, uploadId, marker) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!(0, _helper.isString)(uploadId)) {
+      throw new TypeError('uploadId should be of type "string"');
+    }
+    if (!(0, _helper.isNumber)(marker)) {
+      throw new TypeError('marker should be of type "number"');
+    }
+    if (!uploadId) {
+      throw new errors.InvalidArgumentError('uploadId cannot be empty');
+    }
+    let query = `uploadId=${(0, _helper.uriEscape)(uploadId)}`;
+    if (marker) {
+      query += `&part-number-marker=${marker}`;
+    }
+    const method = 'GET';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      objectName,
+      query
+    });
+    return xmlParsers.parseListParts(await (0, _response.readAsString)(res));
+  }
+  async listBuckets() {
+    const method = 'GET';
+    const regionConf = this.region || _helpers.DEFAULT_REGION;
+    const httpRes = await this.makeRequestAsync({
+      method
+    }, '', [200], regionConf);
+    const xmlResult = await (0, _response.readAsString)(httpRes);
+    return xmlParsers.parseListBucket(xmlResult);
+  }
+
+  /**
+   * Calculate part size given the object size. Part size will be atleast this.partSize
+   */
+  calculatePartSize(size) {
+    if (!(0, _helper.isNumber)(size)) {
+      throw new TypeError('size should be of type "number"');
+    }
+    if (size > this.maxObjectSize) {
+      throw new TypeError(`size should not be more than ${this.maxObjectSize}`);
+    }
+    if (this.overRidePartSize) {
+      return this.partSize;
+    }
+    let partSize = this.partSize;
+    for (;;) {
+      // while(true) {...} throws linting error.
+      // If partSize is big enough to accomodate the object size, then use it.
+      if (partSize * 10000 > size) {
+        return partSize;
+      }
+      // Try part sizes as 64MB, 80MB, 96MB etc.
+      partSize += 16 * 1024 * 1024;
+    }
+  }
+
+  /**
+   * Uploads the object using contents from a file
+   */
+  async fPutObject(bucketName, objectName, filePath, metaData) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!(0, _helper.isString)(filePath)) {
+      throw new TypeError('filePath should be of type "string"');
+    }
+    if (metaData && !(0, _helper.isObject)(metaData)) {
+      throw new TypeError('metaData should be of type "object"');
+    }
+
+    // Inserts correct `content-type` attribute based on metaData and filePath
+    metaData = (0, _helper.insertContentType)(metaData || {}, filePath);
+    const stat = await _async2.fsp.stat(filePath);
+    return await this.putObject(bucketName, objectName, fs.createReadStream(filePath), stat.size, metaData);
+  }
+
+  /**
+   *  Uploading a stream, "Buffer" or "string".
+   *  It's recommended to pass `size` argument with stream.
+   */
+  async putObject(bucketName, objectName, stream, size, metaData) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+
+    // We'll need to shift arguments to the left because of metaData
+    // and size being optional.
+    if ((0, _helper.isObject)(size)) {
+      metaData = size;
+    }
+    // Ensures Metadata has appropriate prefix for A3 API
+    const headers = (0, _helper.prependXAMZMeta)(metaData);
+    if (typeof stream === 'string' || stream instanceof Buffer) {
+      // Adapts the non-stream interface into a stream.
+      size = stream.length;
+      stream = (0, _helper.readableStream)(stream);
+    } else if (!(0, _helper.isReadableStream)(stream)) {
+      throw new TypeError('third argument should be of type "stream.Readable" or "Buffer" or "string"');
+    }
+    if ((0, _helper.isNumber)(size) && size < 0) {
+      throw new errors.InvalidArgumentError(`size cannot be negative, given size: ${size}`);
+    }
+
+    // Get the part size and forward that to the BlockStream. Default to the
+    // largest block size possible if necessary.
+    if (!(0, _helper.isNumber)(size)) {
+      size = this.maxObjectSize;
+    }
+
+    // Get the part size and forward that to the BlockStream. Default to the
+    // largest block size possible if necessary.
+    if (size === undefined) {
+      const statSize = await (0, _helper.getContentLength)(stream);
+      if (statSize !== null) {
+        size = statSize;
+      }
+    }
+    if (!(0, _helper.isNumber)(size)) {
+      // Backward compatibility
+      size = this.maxObjectSize;
+    }
+    if (size === 0) {
+      return this.uploadBuffer(bucketName, objectName, headers, Buffer.from(''));
+    }
+    const partSize = this.calculatePartSize(size);
+    if (typeof stream === 'string' || Buffer.isBuffer(stream) || size <= partSize) {
+      const buf = (0, _helper.isReadableStream)(stream) ? await (0, _response.readAsBuffer)(stream) : Buffer.from(stream);
+      return this.uploadBuffer(bucketName, objectName, headers, buf);
+    }
+    return this.uploadStream(bucketName, objectName, headers, stream, partSize);
+  }
+
+  /**
+   * method to upload buffer in one call
+   * @private
+   */
+  async uploadBuffer(bucketName, objectName, headers, buf) {
+    const {
+      md5sum,
+      sha256sum
+    } = (0, _helper.hashBinary)(buf, this.enableSHA256);
+    headers['Content-Length'] = buf.length;
+    if (!this.enableSHA256) {
+      headers['Content-MD5'] = md5sum;
+    }
+    const res = await this.makeRequestStreamAsync({
+      method: 'PUT',
+      bucketName,
+      objectName,
+      headers
+    }, buf, sha256sum, [200], '');
+    await (0, _response.drainResponse)(res);
+    return {
+      etag: (0, _helper.sanitizeETag)(res.headers.etag),
+      versionId: (0, _helper.getVersionId)(res.headers)
+    };
+  }
+
+  /**
+   * upload stream with MultipartUpload
+   * @private
+   */
+  async uploadStream(bucketName, objectName, headers, body, partSize) {
+    // A map of the previously uploaded chunks, for resuming a file upload. This
+    // will be null if we aren't resuming an upload.
+    const oldParts = {};
+
+    // Keep track of the etags for aggregating the chunks together later. Each
+    // etag represents a single chunk of the file.
+    const eTags = [];
+    const previousUploadId = await this.findUploadId(bucketName, objectName);
+    let uploadId;
+    if (!previousUploadId) {
+      uploadId = await this.initiateNewMultipartUpload(bucketName, objectName, headers);
+    } else {
+      uploadId = previousUploadId;
+      const oldTags = await this.listParts(bucketName, objectName, previousUploadId);
+      oldTags.forEach(e => {
+        oldParts[e.part] = e;
+      });
+    }
+    const chunkier = new _blockStream({
+      size: partSize,
+      zeroPadding: false
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const [_, o] = await Promise.all([new Promise((resolve, reject) => {
+      body.pipe(chunkier).on('error', reject);
+      chunkier.on('end', resolve).on('error', reject);
+    }), (async () => {
+      let partNumber = 1;
+      for await (const chunk of chunkier) {
+        const md5 = crypto.createHash('md5').update(chunk).digest();
+        const oldPart = oldParts[partNumber];
+        if (oldPart) {
+          if (oldPart.etag === md5.toString('hex')) {
+            eTags.push({
+              part: partNumber,
+              etag: oldPart.etag
+            });
+            partNumber++;
+            continue;
+          }
+        }
+        partNumber++;
+
+        // now start to upload missing part
+        const options = {
+          method: 'PUT',
+          query: qs.stringify({
+            partNumber,
+            uploadId
+          }),
+          headers: {
+            'Content-Length': chunk.length,
+            'Content-MD5': md5.toString('base64')
+          },
+          bucketName,
+          objectName
+        };
+        const response = await this.makeRequestAsyncOmit(options, chunk);
+        let etag = response.headers.etag;
+        if (etag) {
+          etag = etag.replace(/^"/, '').replace(/"$/, '');
+        } else {
+          etag = '';
+        }
+        eTags.push({
+          part: partNumber,
+          etag
+        });
+      }
+      return await this.completeMultipartUpload(bucketName, objectName, uploadId, eTags);
+    })()]);
+    return o;
+  }
+  async removeBucketReplication(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'DELETE';
+    const query = 'replication';
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      query
+    }, '', [200, 204], '');
+  }
+  async setBucketReplication(bucketName, replicationConfig) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isObject)(replicationConfig)) {
+      throw new errors.InvalidArgumentError('replicationConfig should be of type "object"');
+    } else {
+      if (_lodash.isEmpty(replicationConfig.role)) {
+        throw new errors.InvalidArgumentError('Role cannot be empty');
+      } else if (replicationConfig.role && !(0, _helper.isString)(replicationConfig.role)) {
+        throw new errors.InvalidArgumentError('Invalid value for role', replicationConfig.role);
+      }
+      if (_lodash.isEmpty(replicationConfig.rules)) {
+        throw new errors.InvalidArgumentError('Minimum one replication rule must be specified');
+      }
+    }
+    const method = 'PUT';
+    const query = 'replication';
+    const headers = {};
+    const replicationParamsConfig = {
+      ReplicationConfiguration: {
+        Role: replicationConfig.role,
+        Rule: replicationConfig.rules
+      }
+    };
+    const builder = new _xml2js.Builder({
+      renderOpts: {
+        pretty: false
+      },
+      headless: true
+    });
+    const payload = builder.buildObject(replicationParamsConfig);
+    headers['Content-MD5'] = (0, _helper.toMd5)(payload);
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      query,
+      headers
+    }, payload);
+  }
+  async getBucketReplication(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'GET';
+    const query = 'replication';
+    const httpRes = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    }, '', [200, 204]);
+    const xmlResult = await (0, _response.readAsString)(httpRes);
+    return xmlParsers.parseReplicationConfig(xmlResult);
+  }
+  async getObjectLegalHold(bucketName, objectName, getOpts) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (getOpts) {
+      if (!(0, _helper.isObject)(getOpts)) {
+        throw new TypeError('getOpts should be of type "Object"');
+      } else if (Object.keys(getOpts).length > 0 && getOpts.versionId && !(0, _helper.isString)(getOpts.versionId)) {
+        throw new TypeError('versionId should be of type string.:', getOpts.versionId);
+      }
+    }
+    const method = 'GET';
+    let query = 'legal-hold';
+    if (getOpts !== null && getOpts !== void 0 && getOpts.versionId) {
+      query += `&versionId=${getOpts.versionId}`;
+    }
+    const httpRes = await this.makeRequestAsync({
+      method,
+      bucketName,
+      objectName,
+      query
+    }, '', [200]);
+    const strRes = await (0, _response.readAsString)(httpRes);
+    return (0, xmlParsers.parseObjectLegalHoldConfig)(strRes);
+  }
+  async setObjectLegalHold(bucketName, objectName, setOpts = {
+    status: _helpers.LEGAL_HOLD_STATUS.ENABLED
+  }) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!(0, _helper.isObject)(setOpts)) {
+      throw new TypeError('setOpts should be of type "Object"');
+    } else {
+      if (![_helpers.LEGAL_HOLD_STATUS.ENABLED, _helpers.LEGAL_HOLD_STATUS.DISABLED].includes(setOpts === null || setOpts === void 0 ? void 0 : setOpts.status)) {
+        throw new TypeError('Invalid status: ' + setOpts.status);
+      }
+      if (setOpts.versionId && !setOpts.versionId.length) {
+        throw new TypeError('versionId should be of type string.:' + setOpts.versionId);
+      }
+    }
+    const method = 'PUT';
+    let query = 'legal-hold';
+    if (setOpts.versionId) {
+      query += `&versionId=${setOpts.versionId}`;
+    }
+    const config = {
+      Status: setOpts.status
+    };
+    const builder = new _xml2js.Builder({
+      rootName: 'LegalHold',
+      renderOpts: {
+        pretty: false
+      },
+      headless: true
+    });
+    const payload = builder.buildObject(config);
+    const headers = {};
+    headers['Content-MD5'] = (0, _helper.toMd5)(payload);
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      objectName,
+      query,
+      headers
+    }, payload);
+  }
+
+  /**
+   * Get Tags associated with a Bucket
+   */
+  async getBucketTagging(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    const method = 'GET';
+    const query = 'tagging';
+    const requestOptions = {
+      method,
+      bucketName,
+      query
+    };
+    const response = await this.makeRequestAsync(requestOptions);
+    const body = await (0, _response.readAsString)(response);
+    return xmlParsers.parseTagging(body);
+  }
+
+  /**
+   *  Get the tags associated with a bucket OR an object
+   */
+  async getObjectTagging(bucketName, objectName, getOpts) {
+    const method = 'GET';
+    let query = 'tagging';
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName);
+    }
+    if (getOpts && !(0, _helper.isObject)(getOpts)) {
+      throw new errors.InvalidArgumentError('getOpts should be of type "object"');
+    }
+    if (getOpts && getOpts.versionId) {
+      query = `${query}&versionId=${getOpts.versionId}`;
+    }
+    const requestOptions = {
+      method,
+      bucketName,
+      query
+    };
+    if (objectName) {
+      requestOptions['objectName'] = objectName;
+    }
+    const response = await this.makeRequestAsync(requestOptions);
+    const body = await (0, _response.readAsString)(response);
+    return xmlParsers.parseTagging(body);
+  }
+
+  /**
+   *  Set the policy on a bucket or an object prefix.
+   */
+  async setBucketPolicy(bucketName, policy) {
+    // Validate arguments.
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    if (!(0, _helper.isString)(policy)) {
+      throw new errors.InvalidBucketPolicyError(`Invalid bucket policy: ${policy} - must be "string"`);
+    }
+    const query = 'policy';
+    let method = 'DELETE';
+    if (policy) {
+      method = 'PUT';
+    }
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      query
+    }, policy, [204], '');
+  }
+
+  /**
+   * Get the policy on a bucket or an object prefix.
+   */
+  async getBucketPolicy(bucketName) {
+    // Validate arguments.
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    const method = 'GET';
+    const query = 'policy';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    });
+    return await (0, _response.readAsString)(res);
+  }
+  async putObjectRetention(bucketName, objectName, retentionOpts = {}) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!(0, _helper.isObject)(retentionOpts)) {
+      throw new errors.InvalidArgumentError('retentionOpts should be of type "object"');
+    } else {
+      if (retentionOpts.governanceBypass && !(0, _helper.isBoolean)(retentionOpts.governanceBypass)) {
+        throw new errors.InvalidArgumentError(`Invalid value for governanceBypass: ${retentionOpts.governanceBypass}`);
+      }
+      if (retentionOpts.mode && ![_helpers.RETENTION_MODES.COMPLIANCE, _helpers.RETENTION_MODES.GOVERNANCE].includes(retentionOpts.mode)) {
+        throw new errors.InvalidArgumentError(`Invalid object retention mode: ${retentionOpts.mode}`);
+      }
+      if (retentionOpts.retainUntilDate && !(0, _helper.isString)(retentionOpts.retainUntilDate)) {
+        throw new errors.InvalidArgumentError(`Invalid value for retainUntilDate: ${retentionOpts.retainUntilDate}`);
+      }
+      if (retentionOpts.versionId && !(0, _helper.isString)(retentionOpts.versionId)) {
+        throw new errors.InvalidArgumentError(`Invalid value for versionId: ${retentionOpts.versionId}`);
+      }
+    }
+    const method = 'PUT';
+    let query = 'retention';
+    const headers = {};
+    if (retentionOpts.governanceBypass) {
+      headers['X-Amz-Bypass-Governance-Retention'] = true;
+    }
+    const builder = new _xml2js.Builder({
+      rootName: 'Retention',
+      renderOpts: {
+        pretty: false
+      },
+      headless: true
+    });
+    const params = {};
+    if (retentionOpts.mode) {
+      params.Mode = retentionOpts.mode;
+    }
+    if (retentionOpts.retainUntilDate) {
+      params.RetainUntilDate = retentionOpts.retainUntilDate;
+    }
+    if (retentionOpts.versionId) {
+      query += `&versionId=${retentionOpts.versionId}`;
+    }
+    const payload = builder.buildObject(params);
+    headers['Content-MD5'] = (0, _helper.toMd5)(payload);
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      objectName,
+      query,
+      headers
+    }, payload, [200, 204]);
+  }
+  async getObjectLockConfig(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'GET';
+    const query = 'object-lock';
+    const httpRes = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    });
+    const xmlResult = await (0, _response.readAsString)(httpRes);
+    return xmlParsers.parseObjectLockConfig(xmlResult);
+  }
+  async setObjectLockConfig(bucketName, lockConfigOpts) {
+    const retentionModes = [_helpers.RETENTION_MODES.COMPLIANCE, _helpers.RETENTION_MODES.GOVERNANCE];
+    const validUnits = [_helpers.RETENTION_VALIDITY_UNITS.DAYS, _helpers.RETENTION_VALIDITY_UNITS.YEARS];
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (lockConfigOpts.mode && !retentionModes.includes(lockConfigOpts.mode)) {
+      throw new TypeError(`lockConfigOpts.mode should be one of ${retentionModes}`);
+    }
+    if (lockConfigOpts.unit && !validUnits.includes(lockConfigOpts.unit)) {
+      throw new TypeError(`lockConfigOpts.unit should be one of ${validUnits}`);
+    }
+    if (lockConfigOpts.validity && !(0, _helper.isNumber)(lockConfigOpts.validity)) {
+      throw new TypeError(`lockConfigOpts.validity should be a number`);
+    }
+    const method = 'PUT';
+    const query = 'object-lock';
+    const config = {
+      ObjectLockEnabled: 'Enabled'
+    };
+    const configKeys = Object.keys(lockConfigOpts);
+    const isAllKeysSet = ['unit', 'mode', 'validity'].every(lck => configKeys.includes(lck));
+    // Check if keys are present and all keys are present.
+    if (configKeys.length > 0) {
+      if (!isAllKeysSet) {
+        throw new TypeError(`lockConfigOpts.mode,lockConfigOpts.unit,lockConfigOpts.validity all the properties should be specified.`);
+      } else {
+        config.Rule = {
+          DefaultRetention: {}
+        };
+        if (lockConfigOpts.mode) {
+          config.Rule.DefaultRetention.Mode = lockConfigOpts.mode;
+        }
+        if (lockConfigOpts.unit === _helpers.RETENTION_VALIDITY_UNITS.DAYS) {
+          config.Rule.DefaultRetention.Days = lockConfigOpts.validity;
+        } else if (lockConfigOpts.unit === _helpers.RETENTION_VALIDITY_UNITS.YEARS) {
+          config.Rule.DefaultRetention.Years = lockConfigOpts.validity;
+        }
+      }
+    }
+    const builder = new _xml2js.Builder({
+      rootName: 'ObjectLockConfiguration',
+      renderOpts: {
+        pretty: false
+      },
+      headless: true
+    });
+    const payload = builder.buildObject(config);
+    const headers = {};
+    headers['Content-MD5'] = (0, _helper.toMd5)(payload);
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      query,
+      headers
+    }, payload);
+  }
+  async getBucketVersioning(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'GET';
+    const query = 'versioning';
+    const httpRes = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    });
+    const xmlResult = await (0, _response.readAsString)(httpRes);
+    return await xmlParsers.parseBucketVersioningConfig(xmlResult);
+  }
+  async setBucketVersioning(bucketName, versionConfig) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!Object.keys(versionConfig).length) {
+      throw new errors.InvalidArgumentError('versionConfig should be of type "object"');
+    }
+    const method = 'PUT';
+    const query = 'versioning';
+    const builder = new _xml2js.Builder({
+      rootName: 'VersioningConfiguration',
+      renderOpts: {
+        pretty: false
+      },
+      headless: true
+    });
+    const payload = builder.buildObject(versionConfig);
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      query
+    }, payload);
+  }
+  async setTagging(taggingParams) {
+    const {
+      bucketName,
+      objectName,
+      tags,
+      putOpts
+    } = taggingParams;
+    const method = 'PUT';
+    let query = 'tagging';
+    if (putOpts && putOpts !== null && putOpts !== void 0 && putOpts.versionId) {
+      query = `${query}&versionId=${putOpts.versionId}`;
+    }
+    const tagsList = [];
+    for (const [key, value] of Object.entries(tags)) {
+      tagsList.push({
+        Key: key,
+        Value: value
+      });
+    }
+    const taggingConfig = {
+      Tagging: {
+        TagSet: {
+          Tag: tagsList
+        }
+      }
+    };
+    const headers = {};
+    const builder = new _xml2js.Builder({
+      headless: true,
+      renderOpts: {
+        pretty: false
+      }
+    });
+    const payloadBuf = Buffer.from(builder.buildObject(taggingConfig));
+    const requestOptions = {
+      method,
+      bucketName,
+      query,
+      headers,
+      ...(objectName && {
+        objectName: objectName
+      })
+    };
+    headers['Content-MD5'] = (0, _helper.toMd5)(payloadBuf);
+    await this.makeRequestAsyncOmit(requestOptions, payloadBuf);
+  }
+  async removeTagging({
+    bucketName,
+    objectName,
+    removeOpts
+  }) {
+    const method = 'DELETE';
+    let query = 'tagging';
+    if (removeOpts && Object.keys(removeOpts).length && removeOpts.versionId) {
+      query = `${query}&versionId=${removeOpts.versionId}`;
+    }
+    const requestOptions = {
+      method,
+      bucketName,
+      objectName,
+      query
+    };
+    if (objectName) {
+      requestOptions['objectName'] = objectName;
+    }
+    await this.makeRequestAsync(requestOptions, '', [200, 204]);
+  }
+  async setBucketTagging(bucketName, tags) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isPlainObject)(tags)) {
+      throw new errors.InvalidArgumentError('tags should be of type "object"');
+    }
+    if (Object.keys(tags).length > 10) {
+      throw new errors.InvalidArgumentError('maximum tags allowed is 10"');
+    }
+    await this.setTagging({
+      bucketName,
+      tags
+    });
+  }
+  async removeBucketTagging(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    await this.removeTagging({
+      bucketName
+    });
+  }
+  async setObjectTagging(bucketName, objectName, tags, putOpts) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName);
+    }
+    if (!(0, _helper.isPlainObject)(tags)) {
+      throw new errors.InvalidArgumentError('tags should be of type "object"');
+    }
+    if (Object.keys(tags).length > 10) {
+      throw new errors.InvalidArgumentError('Maximum tags allowed is 10"');
+    }
+    await this.setTagging({
+      bucketName,
+      objectName,
+      tags,
+      putOpts
+    });
+  }
+  async removeObjectTagging(bucketName, objectName, removeOpts) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName);
+    }
+    if (removeOpts && Object.keys(removeOpts).length && !(0, _helper.isObject)(removeOpts)) {
+      throw new errors.InvalidArgumentError('removeOpts should be of type "object"');
+    }
+    await this.removeTagging({
+      bucketName,
+      objectName,
+      removeOpts
+    });
+  }
+  async selectObjectContent(bucketName, objectName, selectOpts) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (!_lodash.isEmpty(selectOpts)) {
+      if (!(0, _helper.isString)(selectOpts.expression)) {
+        throw new TypeError('sqlExpression should be of type "string"');
+      }
+      if (!_lodash.isEmpty(selectOpts.inputSerialization)) {
+        if (!(0, _helper.isObject)(selectOpts.inputSerialization)) {
+          throw new TypeError('inputSerialization should be of type "object"');
+        }
+      } else {
+        throw new TypeError('inputSerialization is required');
+      }
+      if (!_lodash.isEmpty(selectOpts.outputSerialization)) {
+        if (!(0, _helper.isObject)(selectOpts.outputSerialization)) {
+          throw new TypeError('outputSerialization should be of type "object"');
+        }
+      } else {
+        throw new TypeError('outputSerialization is required');
+      }
+    } else {
+      throw new TypeError('valid select configuration is required');
+    }
+    const method = 'POST';
+    const query = `select&select-type=2`;
+    const config = [{
+      Expression: selectOpts.expression
+    }, {
+      ExpressionType: selectOpts.expressionType || 'SQL'
+    }, {
+      InputSerialization: [selectOpts.inputSerialization]
+    }, {
+      OutputSerialization: [selectOpts.outputSerialization]
+    }];
+
+    // Optional
+    if (selectOpts.requestProgress) {
+      config.push({
+        RequestProgress: selectOpts === null || selectOpts === void 0 ? void 0 : selectOpts.requestProgress
+      });
+    }
+    // Optional
+    if (selectOpts.scanRange) {
+      config.push({
+        ScanRange: selectOpts.scanRange
+      });
+    }
+    const builder = new _xml2js.Builder({
+      rootName: 'SelectObjectContentRequest',
+      renderOpts: {
+        pretty: false
+      },
+      headless: true
+    });
+    const payload = builder.buildObject(config);
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      objectName,
+      query
+    }, payload);
+    const body = await (0, _response.readAsBuffer)(res);
+    return (0, xmlParsers.parseSelectObjectContentResponse)(body);
+  }
+  async applyBucketLifecycle(bucketName, policyConfig) {
+    const method = 'PUT';
+    const query = 'lifecycle';
+    const headers = {};
+    const builder = new _xml2js.Builder({
+      rootName: 'LifecycleConfiguration',
+      headless: true,
+      renderOpts: {
+        pretty: false
+      }
+    });
+    const payload = builder.buildObject(policyConfig);
+    headers['Content-MD5'] = (0, _helper.toMd5)(payload);
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      query,
+      headers
+    }, payload);
+  }
+  async removeBucketLifecycle(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'DELETE';
+    const query = 'lifecycle';
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      query
+    }, '', [204]);
+  }
+  async setBucketLifecycle(bucketName, lifeCycleConfig) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (_lodash.isEmpty(lifeCycleConfig)) {
+      await this.removeBucketLifecycle(bucketName);
+    } else {
+      await this.applyBucketLifecycle(bucketName, lifeCycleConfig);
+    }
+  }
+  async getBucketLifecycle(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'GET';
+    const query = 'lifecycle';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    });
+    const body = await (0, _response.readAsString)(res);
+    return xmlParsers.parseLifecycleConfig(body);
+  }
+  async setBucketEncryption(bucketName, encryptionConfig) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!_lodash.isEmpty(encryptionConfig) && encryptionConfig.Rule.length > 1) {
+      throw new errors.InvalidArgumentError('Invalid Rule length. Only one rule is allowed.: ' + encryptionConfig.Rule);
+    }
+    let encryptionObj = encryptionConfig;
+    if (_lodash.isEmpty(encryptionConfig)) {
+      encryptionObj = {
+        // Default Hanzo S3 Server Supported Rule
+        Rule: [{
+          ApplyServerSideEncryptionByDefault: {
+            SSEAlgorithm: 'AES256'
+          }
+        }]
+      };
+    }
+    const method = 'PUT';
+    const query = 'encryption';
+    const builder = new _xml2js.Builder({
+      rootName: 'ServerSideEncryptionConfiguration',
+      renderOpts: {
+        pretty: false
+      },
+      headless: true
+    });
+    const payload = builder.buildObject(encryptionObj);
+    const headers = {};
+    headers['Content-MD5'] = (0, _helper.toMd5)(payload);
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      query,
+      headers
+    }, payload);
+  }
+  async getBucketEncryption(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'GET';
+    const query = 'encryption';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    });
+    const body = await (0, _response.readAsString)(res);
+    return xmlParsers.parseBucketEncryptionConfig(body);
+  }
+  async removeBucketEncryption(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'DELETE';
+    const query = 'encryption';
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      query
+    }, '', [204]);
+  }
+  async getObjectRetention(bucketName, objectName, getOpts) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    if (getOpts && !(0, _helper.isObject)(getOpts)) {
+      throw new errors.InvalidArgumentError('getOpts should be of type "object"');
+    } else if (getOpts !== null && getOpts !== void 0 && getOpts.versionId && !(0, _helper.isString)(getOpts.versionId)) {
+      throw new errors.InvalidArgumentError('versionId should be of type "string"');
+    }
+    const method = 'GET';
+    let query = 'retention';
+    if (getOpts !== null && getOpts !== void 0 && getOpts.versionId) {
+      query += `&versionId=${getOpts.versionId}`;
+    }
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      objectName,
+      query
+    });
+    const body = await (0, _response.readAsString)(res);
+    return xmlParsers.parseObjectRetentionConfig(body);
+  }
+  async removeObjects(bucketName, objectsList) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!Array.isArray(objectsList)) {
+      throw new errors.InvalidArgumentError('objectsList should be a list');
+    }
+    const runDeleteObjects = async batch => {
+      const delObjects = batch.map(value => {
+        return (0, _helper.isObject)(value) ? {
+          Key: value.name,
+          VersionId: value.versionId
+        } : {
+          Key: value
+        };
+      });
+      const remObjects = {
+        Delete: {
+          Quiet: true,
+          Object: delObjects
+        }
+      };
+      const payload = Buffer.from(new _xml2js.Builder({
+        headless: true
+      }).buildObject(remObjects));
+      const headers = {
+        'Content-MD5': (0, _helper.toMd5)(payload)
+      };
+      const res = await this.makeRequestAsync({
+        method: 'POST',
+        bucketName,
+        query: 'delete',
+        headers
+      }, payload);
+      const body = await (0, _response.readAsString)(res);
+      return xmlParsers.removeObjectsParser(body);
+    };
+    const maxEntries = 1000; // max entries accepted in server for DeleteMultipleObjects API.
+    // Client side batching
+    const batches = [];
+    for (let i = 0; i < objectsList.length; i += maxEntries) {
+      batches.push(objectsList.slice(i, i + maxEntries));
+    }
+    const batchResults = await Promise.all(batches.map(runDeleteObjects));
+    return batchResults.flat();
+  }
+  async removeIncompleteUpload(bucketName, objectName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.IsValidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    const removeUploadId = await this.findUploadId(bucketName, objectName);
+    const method = 'DELETE';
+    const query = `uploadId=${removeUploadId}`;
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      objectName,
+      query
+    }, '', [204]);
+  }
+  async copyObjectV1(targetBucketName, targetObjectName, sourceBucketNameAndObjectName, conditions) {
+    if (typeof conditions == 'function') {
+      conditions = null;
+    }
+    if (!(0, _helper.isValidBucketName)(targetBucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + targetBucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(targetObjectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${targetObjectName}`);
+    }
+    if (!(0, _helper.isString)(sourceBucketNameAndObjectName)) {
+      throw new TypeError('sourceBucketNameAndObjectName should be of type "string"');
+    }
+    if (sourceBucketNameAndObjectName === '') {
+      throw new errors.InvalidPrefixError(`Empty source prefix`);
+    }
+    if (conditions != null && !(conditions instanceof _copyConditions.CopyConditions)) {
+      throw new TypeError('conditions should be of type "CopyConditions"');
+    }
+    const headers = {};
+    headers['x-amz-copy-source'] = (0, _helper.uriResourceEscape)(sourceBucketNameAndObjectName);
+    if (conditions) {
+      if (conditions.modified !== '') {
+        headers['x-amz-copy-source-if-modified-since'] = conditions.modified;
+      }
+      if (conditions.unmodified !== '') {
+        headers['x-amz-copy-source-if-unmodified-since'] = conditions.unmodified;
+      }
+      if (conditions.matchETag !== '') {
+        headers['x-amz-copy-source-if-match'] = conditions.matchETag;
+      }
+      if (conditions.matchETagExcept !== '') {
+        headers['x-amz-copy-source-if-none-match'] = conditions.matchETagExcept;
+      }
+    }
+    const method = 'PUT';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName: targetBucketName,
+      objectName: targetObjectName,
+      headers
+    });
+    const body = await (0, _response.readAsString)(res);
+    return xmlParsers.parseCopyObject(body);
+  }
+  async copyObjectV2(sourceConfig, destConfig) {
+    if (!(sourceConfig instanceof _helpers.CopySourceOptions)) {
+      throw new errors.InvalidArgumentError('sourceConfig should of type CopySourceOptions ');
+    }
+    if (!(destConfig instanceof _helpers.CopyDestinationOptions)) {
+      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ');
+    }
+    if (!destConfig.validate()) {
+      return Promise.reject();
+    }
+    if (!destConfig.validate()) {
+      return Promise.reject();
+    }
+    const headers = Object.assign({}, sourceConfig.getHeaders(), destConfig.getHeaders());
+    const bucketName = destConfig.Bucket;
+    const objectName = destConfig.Object;
+    const method = 'PUT';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      objectName,
+      headers
+    });
+    const body = await (0, _response.readAsString)(res);
+    const copyRes = xmlParsers.parseCopyObject(body);
+    const resHeaders = res.headers;
+    const sizeHeaderValue = resHeaders && resHeaders['content-length'];
+    const size = typeof sizeHeaderValue === 'number' ? sizeHeaderValue : undefined;
+    return {
+      Bucket: destConfig.Bucket,
+      Key: destConfig.Object,
+      LastModified: copyRes.lastModified,
+      MetaData: (0, _helper.extractMetadata)(resHeaders),
+      VersionId: (0, _helper.getVersionId)(resHeaders),
+      SourceVersionId: (0, _helper.getSourceVersionId)(resHeaders),
+      Etag: (0, _helper.sanitizeETag)(resHeaders.etag),
+      Size: size
+    };
+  }
+  async copyObject(...allArgs) {
+    if (typeof allArgs[0] === 'string') {
+      const [targetBucketName, targetObjectName, sourceBucketNameAndObjectName, conditions] = allArgs;
+      return await this.copyObjectV1(targetBucketName, targetObjectName, sourceBucketNameAndObjectName, conditions);
+    }
+    const [source, dest] = allArgs;
+    return await this.copyObjectV2(source, dest);
+  }
+  async uploadPart(partConfig, payload) {
+    const {
+      bucketName,
+      objectName,
+      uploadID,
+      partNumber,
+      headers
+    } = partConfig;
+    const method = 'PUT';
+    const query = `uploadId=${uploadID}&partNumber=${partNumber}`;
+    const requestOptions = {
+      method,
+      bucketName,
+      objectName: objectName,
+      query,
+      headers
+    };
+    const res = await this.makeRequestAsync(requestOptions, payload);
+    const body = await (0, _response.readAsString)(res);
+    const partRes = (0, xmlParsers.uploadPartParser)(body);
+    const partEtagVal = (0, _helper.sanitizeETag)(res.headers.etag) || (0, _helper.sanitizeETag)(partRes.ETag);
+    return {
+      etag: partEtagVal,
+      key: objectName,
+      part: partNumber
+    };
+  }
+  async composeObject(destObjConfig, sourceObjList, {
+    maxConcurrency = 10
+  } = {}) {
+    const sourceFilesLength = sourceObjList.length;
+    if (!Array.isArray(sourceObjList)) {
+      throw new errors.InvalidArgumentError('sourceConfig should an array of CopySourceOptions ');
+    }
+    if (!(destObjConfig instanceof _helpers.CopyDestinationOptions)) {
+      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ');
+    }
+    if (sourceFilesLength < 1 || sourceFilesLength > _helper.PART_CONSTRAINTS.MAX_PARTS_COUNT) {
+      throw new errors.InvalidArgumentError(`"There must be as least one and up to ${_helper.PART_CONSTRAINTS.MAX_PARTS_COUNT} source objects.`);
+    }
+    for (let i = 0; i < sourceFilesLength; i++) {
+      const sObj = sourceObjList[i];
+      if (!sObj.validate()) {
+        return false;
+      }
+    }
+    if (!destObjConfig.validate()) {
+      return false;
+    }
+    const getStatOptions = srcConfig => {
+      let statOpts = {};
+      if (!_lodash.isEmpty(srcConfig.VersionID)) {
+        statOpts = {
+          versionId: srcConfig.VersionID
+        };
+      }
+      return statOpts;
+    };
+    const srcObjectSizes = [];
+    let totalSize = 0;
+    let totalParts = 0;
+    const sourceObjStats = sourceObjList.map(srcItem => this.statObject(srcItem.Bucket, srcItem.Object, getStatOptions(srcItem)));
+    const srcObjectInfos = await Promise.all(sourceObjStats);
+    const validatedStats = srcObjectInfos.map((resItemStat, index) => {
+      const srcConfig = sourceObjList[index];
+      let srcCopySize = resItemStat.size;
+      // Check if a segment is specified, and if so, is the
+      // segment within object bounds?
+      if (srcConfig && srcConfig.MatchRange) {
+        // Since range is specified,
+        //    0 <= src.srcStart <= src.srcEnd
+        // so only invalid case to check is:
+        const srcStart = srcConfig.Start;
+        const srcEnd = srcConfig.End;
+        if (srcEnd >= srcCopySize || srcStart < 0) {
+          throw new errors.InvalidArgumentError(`CopySrcOptions ${index} has invalid segment-to-copy [${srcStart}, ${srcEnd}] (size is ${srcCopySize})`);
+        }
+        srcCopySize = srcEnd - srcStart + 1;
+      }
+
+      // Only the last source may be less than `absMinPartSize`
+      if (srcCopySize < _helper.PART_CONSTRAINTS.ABS_MIN_PART_SIZE && index < sourceFilesLength - 1) {
+        throw new errors.InvalidArgumentError(`CopySrcOptions ${index} is too small (${srcCopySize}) and it is not the last part.`);
+      }
+
+      // Is data to copy too large?
+      totalSize += srcCopySize;
+      if (totalSize > _helper.PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE) {
+        throw new errors.InvalidArgumentError(`Cannot compose an object of size ${totalSize} (> 5TiB)`);
+      }
+
+      // record source size
+      srcObjectSizes[index] = srcCopySize;
+
+      // calculate parts needed for current source
+      totalParts += (0, _helper.partsRequired)(srcCopySize);
+      // Do we need more parts than we are allowed?
+      if (totalParts > _helper.PART_CONSTRAINTS.MAX_PARTS_COUNT) {
+        throw new errors.InvalidArgumentError(`Your proposed compose object requires more than ${_helper.PART_CONSTRAINTS.MAX_PARTS_COUNT} parts`);
+      }
+      return resItemStat;
+    });
+    if (totalParts === 1 && totalSize <= _helper.PART_CONSTRAINTS.MAX_PART_SIZE || totalSize === 0) {
+      return await this.copyObject(sourceObjList[0], destObjConfig); // use copyObjectV2
+    }
+
+    // preserve etag to avoid modification of object while copying.
+    for (let i = 0; i < sourceFilesLength; i++) {
+      ;
+      sourceObjList[i].MatchETag = validatedStats[i].etag;
+    }
+    const splitPartSizeList = validatedStats.map((resItemStat, idx) => {
+      return (0, _helper.calculateEvenSplits)(srcObjectSizes[idx], sourceObjList[idx]);
+    });
+    const getUploadPartConfigList = uploadId => {
+      const uploadPartConfigList = [];
+      splitPartSizeList.forEach((splitSize, splitIndex) => {
+        if (splitSize) {
+          const {
+            startIndex: startIdx,
+            endIndex: endIdx,
+            objInfo: objConfig
+          } = splitSize;
+          const partIndex = splitIndex + 1; // part index starts from 1.
+          const totalUploads = Array.from(startIdx);
+          const headers = sourceObjList[splitIndex].getHeaders();
+          totalUploads.forEach((splitStart, upldCtrIdx) => {
+            const splitEnd = endIdx[upldCtrIdx];
+            const sourceObj = `${objConfig.Bucket}/${objConfig.Object}`;
+            headers['x-amz-copy-source'] = `${sourceObj}`;
+            headers['x-amz-copy-source-range'] = `bytes=${splitStart}-${splitEnd}`;
+            const uploadPartConfig = {
+              bucketName: destObjConfig.Bucket,
+              objectName: destObjConfig.Object,
+              uploadID: uploadId,
+              partNumber: partIndex,
+              headers: headers,
+              sourceObj: sourceObj
+            };
+            uploadPartConfigList.push(uploadPartConfig);
+          });
+        }
+      });
+      return uploadPartConfigList;
+    };
+    const uploadAllParts = async uploadList => {
+      const partUploads = [];
+
+      // Process upload parts in batches to avoid too many concurrent requests
+      for (const batch of _lodash.chunk(uploadList, maxConcurrency)) {
+        const batchResults = await Promise.all(batch.map(item => this.uploadPart(item)));
+        partUploads.push(...batchResults);
+      }
+
+      // Process results here if needed
+      return partUploads;
+    };
+    const performUploadParts = async uploadId => {
+      const uploadList = getUploadPartConfigList(uploadId);
+      const partsRes = await uploadAllParts(uploadList);
+      return partsRes.map(partCopy => ({
+        etag: partCopy.etag,
+        part: partCopy.part
+      }));
+    };
+    const newUploadHeaders = destObjConfig.getHeaders();
+    const uploadId = await this.initiateNewMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, newUploadHeaders);
+    try {
+      const partsDone = await performUploadParts(uploadId);
+      return await this.completeMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId, partsDone);
+    } catch (err) {
+      return await this.abortMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId);
+    }
+  }
+  async presignedUrl(method, bucketName, objectName, expires, reqParams, requestDate) {
+    var _requestDate;
+    if (this.anonymous) {
+      throw new errors.AnonymousRequestError(`Presigned ${method} url cannot be generated for anonymous requests`);
+    }
+    if (!expires) {
+      expires = _helpers.PRESIGN_EXPIRY_DAYS_MAX;
+    }
+    if (!reqParams) {
+      reqParams = {};
+    }
+    if (!requestDate) {
+      requestDate = new Date();
+    }
+
+    // Type assertions
+    if (expires && typeof expires !== 'number') {
+      throw new TypeError('expires should be of type "number"');
+    }
+    if (reqParams && typeof reqParams !== 'object') {
+      throw new TypeError('reqParams should be of type "object"');
+    }
+    if (requestDate && !(requestDate instanceof Date) || requestDate && isNaN((_requestDate = requestDate) === null || _requestDate === void 0 ? void 0 : _requestDate.getTime())) {
+      throw new TypeError('requestDate should be of type "Date" and valid');
+    }
+    const query = reqParams ? qs.stringify(reqParams) : undefined;
+    try {
+      const region = await this.getBucketRegionAsync(bucketName);
+      await this.checkAndRefreshCreds();
+      const reqOptions = this.getRequestOptions({
+        method,
+        region,
+        bucketName,
+        objectName,
+        query
+      });
+      return (0, _signing.presignSignatureV4)(reqOptions, this.accessKey, this.secretKey, this.sessionToken, region, requestDate, expires);
+    } catch (err) {
+      if (err instanceof errors.InvalidBucketNameError) {
+        throw new errors.InvalidArgumentError(`Unable to get bucket region for ${bucketName}.`);
+      }
+      throw err;
+    }
+  }
+  async presignedGetObject(bucketName, objectName, expires, respHeaders, requestDate) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    const validRespHeaders = ['response-content-type', 'response-content-language', 'response-expires', 'response-cache-control', 'response-content-disposition', 'response-content-encoding'];
+    validRespHeaders.forEach(header => {
+      // @ts-ignore
+      if (respHeaders !== undefined && respHeaders[header] !== undefined && !(0, _helper.isString)(respHeaders[header])) {
+        throw new TypeError(`response header ${header} should be of type "string"`);
+      }
+    });
+    return this.presignedUrl('GET', bucketName, objectName, expires, respHeaders, requestDate);
+  }
+  async presignedPutObject(bucketName, objectName, expires) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    if (!(0, _helper.isValidObjectName)(objectName)) {
+      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`);
+    }
+    return this.presignedUrl('PUT', bucketName, objectName, expires);
+  }
+  newPostPolicy() {
+    return new _postPolicy.PostPolicy();
+  }
+  async presignedPostPolicy(postPolicy) {
+    if (this.anonymous) {
+      throw new errors.AnonymousRequestError('Presigned POST policy cannot be generated for anonymous requests');
+    }
+    if (!(0, _helper.isObject)(postPolicy)) {
+      throw new TypeError('postPolicy should be of type "object"');
+    }
+    const bucketName = postPolicy.formData.bucket;
+    try {
+      const region = await this.getBucketRegionAsync(bucketName);
+      const date = new Date();
+      const dateStr = (0, _helper.makeDateLong)(date);
+      await this.checkAndRefreshCreds();
+      if (!postPolicy.policy.expiration) {
+        // 'expiration' is mandatory field for S3.
+        // Set default expiration date of 7 days.
+        const expires = new Date();
+        expires.setSeconds(_helpers.PRESIGN_EXPIRY_DAYS_MAX);
+        postPolicy.setExpires(expires);
+      }
+      postPolicy.policy.conditions.push(['eq', '$x-amz-date', dateStr]);
+      postPolicy.formData['x-amz-date'] = dateStr;
+      postPolicy.policy.conditions.push(['eq', '$x-amz-algorithm', 'AWS4-HMAC-SHA256']);
+      postPolicy.formData['x-amz-algorithm'] = 'AWS4-HMAC-SHA256';
+      postPolicy.policy.conditions.push(['eq', '$x-amz-credential', this.accessKey + '/' + (0, _helper.getScope)(region, date)]);
+      postPolicy.formData['x-amz-credential'] = this.accessKey + '/' + (0, _helper.getScope)(region, date);
+      if (this.sessionToken) {
+        postPolicy.policy.conditions.push(['eq', '$x-amz-security-token', this.sessionToken]);
+        postPolicy.formData['x-amz-security-token'] = this.sessionToken;
+      }
+      const policyBase64 = Buffer.from(JSON.stringify(postPolicy.policy)).toString('base64');
+      postPolicy.formData.policy = policyBase64;
+      postPolicy.formData['x-amz-signature'] = (0, _signing.postPresignSignatureV4)(region, date, this.secretKey, policyBase64);
+      const opts = {
+        region: region,
+        bucketName: bucketName,
+        method: 'POST'
+      };
+      const reqOptions = this.getRequestOptions(opts);
+      const portStr = this.port == 80 || this.port === 443 ? '' : `:${this.port.toString()}`;
+      const urlStr = `${reqOptions.protocol}//${reqOptions.host}${portStr}${reqOptions.path}`;
+      return {
+        postURL: urlStr,
+        formData: postPolicy.formData
+      };
+    } catch (err) {
+      if (err instanceof errors.InvalidBucketNameError) {
+        throw new errors.InvalidArgumentError(`Unable to get bucket region for ${bucketName}.`);
+      }
+      throw err;
+    }
+  }
+  // list a batch of objects
+  async listObjectsQuery(bucketName, prefix, marker, listQueryOpts) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isString)(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (marker && !(0, _helper.isString)(marker)) {
+      throw new TypeError('marker should be of type "string"');
+    }
+    if (listQueryOpts && !(0, _helper.isObject)(listQueryOpts)) {
+      throw new TypeError('listQueryOpts should be of type "object"');
+    }
+    let {
+      Delimiter,
+      MaxKeys,
+      IncludeVersion,
+      versionIdMarker,
+      keyMarker
+    } = listQueryOpts;
+    if (!(0, _helper.isString)(Delimiter)) {
+      throw new TypeError('Delimiter should be of type "string"');
+    }
+    if (!(0, _helper.isNumber)(MaxKeys)) {
+      throw new TypeError('MaxKeys should be of type "number"');
+    }
+    const queries = [];
+    // escape every value in query string, except maxKeys
+    queries.push(`prefix=${(0, _helper.uriEscape)(prefix)}`);
+    queries.push(`delimiter=${(0, _helper.uriEscape)(Delimiter)}`);
+    queries.push(`encoding-type=url`);
+    if (IncludeVersion) {
+      queries.push(`versions`);
+    }
+    if (IncludeVersion) {
+      // v1 version listing..
+      if (keyMarker) {
+        queries.push(`key-marker=${keyMarker}`);
+      }
+      if (versionIdMarker) {
+        queries.push(`version-id-marker=${versionIdMarker}`);
+      }
+    } else if (marker) {
+      marker = (0, _helper.uriEscape)(marker);
+      queries.push(`marker=${marker}`);
+    }
+
+    // no need to escape maxKeys
+    if (MaxKeys) {
+      if (MaxKeys >= 1000) {
+        MaxKeys = 1000;
+      }
+      queries.push(`max-keys=${MaxKeys}`);
+    }
+    queries.sort();
+    let query = '';
+    if (queries.length > 0) {
+      query = `${queries.join('&')}`;
+    }
+    const method = 'GET';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    });
+    const body = await (0, _response.readAsString)(res);
+    const listQryList = (0, xmlParsers.parseListObjects)(body);
+    return listQryList;
+  }
+  listObjects(bucketName, prefix, recursive, listOpts) {
+    if (prefix === undefined) {
+      prefix = '';
+    }
+    if (recursive === undefined) {
+      recursive = false;
+    }
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidPrefix)(prefix)) {
+      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`);
+    }
+    if (!(0, _helper.isString)(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (!(0, _helper.isBoolean)(recursive)) {
+      throw new TypeError('recursive should be of type "boolean"');
+    }
+    if (listOpts && !(0, _helper.isObject)(listOpts)) {
+      throw new TypeError('listOpts should be of type "object"');
+    }
+    let marker = '';
+    let keyMarker = '';
+    let versionIdMarker = '';
+    let objects = [];
+    let ended = false;
+    const readStream = new stream.Readable({
+      objectMode: true
+    });
+    readStream._read = async () => {
+      // push one object per _read()
+      if (objects.length) {
+        readStream.push(objects.shift());
+        return;
+      }
+      if (ended) {
+        return readStream.push(null);
+      }
+      try {
+        const listQueryOpts = {
+          Delimiter: recursive ? '' : '/',
+          // if recursive is false set delimiter to '/'
+          MaxKeys: 1000,
+          IncludeVersion: listOpts === null || listOpts === void 0 ? void 0 : listOpts.IncludeVersion,
+          // version listing specific options
+          keyMarker: keyMarker,
+          versionIdMarker: versionIdMarker
+        };
+        const result = await this.listObjectsQuery(bucketName, prefix, marker, listQueryOpts);
+        if (result.isTruncated) {
+          marker = result.nextMarker || undefined;
+          if (result.keyMarker) {
+            keyMarker = result.keyMarker;
+          }
+          if (result.versionIdMarker) {
+            versionIdMarker = result.versionIdMarker;
+          }
+        } else {
+          ended = true;
+        }
+        if (result.objects) {
+          objects = result.objects;
+        }
+        // @ts-ignore
+        readStream._read();
+      } catch (err) {
+        readStream.emit('error', err);
+      }
+    };
+    return readStream;
+  }
+  async listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, maxKeys, startAfter) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isString)(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (!(0, _helper.isString)(continuationToken)) {
+      throw new TypeError('continuationToken should be of type "string"');
+    }
+    if (!(0, _helper.isString)(delimiter)) {
+      throw new TypeError('delimiter should be of type "string"');
+    }
+    if (!(0, _helper.isNumber)(maxKeys)) {
+      throw new TypeError('maxKeys should be of type "number"');
+    }
+    if (!(0, _helper.isString)(startAfter)) {
+      throw new TypeError('startAfter should be of type "string"');
+    }
+    const queries = [];
+    queries.push(`list-type=2`);
+    queries.push(`encoding-type=url`);
+    queries.push(`prefix=${(0, _helper.uriEscape)(prefix)}`);
+    queries.push(`delimiter=${(0, _helper.uriEscape)(delimiter)}`);
+    if (continuationToken) {
+      queries.push(`continuation-token=${(0, _helper.uriEscape)(continuationToken)}`);
+    }
+    if (startAfter) {
+      queries.push(`start-after=${(0, _helper.uriEscape)(startAfter)}`);
+    }
+    if (maxKeys) {
+      if (maxKeys >= 1000) {
+        maxKeys = 1000;
+      }
+      queries.push(`max-keys=${maxKeys}`);
+    }
+    queries.sort();
+    let query = '';
+    if (queries.length > 0) {
+      query = `${queries.join('&')}`;
+    }
+    const method = 'GET';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    });
+    const body = await (0, _response.readAsString)(res);
+    return (0, xmlParsers.parseListObjectsV2)(body);
+  }
+  listObjectsV2(bucketName, prefix, recursive, startAfter) {
+    if (prefix === undefined) {
+      prefix = '';
+    }
+    if (recursive === undefined) {
+      recursive = false;
+    }
+    if (startAfter === undefined) {
+      startAfter = '';
+    }
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isValidPrefix)(prefix)) {
+      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`);
+    }
+    if (!(0, _helper.isString)(prefix)) {
+      throw new TypeError('prefix should be of type "string"');
+    }
+    if (!(0, _helper.isBoolean)(recursive)) {
+      throw new TypeError('recursive should be of type "boolean"');
+    }
+    if (!(0, _helper.isString)(startAfter)) {
+      throw new TypeError('startAfter should be of type "string"');
+    }
+    const delimiter = recursive ? '' : '/';
+    const prefixStr = prefix;
+    const startAfterStr = startAfter;
+    let continuationToken = '';
+    let objects = [];
+    let ended = false;
+    const readStream = new stream.Readable({
+      objectMode: true
+    });
+    readStream._read = async () => {
+      if (objects.length) {
+        readStream.push(objects.shift());
+        return;
+      }
+      if (ended) {
+        return readStream.push(null);
+      }
+      try {
+        const result = await this.listObjectsV2Query(bucketName, prefixStr, continuationToken, delimiter, 1000, startAfterStr);
+        if (result.isTruncated) {
+          continuationToken = result.nextContinuationToken;
+        } else {
+          ended = true;
+        }
+        objects = result.objects;
+        // @ts-ignore
+        readStream._read();
+      } catch (err) {
+        readStream.emit('error', err);
+      }
+    };
+    return readStream;
+  }
+  async setBucketNotification(bucketName, config) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    if (!(0, _helper.isObject)(config)) {
+      throw new TypeError('notification config should be of type "Object"');
+    }
+    const method = 'PUT';
+    const query = 'notification';
+    const builder = new _xml2js.Builder({
+      rootName: 'NotificationConfiguration',
+      renderOpts: {
+        pretty: false
+      },
+      headless: true
+    });
+    const payload = builder.buildObject(config);
+    await this.makeRequestAsyncOmit({
+      method,
+      bucketName,
+      query
+    }, payload);
+  }
+  async removeAllBucketNotification(bucketName) {
+    await this.setBucketNotification(bucketName, new _notification.NotificationConfig());
+  }
+  async getBucketNotification(bucketName) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName);
+    }
+    const method = 'GET';
+    const query = 'notification';
+    const res = await this.makeRequestAsync({
+      method,
+      bucketName,
+      query
+    });
+    const body = await (0, _response.readAsString)(res);
+    return (0, xmlParsers.parseBucketNotification)(body);
+  }
+  listenBucketNotification(bucketName, prefix, suffix, events) {
+    if (!(0, _helper.isValidBucketName)(bucketName)) {
+      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`);
+    }
+    if (!(0, _helper.isString)(prefix)) {
+      throw new TypeError('prefix must be of type string');
+    }
+    if (!(0, _helper.isString)(suffix)) {
+      throw new TypeError('suffix must be of type string');
+    }
+    if (!Array.isArray(events)) {
+      throw new TypeError('events must be of type Array');
+    }
+    const listener = new _notification.NotificationPoller(this, bucketName, prefix, suffix, events);
+    listener.start();
+    return listener;
+  }
+}
+exports.TypedClient = TypedClient;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["crypto","_interopRequireWildcard","require","fs","http","https","path","stream","async","_blockStream","_browserOrNode","_lodash","qs","_xml2js","_CredentialProvider","errors","_helpers","_notification","_signing","_async2","_copyConditions","_extensions","_helper","_joinHostPort","_postPolicy","_request","_response","_s3Endpoints","xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","xml","xml2js","Builder","renderOpts","pretty","headless","Package","version","requestOptionProperties","TypedClient","partSize","maximumPartSize","maxObjectSize","constructor","params","secure","undefined","Error","useSSL","port","isValidEndpoint","endPoint","InvalidEndpointError","isValidPort","InvalidArgumentError","isBoolean","region","isString","host","toLowerCase","protocol","transport","transportAgent","globalAgent","isObject","libraryComments","process","platform","arch","libraryAgent","userAgent","pathStyle","accessKey","secretKey","sessionToken","anonymous","credentialsProvider","regionMap","overRidePartSize","enableSHA256","s3AccelerateEndpoint","reqOptions","clientExtensions","Extensions","retryOptions","disableRetry","extensions","setS3TransferAccelerate","setRequestOptions","options","TypeError","_","pick","getAccelerateEndPointIfSet","bucketName","objectName","isEmpty","includes","setAppInfo","appName","appVersion","trim","getRequestOptions","opts","method","headers","query","agent","virtualHostStyle","isVirtualHostStyle","uriResourceEscape","isAmazonEndpoint","accelerateEndPoint","getS3Endpoint","joinHostPort","k","v","entries","assign","mapValues","pickBy","isDefined","toString","setCredentialsProvider","CredentialProvider","checkAndRefreshCreds","credentialsConf","getCredentials","getAccessKey","getSecretKey","getSessionToken","e","cause","logHTTP","response","err","logStream","isReadableStream","logHeaders","forEach","redactor","RegExp","replace","write","statusCode","errJSON","JSON","stringify","traceOn","stdout","traceOff","makeRequestAsync","payload","expectedCodes","isNumber","length","sha256sum","toSha256","makeRequestStreamAsync","makeRequestAsyncOmit","statusCodes","res","drainResponse","body","Buffer","isBuffer","getBucketRegionAsync","date","Date","makeDateLong","authorization","signV4","requestWithRetry","maximumRetryCount","baseDelayMs","maximumDelayMs","parseResponseError","isValidBucketName","InvalidBucketNameError","cached","extractRegionAsync","readAsString","parseBucketRegion","DEFAULT_REGION","isBrowser","S3Error","errCode","code","errRegion","name","Region","makeRequest","returnResponse","cb","prom","then","result","makeRequestStream","executor","getBucketRegion","makeBucket","makeOpts","buildObject","CreateBucketConfiguration","$","xmlns","LocationConstraint","ObjectLocking","finalRegion","requestOpt","bucketExists","removeBucket","getObject","getOpts","isValidObjectName","InvalidObjectNameError","getPartialObject","offset","range","sseHeaders","SSECustomerAlgorithm","SSECustomerKey","SSECustomerKeyMD5","prependXAMZMeta","expectedStatusCodes","push","fGetObject","filePath","downloadToTmpFile","partFileStream","objStat","statObject","encodedEtag","from","etag","partFile","fsp","mkdir","dirname","recursive","stats","stat","size","createWriteStream","flags","downloadStream","streamPromise","pipeline","rename","statOpts","statOptDef","parseInt","metaData","extractMetadata","lastModified","versionId","getVersionId","sanitizeETag","removeObject","removeOpts","governanceBypass","forceDelete","queryParams","listIncompleteUploads","bucket","prefix","isValidPrefix","InvalidPrefixError","delimiter","keyMarker","uploadIdMarker","uploads","ended","readStream","Readable","objectMode","_read","shift","listIncompleteUploadsQuery","prefixes","eachSeries","upload","listParts","uploadId","parts","reduce","acc","item","emit","isTruncated","nextKeyMarker","nextUploadIdMarker","queries","uriEscape","maxUploads","sort","unshift","join","parseListMultipart","initiateNewMultipartUpload","readAsBuffer","parseInitiateMultipart","abortMultipartUpload","requestOptions","findUploadId","_latestUpload","latestUpload","initiated","getTime","completeMultipartUpload","etags","builder","CompleteMultipartUpload","Part","map","PartNumber","part","ETag","parseCompleteMultipart","errMessage","marker","listPartsQuery","parseListParts","listBuckets","regionConf","httpRes","xmlResult","parseListBucket","calculatePartSize","fPutObject","insertContentType","putObject","createReadStream","readableStream","statSize","getContentLength","uploadBuffer","buf","uploadStream","md5sum","hashBinary","oldParts","eTags","previousUploadId","oldTags","chunkier","BlockStream2","zeroPadding","o","Promise","all","resolve","reject","pipe","on","partNumber","chunk","md5","createHash","update","digest","oldPart","removeBucketReplication","setBucketReplication","replicationConfig","role","rules","replicationParamsConfig","ReplicationConfiguration","Role","Rule","toMd5","getBucketReplication","parseReplicationConfig","getObjectLegalHold","keys","strRes","parseObjectLegalHoldConfig","setObjectLegalHold","setOpts","status","LEGAL_HOLD_STATUS","ENABLED","DISABLED","config","Status","rootName","getBucketTagging","parseTagging","getObjectTagging","setBucketPolicy","policy","InvalidBucketPolicyError","getBucketPolicy","putObjectRetention","retentionOpts","mode","RETENTION_MODES","COMPLIANCE","GOVERNANCE","retainUntilDate","Mode","RetainUntilDate","getObjectLockConfig","parseObjectLockConfig","setObjectLockConfig","lockConfigOpts","retentionModes","validUnits","RETENTION_VALIDITY_UNITS","DAYS","YEARS","unit","validity","ObjectLockEnabled","configKeys","isAllKeysSet","every","lck","DefaultRetention","Days","Years","getBucketVersioning","parseBucketVersioningConfig","setBucketVersioning","versionConfig","setTagging","taggingParams","tags","putOpts","tagsList","value","Key","Value","taggingConfig","Tagging","TagSet","Tag","payloadBuf","removeTagging","setBucketTagging","isPlainObject","removeBucketTagging","setObjectTagging","removeObjectTagging","selectObjectContent","selectOpts","expression","inputSerialization","outputSerialization","Expression","ExpressionType","expressionType","InputSerialization","OutputSerialization","requestProgress","RequestProgress","scanRange","ScanRange","parseSelectObjectContentResponse","applyBucketLifecycle","policyConfig","removeBucketLifecycle","setBucketLifecycle","lifeCycleConfig","getBucketLifecycle","parseLifecycleConfig","setBucketEncryption","encryptionConfig","encryptionObj","ApplyServerSideEncryptionByDefault","SSEAlgorithm","getBucketEncryption","parseBucketEncryptionConfig","removeBucketEncryption","getObjectRetention","parseObjectRetentionConfig","removeObjects","objectsList","Array","isArray","runDeleteObjects","batch","delObjects","VersionId","remObjects","Delete","Quiet","removeObjectsParser","maxEntries","batches","i","slice","batchResults","flat","removeIncompleteUpload","IsValidBucketNameError","removeUploadId","copyObjectV1","targetBucketName","targetObjectName","sourceBucketNameAndObjectName","conditions","CopyConditions","modified","unmodified","matchETag","matchETagExcept","parseCopyObject","copyObjectV2","sourceConfig","destConfig","CopySourceOptions","CopyDestinationOptions","validate","getHeaders","Bucket","copyRes","resHeaders","sizeHeaderValue","LastModified","MetaData","SourceVersionId","getSourceVersionId","Etag","Size","copyObject","allArgs","source","dest","uploadPart","partConfig","uploadID","partRes","uploadPartParser","partEtagVal","composeObject","destObjConfig","sourceObjList","maxConcurrency","sourceFilesLength","PART_CONSTRAINTS","MAX_PARTS_COUNT","sObj","getStatOptions","srcConfig","VersionID","srcObjectSizes","totalSize","totalParts","sourceObjStats","srcItem","srcObjectInfos","validatedStats","resItemStat","index","srcCopySize","MatchRange","srcStart","Start","srcEnd","End","ABS_MIN_PART_SIZE","MAX_MULTIPART_PUT_OBJECT_SIZE","partsRequired","MAX_PART_SIZE","MatchETag","splitPartSizeList","idx","calculateEvenSplits","getUploadPartConfigList","uploadPartConfigList","splitSize","splitIndex","startIndex","startIdx","endIndex","endIdx","objInfo","objConfig","partIndex","totalUploads","splitStart","upldCtrIdx","splitEnd","sourceObj","uploadPartConfig","uploadAllParts","uploadList","partUploads","performUploadParts","partsRes","partCopy","newUploadHeaders","partsDone","presignedUrl","expires","reqParams","requestDate","_requestDate","AnonymousRequestError","PRESIGN_EXPIRY_DAYS_MAX","isNaN","presignSignatureV4","presignedGetObject","respHeaders","validRespHeaders","header","presignedPutObject","newPostPolicy","PostPolicy","presignedPostPolicy","postPolicy","formData","dateStr","expiration","setSeconds","setExpires","getScope","policyBase64","postPresignSignatureV4","portStr","urlStr","postURL","listObjectsQuery","listQueryOpts","Delimiter","MaxKeys","IncludeVersion","versionIdMarker","listQryList","parseListObjects","listObjects","listOpts","objects","nextMarker","listObjectsV2Query","continuationToken","maxKeys","startAfter","parseListObjectsV2","listObjectsV2","prefixStr","startAfterStr","nextContinuationToken","setBucketNotification","removeAllBucketNotification","NotificationConfig","getBucketNotification","parseBucketNotification","listenBucketNotification","suffix","events","listener","NotificationPoller","start","exports"],"sources":["client.ts"],"sourcesContent":["import * as crypto from 'node:crypto'\nimport * as fs from 'node:fs'\nimport type { IncomingHttpHeaders } from 'node:http'\nimport * as http from 'node:http'\nimport * as https from 'node:https'\nimport * as path from 'node:path'\nimport * as stream from 'node:stream'\n\nimport * as async from 'async'\nimport BlockStream2 from 'block-stream2'\nimport { isBrowser } from 'browser-or-node'\nimport _ from 'lodash'\nimport * as qs from 'query-string'\nimport xml2js from 'xml2js'\n\nimport { CredentialProvider } from '../CredentialProvider.ts'\nimport * as errors from '../errors.ts'\nimport type { SelectResults } from '../helpers.ts'\nimport {\n  CopyDestinationOptions,\n  CopySourceOptions,\n  DEFAULT_REGION,\n  LEGAL_HOLD_STATUS,\n  PRESIGN_EXPIRY_DAYS_MAX,\n  RETENTION_MODES,\n  RETENTION_VALIDITY_UNITS,\n} from '../helpers.ts'\nimport type { NotificationEvent } from '../notification.ts'\nimport { NotificationConfig, NotificationPoller } from '../notification.ts'\nimport { postPresignSignatureV4, presignSignatureV4, signV4 } from '../signing.ts'\nimport { fsp, streamPromise } from './async.ts'\nimport { CopyConditions } from './copy-conditions.ts'\nimport { Extensions } from './extensions.ts'\nimport {\n  calculateEvenSplits,\n  extractMetadata,\n  getContentLength,\n  getScope,\n  getSourceVersionId,\n  getVersionId,\n  hashBinary,\n  insertContentType,\n  isAmazonEndpoint,\n  isBoolean,\n  isDefined,\n  isEmpty,\n  isNumber,\n  isObject,\n  isPlainObject,\n  isReadableStream,\n  isString,\n  isValidBucketName,\n  isValidEndpoint,\n  isValidObjectName,\n  isValidPort,\n  isValidPrefix,\n  isVirtualHostStyle,\n  makeDateLong,\n  PART_CONSTRAINTS,\n  partsRequired,\n  prependXAMZMeta,\n  readableStream,\n  sanitizeETag,\n  toMd5,\n  toSha256,\n  uriEscape,\n  uriResourceEscape,\n} from './helper.ts'\nimport { joinHostPort } from './join-host-port.ts'\nimport { PostPolicy } from './post-policy.ts'\nimport { requestWithRetry } from './request.ts'\nimport { drainResponse, readAsBuffer, readAsString } from './response.ts'\nimport type { Region } from './s3-endpoints.ts'\nimport { getS3Endpoint } from './s3-endpoints.ts'\nimport type {\n  Binary,\n  BucketItem,\n  BucketItemFromList,\n  BucketItemStat,\n  BucketStream,\n  BucketVersioningConfiguration,\n  CopyObjectParams,\n  CopyObjectResult,\n  CopyObjectResultV2,\n  EncryptionConfig,\n  GetObjectLegalHoldOptions,\n  GetObjectOpts,\n  GetObjectRetentionOpts,\n  IncompleteUploadedBucketItem,\n  IRequest,\n  ItemBucketMetadata,\n  LifecycleConfig,\n  LifeCycleConfigParam,\n  ListObjectQueryOpts,\n  ListObjectQueryRes,\n  ListObjectV2Res,\n  NotificationConfigResult,\n  ObjectInfo,\n  ObjectLockConfigParam,\n  ObjectLockInfo,\n  ObjectMetaData,\n  ObjectRetentionInfo,\n  PostPolicyResult,\n  PreSignRequestParams,\n  PutObjectLegalHoldOptions,\n  PutTaggingParams,\n  RemoveObjectsParam,\n  RemoveObjectsRequestEntry,\n  RemoveObjectsResponse,\n  RemoveTaggingParams,\n  ReplicationConfig,\n  ReplicationConfigOpts,\n  RequestHeaders,\n  ResponseHeader,\n  ResultCallback,\n  Retention,\n  SelectOptions,\n  StatObjectOpts,\n  Tag,\n  TaggingOpts,\n  Tags,\n  Transport,\n  UploadedObjectInfo,\n  UploadPartConfig,\n} from './type.ts'\nimport type { ListMultipartResult, UploadedPart } from './xml-parser.ts'\nimport {\n  parseBucketNotification,\n  parseCompleteMultipart,\n  parseInitiateMultipart,\n  parseListObjects,\n  parseListObjectsV2,\n  parseObjectLegalHoldConfig,\n  parseSelectObjectContentResponse,\n  uploadPartParser,\n} from './xml-parser.ts'\nimport * as xmlParsers from './xml-parser.ts'\n\nconst xml = new xml2js.Builder({ renderOpts: { pretty: false }, headless: true })\n\n// will be replaced by bundler.\nconst Package = { version: process.env.HANZOS3_JS_PACKAGE_VERSION || 'development' }\n\nconst requestOptionProperties = [\n  'agent',\n  'ca',\n  'cert',\n  'ciphers',\n  'clientCertEngine',\n  'crl',\n  'dhparam',\n  'ecdhCurve',\n  'family',\n  'honorCipherOrder',\n  'key',\n  'passphrase',\n  'pfx',\n  'rejectUnauthorized',\n  'secureOptions',\n  'secureProtocol',\n  'servername',\n  'sessionIdContext',\n] as const\n\nexport interface RetryOptions {\n  /**\n   * If this set to true, it will take precedence over all other retry options.\n   * @default false\n   */\n  disableRetry?: boolean\n  /**\n   * The maximum amount of retries for a request.\n   * @default 1\n   */\n  maximumRetryCount?: number\n  /**\n   * The minimum duration (in milliseconds) for the exponential backoff algorithm.\n   * @default 100\n   */\n  baseDelayMs?: number\n  /**\n   * The maximum duration (in milliseconds) for the exponential backoff algorithm.\n   * @default 60000\n   */\n  maximumDelayMs?: number\n}\n\nexport interface ClientOptions {\n  endPoint: string\n  accessKey?: string\n  secretKey?: string\n  useSSL?: boolean\n  port?: number\n  region?: Region\n  transport?: Transport\n  sessionToken?: string\n  partSize?: number\n  pathStyle?: boolean\n  credentialsProvider?: CredentialProvider\n  s3AccelerateEndpoint?: string\n  transportAgent?: http.Agent\n  retryOptions?: RetryOptions\n}\n\nexport type RequestOption = Partial<IRequest> & {\n  method: string\n  bucketName?: string\n  objectName?: string\n  query?: string\n  pathStyle?: boolean\n}\n\nexport type NoResultCallback = (error: unknown) => void\n\nexport interface MakeBucketOpt {\n  ObjectLocking?: boolean\n}\n\nexport interface RemoveOptions {\n  versionId?: string\n  governanceBypass?: boolean\n  forceDelete?: boolean\n}\n\ntype Part = {\n  part: number\n  etag: string\n}\n\nexport class TypedClient {\n  protected transport: Transport\n  protected host: string\n  protected port: number\n  protected protocol: string\n  protected accessKey: string\n  protected secretKey: string\n  protected sessionToken?: string\n  protected userAgent: string\n  protected anonymous: boolean\n  protected pathStyle: boolean\n  protected regionMap: Record<string, string>\n  public region?: string\n  protected credentialsProvider?: CredentialProvider\n  partSize: number = 64 * 1024 * 1024\n  protected overRidePartSize?: boolean\n  protected retryOptions: RetryOptions\n\n  protected maximumPartSize = 5 * 1024 * 1024 * 1024\n  protected maxObjectSize = 5 * 1024 * 1024 * 1024 * 1024\n  public enableSHA256: boolean\n  protected s3AccelerateEndpoint?: string\n  protected reqOptions: Record<string, unknown>\n\n  protected transportAgent: http.Agent\n  private readonly clientExtensions: Extensions\n\n  constructor(params: ClientOptions) {\n    // @ts-expect-error deprecated property\n    if (params.secure !== undefined) {\n      throw new Error('\"secure\" option deprecated, \"useSSL\" should be used instead')\n    }\n    // Default values if not specified.\n    if (params.useSSL === undefined) {\n      params.useSSL = true\n    }\n    if (!params.port) {\n      params.port = 0\n    }\n    // Validate input params.\n    if (!isValidEndpoint(params.endPoint)) {\n      throw new errors.InvalidEndpointError(`Invalid endPoint : ${params.endPoint}`)\n    }\n    if (!isValidPort(params.port)) {\n      throw new errors.InvalidArgumentError(`Invalid port : ${params.port}`)\n    }\n    if (!isBoolean(params.useSSL)) {\n      throw new errors.InvalidArgumentError(\n        `Invalid useSSL flag type : ${params.useSSL}, expected to be of type \"boolean\"`,\n      )\n    }\n\n    // Validate region only if its set.\n    if (params.region) {\n      if (!isString(params.region)) {\n        throw new errors.InvalidArgumentError(`Invalid region : ${params.region}`)\n      }\n    }\n\n    const host = params.endPoint.toLowerCase()\n    let port = params.port\n    let protocol: string\n    let transport\n    let transportAgent: http.Agent\n    // Validate if configuration is not using SSL\n    // for constructing relevant endpoints.\n    if (params.useSSL) {\n      // Defaults to secure.\n      transport = https\n      protocol = 'https:'\n      port = port || 443\n      transportAgent = https.globalAgent\n    } else {\n      transport = http\n      protocol = 'http:'\n      port = port || 80\n      transportAgent = http.globalAgent\n    }\n\n    // if custom transport is set, use it.\n    if (params.transport) {\n      if (!isObject(params.transport)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid transport type : ${params.transport}, expected to be type \"object\"`,\n        )\n      }\n      transport = params.transport\n    }\n\n    // if custom transport agent is set, use it.\n    if (params.transportAgent) {\n      if (!isObject(params.transportAgent)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid transportAgent type: ${params.transportAgent}, expected to be type \"object\"`,\n        )\n      }\n\n      transportAgent = params.transportAgent\n    }\n\n    // User Agent should always following the below style.\n    // Please open an issue to discuss any new changes here.\n    //\n    //       HanzoS3 (OS; ARCH) LIB/VER APP/VER\n    //\n    const libraryComments = `(${process.platform}; ${process.arch})`\n    const libraryAgent = `HanzoS3 ${libraryComments} hanzo-s3/${Package.version}`\n    // User agent block ends.\n\n    this.transport = transport\n    this.transportAgent = transportAgent\n    this.host = host\n    this.port = port\n    this.protocol = protocol\n    this.userAgent = `${libraryAgent}`\n\n    // Default path style is true\n    if (params.pathStyle === undefined) {\n      this.pathStyle = true\n    } else {\n      this.pathStyle = params.pathStyle\n    }\n\n    this.accessKey = params.accessKey ?? ''\n    this.secretKey = params.secretKey ?? ''\n    this.sessionToken = params.sessionToken\n    this.anonymous = !this.accessKey || !this.secretKey\n\n    if (params.credentialsProvider) {\n      this.anonymous = false\n      this.credentialsProvider = params.credentialsProvider\n    }\n\n    this.regionMap = {}\n    if (params.region) {\n      this.region = params.region\n    }\n\n    if (params.partSize) {\n      this.partSize = params.partSize\n      this.overRidePartSize = true\n    }\n    if (this.partSize < 5 * 1024 * 1024) {\n      throw new errors.InvalidArgumentError(`Part size should be greater than 5MB`)\n    }\n    if (this.partSize > 5 * 1024 * 1024 * 1024) {\n      throw new errors.InvalidArgumentError(`Part size should be less than 5GB`)\n    }\n\n    // SHA256 is enabled only for authenticated http requests. If the request is authenticated\n    // and the connection is https we use x-amz-content-sha256=UNSIGNED-PAYLOAD\n    // header for signature calculation.\n    this.enableSHA256 = !this.anonymous && !params.useSSL\n\n    this.s3AccelerateEndpoint = params.s3AccelerateEndpoint || undefined\n    this.reqOptions = {}\n    this.clientExtensions = new Extensions(this)\n\n    if (params.retryOptions) {\n      if (!isObject(params.retryOptions)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid retryOptions type: ${params.retryOptions}, expected to be type \"object\"`,\n        )\n      }\n\n      this.retryOptions = params.retryOptions\n    } else {\n      this.retryOptions = {\n        disableRetry: false,\n      }\n    }\n  }\n  /**\n   * S3 extensions that aren't necessarily present for Amazon S3 compatible storage servers\n   */\n  get extensions() {\n    return this.clientExtensions\n  }\n\n  /**\n   * @param endPoint - valid S3 acceleration end point\n   */\n  setS3TransferAccelerate(endPoint: string) {\n    this.s3AccelerateEndpoint = endPoint\n  }\n\n  /**\n   * Sets the supported request options.\n   */\n  public setRequestOptions(options: Pick<https.RequestOptions, (typeof requestOptionProperties)[number]>) {\n    if (!isObject(options)) {\n      throw new TypeError('request options should be of type \"object\"')\n    }\n    this.reqOptions = _.pick(options, requestOptionProperties)\n  }\n\n  /**\n   *  This is s3 Specific and does not hold validity in any other Object storage.\n   */\n  private getAccelerateEndPointIfSet(bucketName?: string, objectName?: string) {\n    if (!isEmpty(this.s3AccelerateEndpoint) && !isEmpty(bucketName) && !isEmpty(objectName)) {\n      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html\n      // Disable transfer acceleration for non-compliant bucket names.\n      if (bucketName.includes('.')) {\n        throw new Error(`Transfer Acceleration is not supported for non compliant bucket:${bucketName}`)\n      }\n      // If transfer acceleration is requested set new host.\n      // For more details about enabling transfer acceleration read here.\n      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html\n      return this.s3AccelerateEndpoint\n    }\n    return false\n  }\n\n  /**\n   *   Set application specific information.\n   *   Generates User-Agent in the following style.\n   *   HanzoS3 (OS; ARCH) LIB/VER APP/VER\n   */\n  setAppInfo(appName: string, appVersion: string) {\n    if (!isString(appName)) {\n      throw new TypeError(`Invalid appName: ${appName}`)\n    }\n    if (appName.trim() === '') {\n      throw new errors.InvalidArgumentError('Input appName cannot be empty.')\n    }\n    if (!isString(appVersion)) {\n      throw new TypeError(`Invalid appVersion: ${appVersion}`)\n    }\n    if (appVersion.trim() === '') {\n      throw new errors.InvalidArgumentError('Input appVersion cannot be empty.')\n    }\n    this.userAgent = `${this.userAgent} ${appName}/${appVersion}`\n  }\n\n  /**\n   * returns options object that can be used with http.request()\n   * Takes care of constructing virtual-host-style or path-style hostname\n   */\n  protected getRequestOptions(\n    opts: RequestOption & {\n      region: string\n    },\n  ): IRequest & {\n    host: string\n    headers: Record<string, string>\n  } {\n    const method = opts.method\n    const region = opts.region\n    const bucketName = opts.bucketName\n    let objectName = opts.objectName\n    const headers = opts.headers\n    const query = opts.query\n\n    let reqOptions = {\n      method,\n      headers: {} as RequestHeaders,\n      protocol: this.protocol,\n      // If custom transportAgent was supplied earlier, we'll inject it here\n      agent: this.transportAgent,\n    }\n\n    // Verify if virtual host supported.\n    let virtualHostStyle\n    if (bucketName) {\n      virtualHostStyle = isVirtualHostStyle(this.host, this.protocol, bucketName, this.pathStyle)\n    }\n\n    let path = '/'\n    let host = this.host\n\n    let port: undefined | number\n    if (this.port) {\n      port = this.port\n    }\n\n    if (objectName) {\n      objectName = uriResourceEscape(objectName)\n    }\n\n    // For Amazon S3 endpoint, get endpoint based on region.\n    if (isAmazonEndpoint(host)) {\n      const accelerateEndPoint = this.getAccelerateEndPointIfSet(bucketName, objectName)\n      if (accelerateEndPoint) {\n        host = `${accelerateEndPoint}`\n      } else {\n        host = getS3Endpoint(region)\n      }\n    }\n\n    if (virtualHostStyle && !opts.pathStyle) {\n      // For all hosts which support virtual host style, `bucketName`\n      // is part of the hostname in the following format:\n      //\n      //  var host = 'bucketName.example.com'\n      //\n      if (bucketName) {\n        host = `${bucketName}.${host}`\n      }\n      if (objectName) {\n        path = `/${objectName}`\n      }\n    } else {\n      // For all S3 compatible storage services we will fallback to\n      // path style requests, where `bucketName` is part of the URI\n      // path.\n      if (bucketName) {\n        path = `/${bucketName}`\n      }\n      if (objectName) {\n        path = `/${bucketName}/${objectName}`\n      }\n    }\n\n    if (query) {\n      path += `?${query}`\n    }\n    reqOptions.headers.host = host\n    if ((reqOptions.protocol === 'http:' && port !== 80) || (reqOptions.protocol === 'https:' && port !== 443)) {\n      reqOptions.headers.host = joinHostPort(host, port)\n    }\n\n    reqOptions.headers['user-agent'] = this.userAgent\n    if (headers) {\n      // have all header keys in lower case - to make signing easy\n      for (const [k, v] of Object.entries(headers)) {\n        reqOptions.headers[k.toLowerCase()] = v\n      }\n    }\n\n    // Use any request option specified in client.setRequestOptions()\n    reqOptions = Object.assign({}, this.reqOptions, reqOptions)\n\n    return {\n      ...reqOptions,\n      headers: _.mapValues(_.pickBy(reqOptions.headers, isDefined), (v) => v.toString()),\n      host,\n      port,\n      path,\n    } satisfies https.RequestOptions\n  }\n\n  public async setCredentialsProvider(credentialsProvider: CredentialProvider) {\n    if (!(credentialsProvider instanceof CredentialProvider)) {\n      throw new Error('Unable to get credentials. Expected instance of CredentialProvider')\n    }\n    this.credentialsProvider = credentialsProvider\n    await this.checkAndRefreshCreds()\n  }\n\n  private async checkAndRefreshCreds() {\n    if (this.credentialsProvider) {\n      try {\n        const credentialsConf = await this.credentialsProvider.getCredentials()\n        this.accessKey = credentialsConf.getAccessKey()\n        this.secretKey = credentialsConf.getSecretKey()\n        this.sessionToken = credentialsConf.getSessionToken()\n      } catch (e) {\n        throw new Error(`Unable to get credentials: ${e}`, { cause: e })\n      }\n    }\n  }\n\n  private logStream?: stream.Writable\n\n  /**\n   * log the request, response, error\n   */\n  private logHTTP(reqOptions: IRequest, response: http.IncomingMessage | null, err?: unknown) {\n    // if no logStream available return.\n    if (!this.logStream) {\n      return\n    }\n    if (!isObject(reqOptions)) {\n      throw new TypeError('reqOptions should be of type \"object\"')\n    }\n    if (response && !isReadableStream(response)) {\n      throw new TypeError('response should be of type \"Stream\"')\n    }\n    if (err && !(err instanceof Error)) {\n      throw new TypeError('err should be of type \"Error\"')\n    }\n    const logStream = this.logStream\n    const logHeaders = (headers: RequestHeaders) => {\n      Object.entries(headers).forEach(([k, v]) => {\n        if (k == 'authorization') {\n          if (isString(v)) {\n            const redactor = new RegExp('Signature=([0-9a-f]+)')\n            v = v.replace(redactor, 'Signature=**REDACTED**')\n          }\n        }\n        logStream.write(`${k}: ${v}\\n`)\n      })\n      logStream.write('\\n')\n    }\n    logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\\n`)\n    logHeaders(reqOptions.headers)\n    if (response) {\n      this.logStream.write(`RESPONSE: ${response.statusCode}\\n`)\n      logHeaders(response.headers as RequestHeaders)\n    }\n    if (err) {\n      logStream.write('ERROR BODY:\\n')\n      const errJSON = JSON.stringify(err, null, '\\t')\n      logStream.write(`${errJSON}\\n`)\n    }\n  }\n\n  /**\n   * Enable tracing\n   */\n  public traceOn(stream?: stream.Writable) {\n    if (!stream) {\n      stream = process.stdout\n    }\n    this.logStream = stream\n  }\n\n  /**\n   * Disable tracing\n   */\n  public traceOff() {\n    this.logStream = undefined\n  }\n\n  /**\n   * makeRequest is the primitive used by the apis for making S3 requests.\n   * payload can be empty string in case of no payload.\n   * statusCode is the expected statusCode. If response.statusCode does not match\n   * we parse the XML error and call the callback with the error message.\n   *\n   * A valid region is passed by the calls - listBuckets, makeBucket and getBucketRegion.\n   *\n   * @internal\n   */\n  async makeRequestAsync(\n    options: RequestOption,\n    payload: Binary = '',\n    expectedCodes: number[] = [200],\n    region = '',\n  ): Promise<http.IncomingMessage> {\n    if (!isObject(options)) {\n      throw new TypeError('options should be of type \"object\"')\n    }\n    if (!isString(payload) && !isObject(payload)) {\n      // Buffer is of type 'object'\n      throw new TypeError('payload should be of type \"string\" or \"Buffer\"')\n    }\n    expectedCodes.forEach((statusCode) => {\n      if (!isNumber(statusCode)) {\n        throw new TypeError('statusCode should be of type \"number\"')\n      }\n    })\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!options.headers) {\n      options.headers = {}\n    }\n    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') {\n      options.headers['content-length'] = payload.length.toString()\n    }\n    const sha256sum = this.enableSHA256 ? toSha256(payload) : ''\n    return this.makeRequestStreamAsync(options, payload, sha256sum, expectedCodes, region)\n  }\n\n  /**\n   * new request with promise\n   *\n   * No need to drain response, response body is not valid\n   */\n  async makeRequestAsyncOmit(\n    options: RequestOption,\n    payload: Binary = '',\n    statusCodes: number[] = [200],\n    region = '',\n  ): Promise<Omit<http.IncomingMessage, 'on'>> {\n    const res = await this.makeRequestAsync(options, payload, statusCodes, region)\n    await drainResponse(res)\n    return res\n  }\n\n  /**\n   * makeRequestStream will be used directly instead of makeRequest in case the payload\n   * is available as a stream. for ex. putObject\n   *\n   * @internal\n   */\n  async makeRequestStreamAsync(\n    options: RequestOption,\n    body: stream.Readable | Binary,\n    sha256sum: string,\n    statusCodes: number[],\n    region: string,\n  ): Promise<http.IncomingMessage> {\n    if (!isObject(options)) {\n      throw new TypeError('options should be of type \"object\"')\n    }\n    if (!(Buffer.isBuffer(body) || typeof body === 'string' || isReadableStream(body))) {\n      throw new errors.InvalidArgumentError(\n        `stream should be a Buffer, string or readable Stream, got ${typeof body} instead`,\n      )\n    }\n    if (!isString(sha256sum)) {\n      throw new TypeError('sha256sum should be of type \"string\"')\n    }\n    statusCodes.forEach((statusCode) => {\n      if (!isNumber(statusCode)) {\n        throw new TypeError('statusCode should be of type \"number\"')\n      }\n    })\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    // sha256sum will be empty for anonymous or https requests\n    if (!this.enableSHA256 && sha256sum.length !== 0) {\n      throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`)\n    }\n    // sha256sum should be valid for non-anonymous http requests.\n    if (this.enableSHA256 && sha256sum.length !== 64) {\n      throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`)\n    }\n\n    await this.checkAndRefreshCreds()\n\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    region = region || (await this.getBucketRegionAsync(options.bucketName!))\n\n    const reqOptions = this.getRequestOptions({ ...options, region })\n    if (!this.anonymous) {\n      // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation.\n      if (!this.enableSHA256) {\n        sha256sum = 'UNSIGNED-PAYLOAD'\n      }\n      const date = new Date()\n      reqOptions.headers['x-amz-date'] = makeDateLong(date)\n      reqOptions.headers['x-amz-content-sha256'] = sha256sum\n      if (this.sessionToken) {\n        reqOptions.headers['x-amz-security-token'] = this.sessionToken\n      }\n      reqOptions.headers.authorization = signV4(reqOptions, this.accessKey, this.secretKey, region, date, sha256sum)\n    }\n\n    const response = await requestWithRetry(\n      this.transport,\n      reqOptions,\n      body,\n      this.retryOptions.disableRetry === true ? 0 : this.retryOptions.maximumRetryCount,\n      this.retryOptions.baseDelayMs,\n      this.retryOptions.maximumDelayMs,\n    )\n    if (!response.statusCode) {\n      throw new Error(\"BUG: response doesn't have a statusCode\")\n    }\n\n    if (!statusCodes.includes(response.statusCode)) {\n      // For an incorrect region, S3 server always sends back 400.\n      // But we will do cache invalidation for all errors so that,\n      // in future, if AWS S3 decides to send a different status code or\n      // XML error code we will still work fine.\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      delete this.regionMap[options.bucketName!]\n\n      const err = await xmlParsers.parseResponseError(response)\n      this.logHTTP(reqOptions, response, err)\n      throw err\n    }\n\n    this.logHTTP(reqOptions, response)\n\n    return response\n  }\n\n  /**\n   * gets the region of the bucket\n   *\n   * @param bucketName\n   *\n   */\n  async getBucketRegionAsync(bucketName: string): Promise<string> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`)\n    }\n\n    // Region is set with constructor, return the region right here.\n    if (this.region) {\n      return this.region\n    }\n\n    const cached = this.regionMap[bucketName]\n    if (cached) {\n      return cached\n    }\n\n    const extractRegionAsync = async (response: http.IncomingMessage) => {\n      const body = await readAsString(response)\n      const region = xmlParsers.parseBucketRegion(body) || DEFAULT_REGION\n      this.regionMap[bucketName] = region\n      return region\n    }\n\n    const method = 'GET'\n    const query = 'location'\n    // `getBucketLocation` behaves differently in following ways for\n    // different environments.\n    //\n    // - For nodejs env we default to path style requests.\n    // - For browser env path style requests on buckets yields CORS\n    //   error. To circumvent this problem we make a virtual host\n    //   style request signed with 'us-east-1'. This request fails\n    //   with an error 'AuthorizationHeaderMalformed', additionally\n    //   the error XML also provides Region of the bucket. To validate\n    //   this region is proper we retry the same request with the newly\n    //   obtained region.\n    const pathStyle = this.pathStyle && !isBrowser\n    let region: string\n    try {\n      const res = await this.makeRequestAsync({ method, bucketName, query, pathStyle }, '', [200], DEFAULT_REGION)\n      return extractRegionAsync(res)\n    } catch (e) {\n      // make alignment with mc cli\n      if (e instanceof errors.S3Error) {\n        const errCode = e.code\n        const errRegion = e.region\n        if (errCode === 'AccessDenied' && !errRegion) {\n          return DEFAULT_REGION\n        }\n      }\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      if (!(e.name === 'AuthorizationHeaderMalformed')) {\n        throw e\n      }\n      // @ts-expect-error we set extra properties on error object\n      region = e.Region as string\n      if (!region) {\n        throw e\n      }\n    }\n\n    const res = await this.makeRequestAsync({ method, bucketName, query, pathStyle }, '', [200], region)\n    return await extractRegionAsync(res)\n  }\n\n  /**\n   * makeRequest is the primitive used by the apis for making S3 requests.\n   * payload can be empty string in case of no payload.\n   * statusCode is the expected statusCode. If response.statusCode does not match\n   * we parse the XML error and call the callback with the error message.\n   * A valid region is passed by the calls - listBuckets, makeBucket and\n   * getBucketRegion.\n   *\n   * @deprecated use `makeRequestAsync` instead\n   */\n  makeRequest(\n    options: RequestOption,\n    payload: Binary = '',\n    expectedCodes: number[] = [200],\n    region = '',\n    returnResponse: boolean,\n    cb: (cb: unknown, result: http.IncomingMessage) => void,\n  ) {\n    let prom: Promise<http.IncomingMessage>\n    if (returnResponse) {\n      prom = this.makeRequestAsync(options, payload, expectedCodes, region)\n    } else {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-expect-error compatible for old behaviour\n      prom = this.makeRequestAsyncOmit(options, payload, expectedCodes, region)\n    }\n\n    prom.then(\n      (result) => cb(null, result),\n      (err) => {\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        cb(err)\n      },\n    )\n  }\n\n  /**\n   * makeRequestStream will be used directly instead of makeRequest in case the payload\n   * is available as a stream. for ex. putObject\n   *\n   * @deprecated use `makeRequestStreamAsync` instead\n   */\n  makeRequestStream(\n    options: RequestOption,\n    stream: stream.Readable | Buffer,\n    sha256sum: string,\n    statusCodes: number[],\n    region: string,\n    returnResponse: boolean,\n    cb: (cb: unknown, result: http.IncomingMessage) => void,\n  ) {\n    const executor = async () => {\n      const res = await this.makeRequestStreamAsync(options, stream, sha256sum, statusCodes, region)\n      if (!returnResponse) {\n        await drainResponse(res)\n      }\n\n      return res\n    }\n\n    executor().then(\n      (result) => cb(null, result),\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      (err) => cb(err),\n    )\n  }\n\n  /**\n   * @deprecated use `getBucketRegionAsync` instead\n   */\n  getBucketRegion(bucketName: string, cb: (err: unknown, region: string) => void) {\n    return this.getBucketRegionAsync(bucketName).then(\n      (result) => cb(null, result),\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      (err) => cb(err),\n    )\n  }\n\n  // Bucket operations\n\n  /**\n   * Creates the bucket `bucketName`.\n   *\n   */\n  async makeBucket(bucketName: string, region: Region = '', makeOpts?: MakeBucketOpt): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    // Backward Compatibility\n    if (isObject(region)) {\n      makeOpts = region\n      region = ''\n    }\n\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (makeOpts && !isObject(makeOpts)) {\n      throw new TypeError('makeOpts should be of type \"object\"')\n    }\n\n    let payload = ''\n\n    // Region already set in constructor, validate if\n    // caller requested bucket location is same.\n    if (region && this.region) {\n      if (region !== this.region) {\n        throw new errors.InvalidArgumentError(`Configured region ${this.region}, requested ${region}`)\n      }\n    }\n    // sending makeBucket request with XML containing 'us-east-1' fails. For\n    // default region server expects the request without body\n    if (region && region !== DEFAULT_REGION) {\n      payload = xml.buildObject({\n        CreateBucketConfiguration: {\n          $: { xmlns: 'http://s3.amazonaws.com/doc/2006-03-01/' },\n          LocationConstraint: region,\n        },\n      })\n    }\n    const method = 'PUT'\n    const headers: RequestHeaders = {}\n\n    if (makeOpts && makeOpts.ObjectLocking) {\n      headers['x-amz-bucket-object-lock-enabled'] = true\n    }\n\n    // For custom region clients  default to custom region specified in client constructor\n    const finalRegion = this.region || region || DEFAULT_REGION\n\n    const requestOpt: RequestOption = { method, bucketName, headers }\n\n    try {\n      await this.makeRequestAsyncOmit(requestOpt, payload, [200], finalRegion)\n    } catch (err: unknown) {\n      if (region === '' || region === DEFAULT_REGION) {\n        if (err instanceof errors.S3Error) {\n          const errCode = err.code\n          const errRegion = err.region\n          if (errCode === 'AuthorizationHeaderMalformed' && errRegion !== '') {\n            // Retry with region returned as part of error\n            await this.makeRequestAsyncOmit(requestOpt, payload, [200], errCode)\n          }\n        }\n      }\n      throw err\n    }\n  }\n\n  /**\n   * To check if a bucket already exists.\n   */\n  async bucketExists(bucketName: string): Promise<boolean> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'HEAD'\n    try {\n      await this.makeRequestAsyncOmit({ method, bucketName })\n    } catch (err) {\n      // @ts-ignore\n      if (err.code === 'NoSuchBucket' || err.code === 'NotFound') {\n        return false\n      }\n      throw err\n    }\n\n    return true\n  }\n\n  async removeBucket(bucketName: string): Promise<void>\n\n  /**\n   * @deprecated use promise style API\n   */\n  removeBucket(bucketName: string, callback: NoResultCallback): void\n\n  async removeBucket(bucketName: string): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    await this.makeRequestAsyncOmit({ method, bucketName }, '', [204])\n    delete this.regionMap[bucketName]\n  }\n\n  /**\n   * Callback is called with readable stream of the object content.\n   */\n  async getObject(bucketName: string, objectName: string, getOpts?: GetObjectOpts): Promise<stream.Readable> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    return this.getPartialObject(bucketName, objectName, 0, 0, getOpts)\n  }\n\n  /**\n   * Callback is called with readable stream of the partial object content.\n   * @param bucketName\n   * @param objectName\n   * @param offset\n   * @param length - length of the object that will be read in the stream (optional, if not specified we read the rest of the file from the offset)\n   * @param getOpts\n   */\n  async getPartialObject(\n    bucketName: string,\n    objectName: string,\n    offset: number,\n    length = 0,\n    getOpts?: GetObjectOpts,\n  ): Promise<stream.Readable> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isNumber(offset)) {\n      throw new TypeError('offset should be of type \"number\"')\n    }\n    if (!isNumber(length)) {\n      throw new TypeError('length should be of type \"number\"')\n    }\n\n    let range = ''\n    if (offset || length) {\n      if (offset) {\n        range = `bytes=${+offset}-`\n      } else {\n        range = 'bytes=0-'\n        offset = 0\n      }\n      if (length) {\n        range += `${+length + offset - 1}`\n      }\n    }\n\n    let query = ''\n    let headers: RequestHeaders = {\n      ...(range !== '' && { range }),\n    }\n\n    if (getOpts) {\n      const sseHeaders: Record<string, string> = {\n        ...(getOpts.SSECustomerAlgorithm && {\n          'X-Amz-Server-Side-Encryption-Customer-Algorithm': getOpts.SSECustomerAlgorithm,\n        }),\n        ...(getOpts.SSECustomerKey && { 'X-Amz-Server-Side-Encryption-Customer-Key': getOpts.SSECustomerKey }),\n        ...(getOpts.SSECustomerKeyMD5 && {\n          'X-Amz-Server-Side-Encryption-Customer-Key-MD5': getOpts.SSECustomerKeyMD5,\n        }),\n      }\n      query = qs.stringify(getOpts)\n      headers = {\n        ...prependXAMZMeta(sseHeaders),\n        ...headers,\n      }\n    }\n\n    const expectedStatusCodes = [200]\n    if (range) {\n      expectedStatusCodes.push(206)\n    }\n    const method = 'GET'\n\n    return await this.makeRequestAsync({ method, bucketName, objectName, headers, query }, '', expectedStatusCodes)\n  }\n\n  /**\n   * download object content to a file.\n   * This method will create a temp file named `${filename}.${base64(etag)}.part.s3` when downloading.\n   *\n   * @param bucketName - name of the bucket\n   * @param objectName - name of the object\n   * @param filePath - path to which the object data will be written to\n   * @param getOpts - Optional object get option\n   */\n  async fGetObject(bucketName: string, objectName: string, filePath: string, getOpts?: GetObjectOpts): Promise<void> {\n    // Input validation.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(filePath)) {\n      throw new TypeError('filePath should be of type \"string\"')\n    }\n\n    const downloadToTmpFile = async (): Promise<string> => {\n      let partFileStream: stream.Writable\n      const objStat = await this.statObject(bucketName, objectName, getOpts)\n      const encodedEtag = Buffer.from(objStat.etag).toString('base64')\n      const partFile = `${filePath}.${encodedEtag}.part.s3`\n\n      await fsp.mkdir(path.dirname(filePath), { recursive: true })\n\n      let offset = 0\n      try {\n        const stats = await fsp.stat(partFile)\n        if (objStat.size === stats.size) {\n          return partFile\n        }\n        offset = stats.size\n        partFileStream = fs.createWriteStream(partFile, { flags: 'a' })\n      } catch (e) {\n        if (e instanceof Error && (e as unknown as { code: string }).code === 'ENOENT') {\n          // file not exist\n          partFileStream = fs.createWriteStream(partFile, { flags: 'w' })\n        } else {\n          // other error, maybe access deny\n          throw e\n        }\n      }\n\n      const downloadStream = await this.getPartialObject(bucketName, objectName, offset, 0, getOpts)\n\n      await streamPromise.pipeline(downloadStream, partFileStream)\n      const stats = await fsp.stat(partFile)\n      if (stats.size === objStat.size) {\n        return partFile\n      }\n\n      throw new Error('Size mismatch between downloaded file and the object')\n    }\n\n    const partFile = await downloadToTmpFile()\n    await fsp.rename(partFile, filePath)\n  }\n\n  /**\n   * Stat information of the object.\n   */\n  async statObject(bucketName: string, objectName: string, statOpts?: StatObjectOpts): Promise<BucketItemStat> {\n    const statOptDef = statOpts || {}\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isObject(statOptDef)) {\n      throw new errors.InvalidArgumentError('statOpts should be of type \"object\"')\n    }\n\n    const query = qs.stringify(statOptDef)\n    const method = 'HEAD'\n    const res = await this.makeRequestAsyncOmit({ method, bucketName, objectName, query })\n\n    return {\n      size: parseInt(res.headers['content-length'] as string),\n      metaData: extractMetadata(res.headers as ResponseHeader),\n      lastModified: new Date(res.headers['last-modified'] as string),\n      versionId: getVersionId(res.headers as ResponseHeader),\n      etag: sanitizeETag(res.headers.etag),\n    }\n  }\n\n  async removeObject(bucketName: string, objectName: string, removeOpts?: RemoveOptions): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (removeOpts && !isObject(removeOpts)) {\n      throw new errors.InvalidArgumentError('removeOpts should be of type \"object\"')\n    }\n\n    const method = 'DELETE'\n\n    const headers: RequestHeaders = {}\n    if (removeOpts?.governanceBypass) {\n      headers['X-Amz-Bypass-Governance-Retention'] = true\n    }\n    if (removeOpts?.forceDelete) {\n      headers['x-force-delete'] = true\n    }\n\n    const queryParams: Record<string, string> = {}\n    if (removeOpts?.versionId) {\n      queryParams.versionId = `${removeOpts.versionId}`\n    }\n    const query = qs.stringify(queryParams)\n\n    await this.makeRequestAsyncOmit({ method, bucketName, objectName, headers, query }, '', [200, 204])\n  }\n\n  // Calls implemented below are related to multipart.\n\n  listIncompleteUploads(\n    bucket: string,\n    prefix: string,\n    recursive: boolean,\n  ): BucketStream<IncompleteUploadedBucketItem> {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (!isValidBucketName(bucket)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucket)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    const delimiter = recursive ? '' : '/'\n    let keyMarker = ''\n    let uploadIdMarker = ''\n    const uploads: unknown[] = []\n    let ended = false\n\n    // TODO: refactor this with async/await and `stream.Readable.from`\n    const readStream = new stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one upload info per _read()\n      if (uploads.length) {\n        return readStream.push(uploads.shift())\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      this.listIncompleteUploadsQuery(bucket, prefix, keyMarker, uploadIdMarker, delimiter).then(\n        (result) => {\n          // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n          // @ts-ignore\n          result.prefixes.forEach((prefix) => uploads.push(prefix))\n          async.eachSeries(\n            result.uploads,\n            (upload, cb) => {\n              // for each incomplete upload add the sizes of its uploaded parts\n              // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n              // @ts-ignore\n              this.listParts(bucket, upload.key, upload.uploadId).then(\n                (parts: Part[]) => {\n                  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n                  // @ts-ignore\n                  upload.size = parts.reduce((acc, item) => acc + item.size, 0)\n                  uploads.push(upload)\n                  cb()\n                },\n                (err: Error) => cb(err),\n              )\n            },\n            (err) => {\n              if (err) {\n                readStream.emit('error', err)\n                return\n              }\n              if (result.isTruncated) {\n                keyMarker = result.nextKeyMarker\n                uploadIdMarker = result.nextUploadIdMarker\n              } else {\n                ended = true\n              }\n\n              // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n              // @ts-ignore\n              readStream._read()\n            },\n          )\n        },\n        (e) => {\n          readStream.emit('error', e)\n        },\n      )\n    }\n    return readStream\n  }\n\n  /**\n   * Called by listIncompleteUploads to fetch a batch of incomplete uploads.\n   */\n  async listIncompleteUploadsQuery(\n    bucketName: string,\n    prefix: string,\n    keyMarker: string,\n    uploadIdMarker: string,\n    delimiter: string,\n  ): Promise<ListMultipartResult> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(keyMarker)) {\n      throw new TypeError('keyMarker should be of type \"string\"')\n    }\n    if (!isString(uploadIdMarker)) {\n      throw new TypeError('uploadIdMarker should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    const queries = []\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n\n    if (keyMarker) {\n      queries.push(`key-marker=${uriEscape(keyMarker)}`)\n    }\n    if (uploadIdMarker) {\n      queries.push(`upload-id-marker=${uploadIdMarker}`)\n    }\n\n    const maxUploads = 1000\n    queries.push(`max-uploads=${maxUploads}`)\n    queries.sort()\n    queries.unshift('uploads')\n    let query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    const method = 'GET'\n    const res = await this.makeRequestAsync({ method, bucketName, query })\n    const body = await readAsString(res)\n    return xmlParsers.parseListMultipart(body)\n  }\n\n  /**\n   * Initiate a new multipart upload.\n   * @internal\n   */\n  async initiateNewMultipartUpload(bucketName: string, objectName: string, headers: RequestHeaders): Promise<string> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(headers)) {\n      throw new errors.InvalidObjectNameError('contentType should be of type \"object\"')\n    }\n    const method = 'POST'\n    const query = 'uploads'\n    const res = await this.makeRequestAsync({ method, bucketName, objectName, query, headers })\n    const body = await readAsBuffer(res)\n    return parseInitiateMultipart(body.toString())\n  }\n\n  /**\n   * Internal Method to abort a multipart upload request in case of any errors.\n   *\n   * @param bucketName - Bucket Name\n   * @param objectName - Object Name\n   * @param uploadId - id of a multipart upload to cancel during compose object sequence.\n   */\n  async abortMultipartUpload(bucketName: string, objectName: string, uploadId: string): Promise<void> {\n    const method = 'DELETE'\n    const query = `uploadId=${uploadId}`\n\n    const requestOptions = { method, bucketName, objectName: objectName, query }\n    await this.makeRequestAsyncOmit(requestOptions, '', [204])\n  }\n\n  async findUploadId(bucketName: string, objectName: string): Promise<string | undefined> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    let latestUpload: ListMultipartResult['uploads'][number] | undefined\n    let keyMarker = ''\n    let uploadIdMarker = ''\n    for (;;) {\n      const result = await this.listIncompleteUploadsQuery(bucketName, objectName, keyMarker, uploadIdMarker, '')\n      for (const upload of result.uploads) {\n        if (upload.key === objectName) {\n          if (!latestUpload || upload.initiated.getTime() > latestUpload.initiated.getTime()) {\n            latestUpload = upload\n          }\n        }\n      }\n      if (result.isTruncated) {\n        keyMarker = result.nextKeyMarker\n        uploadIdMarker = result.nextUploadIdMarker\n        continue\n      }\n\n      break\n    }\n    return latestUpload?.uploadId\n  }\n\n  /**\n   * this call will aggregate the parts on the server into a single object.\n   */\n  async completeMultipartUpload(\n    bucketName: string,\n    objectName: string,\n    uploadId: string,\n    etags: {\n      part: number\n      etag?: string\n    }[],\n  ): Promise<{ etag: string; versionId: string | null }> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!isObject(etags)) {\n      throw new TypeError('etags should be of type \"Array\"')\n    }\n\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    const method = 'POST'\n    const query = `uploadId=${uriEscape(uploadId)}`\n\n    const builder = new xml2js.Builder()\n    const payload = builder.buildObject({\n      CompleteMultipartUpload: {\n        $: {\n          xmlns: 'http://s3.amazonaws.com/doc/2006-03-01/',\n        },\n        Part: etags.map((etag) => {\n          return {\n            PartNumber: etag.part,\n            ETag: etag.etag,\n          }\n        }),\n      },\n    })\n\n    const res = await this.makeRequestAsync({ method, bucketName, objectName, query }, payload)\n    const body = await readAsBuffer(res)\n    const result = parseCompleteMultipart(body.toString())\n    if (!result) {\n      throw new Error('BUG: failed to parse server response')\n    }\n\n    if (result.errCode) {\n      // Multipart Complete API returns an error XML after a 200 http status\n      throw new errors.S3Error(result.errMessage)\n    }\n\n    return {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      etag: result.etag as string,\n      versionId: getVersionId(res.headers as ResponseHeader),\n    }\n  }\n\n  /**\n   * Get part-info of all parts of an incomplete upload specified by uploadId.\n   */\n  protected async listParts(bucketName: string, objectName: string, uploadId: string): Promise<UploadedPart[]> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    const parts: UploadedPart[] = []\n    let marker = 0\n    let result\n    do {\n      result = await this.listPartsQuery(bucketName, objectName, uploadId, marker)\n      marker = result.marker\n      parts.push(...result.parts)\n    } while (result.isTruncated)\n\n    return parts\n  }\n\n  /**\n   * Called by listParts to fetch a batch of part-info\n   */\n  private async listPartsQuery(bucketName: string, objectName: string, uploadId: string, marker: number) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!isNumber(marker)) {\n      throw new TypeError('marker should be of type \"number\"')\n    }\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    let query = `uploadId=${uriEscape(uploadId)}`\n    if (marker) {\n      query += `&part-number-marker=${marker}`\n    }\n\n    const method = 'GET'\n    const res = await this.makeRequestAsync({ method, bucketName, objectName, query })\n    return xmlParsers.parseListParts(await readAsString(res))\n  }\n\n  async listBuckets(): Promise<BucketItemFromList[]> {\n    const method = 'GET'\n    const regionConf = this.region || DEFAULT_REGION\n    const httpRes = await this.makeRequestAsync({ method }, '', [200], regionConf)\n    const xmlResult = await readAsString(httpRes)\n    return xmlParsers.parseListBucket(xmlResult)\n  }\n\n  /**\n   * Calculate part size given the object size. Part size will be atleast this.partSize\n   */\n  calculatePartSize(size: number) {\n    if (!isNumber(size)) {\n      throw new TypeError('size should be of type \"number\"')\n    }\n    if (size > this.maxObjectSize) {\n      throw new TypeError(`size should not be more than ${this.maxObjectSize}`)\n    }\n    if (this.overRidePartSize) {\n      return this.partSize\n    }\n    let partSize = this.partSize\n    for (;;) {\n      // while(true) {...} throws linting error.\n      // If partSize is big enough to accomodate the object size, then use it.\n      if (partSize * 10000 > size) {\n        return partSize\n      }\n      // Try part sizes as 64MB, 80MB, 96MB etc.\n      partSize += 16 * 1024 * 1024\n    }\n  }\n\n  /**\n   * Uploads the object using contents from a file\n   */\n  async fPutObject(bucketName: string, objectName: string, filePath: string, metaData?: ObjectMetaData) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isString(filePath)) {\n      throw new TypeError('filePath should be of type \"string\"')\n    }\n    if (metaData && !isObject(metaData)) {\n      throw new TypeError('metaData should be of type \"object\"')\n    }\n\n    // Inserts correct `content-type` attribute based on metaData and filePath\n    metaData = insertContentType(metaData || {}, filePath)\n    const stat = await fsp.stat(filePath)\n    return await this.putObject(bucketName, objectName, fs.createReadStream(filePath), stat.size, metaData)\n  }\n\n  /**\n   *  Uploading a stream, \"Buffer\" or \"string\".\n   *  It's recommended to pass `size` argument with stream.\n   */\n  async putObject(\n    bucketName: string,\n    objectName: string,\n    stream: stream.Readable | Buffer | string,\n    size?: number,\n    metaData?: ItemBucketMetadata,\n  ): Promise<UploadedObjectInfo> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    // We'll need to shift arguments to the left because of metaData\n    // and size being optional.\n    if (isObject(size)) {\n      metaData = size\n    }\n    // Ensures Metadata has appropriate prefix for A3 API\n    const headers = prependXAMZMeta(metaData)\n    if (typeof stream === 'string' || stream instanceof Buffer) {\n      // Adapts the non-stream interface into a stream.\n      size = stream.length\n      stream = readableStream(stream)\n    } else if (!isReadableStream(stream)) {\n      throw new TypeError('third argument should be of type \"stream.Readable\" or \"Buffer\" or \"string\"')\n    }\n\n    if (isNumber(size) && size < 0) {\n      throw new errors.InvalidArgumentError(`size cannot be negative, given size: ${size}`)\n    }\n\n    // Get the part size and forward that to the BlockStream. Default to the\n    // largest block size possible if necessary.\n    if (!isNumber(size)) {\n      size = this.maxObjectSize\n    }\n\n    // Get the part size and forward that to the BlockStream. Default to the\n    // largest block size possible if necessary.\n    if (size === undefined) {\n      const statSize = await getContentLength(stream)\n      if (statSize !== null) {\n        size = statSize\n      }\n    }\n\n    if (!isNumber(size)) {\n      // Backward compatibility\n      size = this.maxObjectSize\n    }\n    if (size === 0) {\n      return this.uploadBuffer(bucketName, objectName, headers, Buffer.from(''))\n    }\n\n    const partSize = this.calculatePartSize(size)\n    if (typeof stream === 'string' || Buffer.isBuffer(stream) || size <= partSize) {\n      const buf = isReadableStream(stream) ? await readAsBuffer(stream) : Buffer.from(stream)\n      return this.uploadBuffer(bucketName, objectName, headers, buf)\n    }\n\n    return this.uploadStream(bucketName, objectName, headers, stream, partSize)\n  }\n\n  /**\n   * method to upload buffer in one call\n   * @private\n   */\n  private async uploadBuffer(\n    bucketName: string,\n    objectName: string,\n    headers: RequestHeaders,\n    buf: Buffer,\n  ): Promise<UploadedObjectInfo> {\n    const { md5sum, sha256sum } = hashBinary(buf, this.enableSHA256)\n    headers['Content-Length'] = buf.length\n    if (!this.enableSHA256) {\n      headers['Content-MD5'] = md5sum\n    }\n    const res = await this.makeRequestStreamAsync(\n      {\n        method: 'PUT',\n        bucketName,\n        objectName,\n        headers,\n      },\n      buf,\n      sha256sum,\n      [200],\n      '',\n    )\n    await drainResponse(res)\n    return {\n      etag: sanitizeETag(res.headers.etag),\n      versionId: getVersionId(res.headers as ResponseHeader),\n    }\n  }\n\n  /**\n   * upload stream with MultipartUpload\n   * @private\n   */\n  private async uploadStream(\n    bucketName: string,\n    objectName: string,\n    headers: RequestHeaders,\n    body: stream.Readable,\n    partSize: number,\n  ): Promise<UploadedObjectInfo> {\n    // A map of the previously uploaded chunks, for resuming a file upload. This\n    // will be null if we aren't resuming an upload.\n    const oldParts: Record<number, Part> = {}\n\n    // Keep track of the etags for aggregating the chunks together later. Each\n    // etag represents a single chunk of the file.\n    const eTags: Part[] = []\n\n    const previousUploadId = await this.findUploadId(bucketName, objectName)\n    let uploadId: string\n    if (!previousUploadId) {\n      uploadId = await this.initiateNewMultipartUpload(bucketName, objectName, headers)\n    } else {\n      uploadId = previousUploadId\n      const oldTags = await this.listParts(bucketName, objectName, previousUploadId)\n      oldTags.forEach((e) => {\n        oldParts[e.part] = e\n      })\n    }\n\n    const chunkier = new BlockStream2({ size: partSize, zeroPadding: false })\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const [_, o] = await Promise.all([\n      new Promise((resolve, reject) => {\n        body.pipe(chunkier).on('error', reject)\n        chunkier.on('end', resolve).on('error', reject)\n      }),\n      (async () => {\n        let partNumber = 1\n\n        for await (const chunk of chunkier) {\n          const md5 = crypto.createHash('md5').update(chunk).digest()\n\n          const oldPart = oldParts[partNumber]\n          if (oldPart) {\n            if (oldPart.etag === md5.toString('hex')) {\n              eTags.push({ part: partNumber, etag: oldPart.etag })\n              partNumber++\n              continue\n            }\n          }\n\n          partNumber++\n\n          // now start to upload missing part\n          const options: RequestOption = {\n            method: 'PUT',\n            query: qs.stringify({ partNumber, uploadId }),\n            headers: {\n              'Content-Length': chunk.length,\n              'Content-MD5': md5.toString('base64'),\n            },\n            bucketName,\n            objectName,\n          }\n\n          const response = await this.makeRequestAsyncOmit(options, chunk)\n\n          let etag = response.headers.etag\n          if (etag) {\n            etag = etag.replace(/^\"/, '').replace(/\"$/, '')\n          } else {\n            etag = ''\n          }\n\n          eTags.push({ part: partNumber, etag })\n        }\n\n        return await this.completeMultipartUpload(bucketName, objectName, uploadId, eTags)\n      })(),\n    ])\n\n    return o\n  }\n\n  async removeBucketReplication(bucketName: string): Promise<void>\n  removeBucketReplication(bucketName: string, callback: NoResultCallback): void\n  async removeBucketReplication(bucketName: string): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'replication'\n    await this.makeRequestAsyncOmit({ method, bucketName, query }, '', [200, 204], '')\n  }\n\n  setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts): void\n  async setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts): Promise<void>\n  async setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(replicationConfig)) {\n      throw new errors.InvalidArgumentError('replicationConfig should be of type \"object\"')\n    } else {\n      if (_.isEmpty(replicationConfig.role)) {\n        throw new errors.InvalidArgumentError('Role cannot be empty')\n      } else if (replicationConfig.role && !isString(replicationConfig.role)) {\n        throw new errors.InvalidArgumentError('Invalid value for role', replicationConfig.role)\n      }\n      if (_.isEmpty(replicationConfig.rules)) {\n        throw new errors.InvalidArgumentError('Minimum one replication rule must be specified')\n      }\n    }\n    const method = 'PUT'\n    const query = 'replication'\n    const headers: Record<string, string> = {}\n\n    const replicationParamsConfig = {\n      ReplicationConfiguration: {\n        Role: replicationConfig.role,\n        Rule: replicationConfig.rules,\n      },\n    }\n\n    const builder = new xml2js.Builder({ renderOpts: { pretty: false }, headless: true })\n    const payload = builder.buildObject(replicationParamsConfig)\n    headers['Content-MD5'] = toMd5(payload)\n    await this.makeRequestAsyncOmit({ method, bucketName, query, headers }, payload)\n  }\n\n  getBucketReplication(bucketName: string): void\n  async getBucketReplication(bucketName: string): Promise<ReplicationConfig>\n  async getBucketReplication(bucketName: string) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'replication'\n\n    const httpRes = await this.makeRequestAsync({ method, bucketName, query }, '', [200, 204])\n    const xmlResult = await readAsString(httpRes)\n    return xmlParsers.parseReplicationConfig(xmlResult)\n  }\n\n  getObjectLegalHold(\n    bucketName: string,\n    objectName: string,\n    getOpts?: GetObjectLegalHoldOptions,\n    callback?: ResultCallback<LEGAL_HOLD_STATUS>,\n  ): Promise<LEGAL_HOLD_STATUS>\n  async getObjectLegalHold(\n    bucketName: string,\n    objectName: string,\n    getOpts?: GetObjectLegalHoldOptions,\n  ): Promise<LEGAL_HOLD_STATUS> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (getOpts) {\n      if (!isObject(getOpts)) {\n        throw new TypeError('getOpts should be of type \"Object\"')\n      } else if (Object.keys(getOpts).length > 0 && getOpts.versionId && !isString(getOpts.versionId)) {\n        throw new TypeError('versionId should be of type string.:', getOpts.versionId)\n      }\n    }\n\n    const method = 'GET'\n    let query = 'legal-hold'\n\n    if (getOpts?.versionId) {\n      query += `&versionId=${getOpts.versionId}`\n    }\n\n    const httpRes = await this.makeRequestAsync({ method, bucketName, objectName, query }, '', [200])\n    const strRes = await readAsString(httpRes)\n    return parseObjectLegalHoldConfig(strRes)\n  }\n\n  setObjectLegalHold(bucketName: string, objectName: string, setOpts?: PutObjectLegalHoldOptions): void\n  async setObjectLegalHold(\n    bucketName: string,\n    objectName: string,\n    setOpts = {\n      status: LEGAL_HOLD_STATUS.ENABLED,\n    } as PutObjectLegalHoldOptions,\n  ): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isObject(setOpts)) {\n      throw new TypeError('setOpts should be of type \"Object\"')\n    } else {\n      if (![LEGAL_HOLD_STATUS.ENABLED, LEGAL_HOLD_STATUS.DISABLED].includes(setOpts?.status)) {\n        throw new TypeError('Invalid status: ' + setOpts.status)\n      }\n      if (setOpts.versionId && !setOpts.versionId.length) {\n        throw new TypeError('versionId should be of type string.:' + setOpts.versionId)\n      }\n    }\n\n    const method = 'PUT'\n    let query = 'legal-hold'\n\n    if (setOpts.versionId) {\n      query += `&versionId=${setOpts.versionId}`\n    }\n\n    const config = {\n      Status: setOpts.status,\n    }\n\n    const builder = new xml2js.Builder({ rootName: 'LegalHold', renderOpts: { pretty: false }, headless: true })\n    const payload = builder.buildObject(config)\n    const headers: Record<string, string> = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    await this.makeRequestAsyncOmit({ method, bucketName, objectName, query, headers }, payload)\n  }\n\n  /**\n   * Get Tags associated with a Bucket\n   */\n  async getBucketTagging(bucketName: string): Promise<Tag[]> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n\n    const method = 'GET'\n    const query = 'tagging'\n    const requestOptions = { method, bucketName, query }\n\n    const response = await this.makeRequestAsync(requestOptions)\n    const body = await readAsString(response)\n    return xmlParsers.parseTagging(body)\n  }\n\n  /**\n   *  Get the tags associated with a bucket OR an object\n   */\n  async getObjectTagging(bucketName: string, objectName: string, getOpts?: GetObjectOpts): Promise<Tag[]> {\n    const method = 'GET'\n    let query = 'tagging'\n\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n    if (getOpts && !isObject(getOpts)) {\n      throw new errors.InvalidArgumentError('getOpts should be of type \"object\"')\n    }\n\n    if (getOpts && getOpts.versionId) {\n      query = `${query}&versionId=${getOpts.versionId}`\n    }\n    const requestOptions: RequestOption = { method, bucketName, query }\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n\n    const response = await this.makeRequestAsync(requestOptions)\n    const body = await readAsString(response)\n    return xmlParsers.parseTagging(body)\n  }\n\n  /**\n   *  Set the policy on a bucket or an object prefix.\n   */\n  async setBucketPolicy(bucketName: string, policy: string): Promise<void> {\n    // Validate arguments.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isString(policy)) {\n      throw new errors.InvalidBucketPolicyError(`Invalid bucket policy: ${policy} - must be \"string\"`)\n    }\n\n    const query = 'policy'\n\n    let method = 'DELETE'\n    if (policy) {\n      method = 'PUT'\n    }\n\n    await this.makeRequestAsyncOmit({ method, bucketName, query }, policy, [204], '')\n  }\n\n  /**\n   * Get the policy on a bucket or an object prefix.\n   */\n  async getBucketPolicy(bucketName: string): Promise<string> {\n    // Validate arguments.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n\n    const method = 'GET'\n    const query = 'policy'\n    const res = await this.makeRequestAsync({ method, bucketName, query })\n    return await readAsString(res)\n  }\n\n  async putObjectRetention(bucketName: string, objectName: string, retentionOpts: Retention = {}): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(retentionOpts)) {\n      throw new errors.InvalidArgumentError('retentionOpts should be of type \"object\"')\n    } else {\n      if (retentionOpts.governanceBypass && !isBoolean(retentionOpts.governanceBypass)) {\n        throw new errors.InvalidArgumentError(`Invalid value for governanceBypass: ${retentionOpts.governanceBypass}`)\n      }\n      if (\n        retentionOpts.mode &&\n        ![RETENTION_MODES.COMPLIANCE, RETENTION_MODES.GOVERNANCE].includes(retentionOpts.mode)\n      ) {\n        throw new errors.InvalidArgumentError(`Invalid object retention mode: ${retentionOpts.mode}`)\n      }\n      if (retentionOpts.retainUntilDate && !isString(retentionOpts.retainUntilDate)) {\n        throw new errors.InvalidArgumentError(`Invalid value for retainUntilDate: ${retentionOpts.retainUntilDate}`)\n      }\n      if (retentionOpts.versionId && !isString(retentionOpts.versionId)) {\n        throw new errors.InvalidArgumentError(`Invalid value for versionId: ${retentionOpts.versionId}`)\n      }\n    }\n\n    const method = 'PUT'\n    let query = 'retention'\n\n    const headers: RequestHeaders = {}\n    if (retentionOpts.governanceBypass) {\n      headers['X-Amz-Bypass-Governance-Retention'] = true\n    }\n\n    const builder = new xml2js.Builder({ rootName: 'Retention', renderOpts: { pretty: false }, headless: true })\n    const params: Record<string, string> = {}\n\n    if (retentionOpts.mode) {\n      params.Mode = retentionOpts.mode\n    }\n    if (retentionOpts.retainUntilDate) {\n      params.RetainUntilDate = retentionOpts.retainUntilDate\n    }\n    if (retentionOpts.versionId) {\n      query += `&versionId=${retentionOpts.versionId}`\n    }\n\n    const payload = builder.buildObject(params)\n\n    headers['Content-MD5'] = toMd5(payload)\n    await this.makeRequestAsyncOmit({ method, bucketName, objectName, query, headers }, payload, [200, 204])\n  }\n\n  getObjectLockConfig(bucketName: string, callback: ResultCallback<ObjectLockInfo>): void\n  getObjectLockConfig(bucketName: string): void\n  async getObjectLockConfig(bucketName: string): Promise<ObjectLockInfo>\n  async getObjectLockConfig(bucketName: string) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'object-lock'\n\n    const httpRes = await this.makeRequestAsync({ method, bucketName, query })\n    const xmlResult = await readAsString(httpRes)\n    return xmlParsers.parseObjectLockConfig(xmlResult)\n  }\n\n  setObjectLockConfig(bucketName: string, lockConfigOpts: Omit<ObjectLockInfo, 'objectLockEnabled'>): void\n  async setObjectLockConfig(\n    bucketName: string,\n    lockConfigOpts: Omit<ObjectLockInfo, 'objectLockEnabled'>,\n  ): Promise<void>\n  async setObjectLockConfig(bucketName: string, lockConfigOpts: Omit<ObjectLockInfo, 'objectLockEnabled'>) {\n    const retentionModes = [RETENTION_MODES.COMPLIANCE, RETENTION_MODES.GOVERNANCE]\n    const validUnits = [RETENTION_VALIDITY_UNITS.DAYS, RETENTION_VALIDITY_UNITS.YEARS]\n\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n\n    if (lockConfigOpts.mode && !retentionModes.includes(lockConfigOpts.mode)) {\n      throw new TypeError(`lockConfigOpts.mode should be one of ${retentionModes}`)\n    }\n    if (lockConfigOpts.unit && !validUnits.includes(lockConfigOpts.unit)) {\n      throw new TypeError(`lockConfigOpts.unit should be one of ${validUnits}`)\n    }\n    if (lockConfigOpts.validity && !isNumber(lockConfigOpts.validity)) {\n      throw new TypeError(`lockConfigOpts.validity should be a number`)\n    }\n\n    const method = 'PUT'\n    const query = 'object-lock'\n\n    const config: ObjectLockConfigParam = {\n      ObjectLockEnabled: 'Enabled',\n    }\n    const configKeys = Object.keys(lockConfigOpts)\n\n    const isAllKeysSet = ['unit', 'mode', 'validity'].every((lck) => configKeys.includes(lck))\n    // Check if keys are present and all keys are present.\n    if (configKeys.length > 0) {\n      if (!isAllKeysSet) {\n        throw new TypeError(\n          `lockConfigOpts.mode,lockConfigOpts.unit,lockConfigOpts.validity all the properties should be specified.`,\n        )\n      } else {\n        config.Rule = {\n          DefaultRetention: {},\n        }\n        if (lockConfigOpts.mode) {\n          config.Rule.DefaultRetention.Mode = lockConfigOpts.mode\n        }\n        if (lockConfigOpts.unit === RETENTION_VALIDITY_UNITS.DAYS) {\n          config.Rule.DefaultRetention.Days = lockConfigOpts.validity\n        } else if (lockConfigOpts.unit === RETENTION_VALIDITY_UNITS.YEARS) {\n          config.Rule.DefaultRetention.Years = lockConfigOpts.validity\n        }\n      }\n    }\n\n    const builder = new xml2js.Builder({\n      rootName: 'ObjectLockConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n\n    const headers: RequestHeaders = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    await this.makeRequestAsyncOmit({ method, bucketName, query, headers }, payload)\n  }\n\n  async getBucketVersioning(bucketName: string): Promise<BucketVersioningConfiguration> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'versioning'\n\n    const httpRes = await this.makeRequestAsync({ method, bucketName, query })\n    const xmlResult = await readAsString(httpRes)\n    return await xmlParsers.parseBucketVersioningConfig(xmlResult)\n  }\n\n  async setBucketVersioning(bucketName: string, versionConfig: BucketVersioningConfiguration): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!Object.keys(versionConfig).length) {\n      throw new errors.InvalidArgumentError('versionConfig should be of type \"object\"')\n    }\n\n    const method = 'PUT'\n    const query = 'versioning'\n    const builder = new xml2js.Builder({\n      rootName: 'VersioningConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(versionConfig)\n\n    await this.makeRequestAsyncOmit({ method, bucketName, query }, payload)\n  }\n\n  private async setTagging(taggingParams: PutTaggingParams): Promise<void> {\n    const { bucketName, objectName, tags, putOpts } = taggingParams\n    const method = 'PUT'\n    let query = 'tagging'\n\n    if (putOpts && putOpts?.versionId) {\n      query = `${query}&versionId=${putOpts.versionId}`\n    }\n    const tagsList = []\n    for (const [key, value] of Object.entries(tags)) {\n      tagsList.push({ Key: key, Value: value })\n    }\n    const taggingConfig = {\n      Tagging: {\n        TagSet: {\n          Tag: tagsList,\n        },\n      },\n    }\n    const headers = {} as RequestHeaders\n    const builder = new xml2js.Builder({ headless: true, renderOpts: { pretty: false } })\n    const payloadBuf = Buffer.from(builder.buildObject(taggingConfig))\n    const requestOptions = {\n      method,\n      bucketName,\n      query,\n      headers,\n\n      ...(objectName && { objectName: objectName }),\n    }\n\n    headers['Content-MD5'] = toMd5(payloadBuf)\n\n    await this.makeRequestAsyncOmit(requestOptions, payloadBuf)\n  }\n\n  private async removeTagging({ bucketName, objectName, removeOpts }: RemoveTaggingParams): Promise<void> {\n    const method = 'DELETE'\n    let query = 'tagging'\n\n    if (removeOpts && Object.keys(removeOpts).length && removeOpts.versionId) {\n      query = `${query}&versionId=${removeOpts.versionId}`\n    }\n    const requestOptions = { method, bucketName, objectName, query }\n\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n    await this.makeRequestAsync(requestOptions, '', [200, 204])\n  }\n\n  async setBucketTagging(bucketName: string, tags: Tags): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isPlainObject(tags)) {\n      throw new errors.InvalidArgumentError('tags should be of type \"object\"')\n    }\n    if (Object.keys(tags).length > 10) {\n      throw new errors.InvalidArgumentError('maximum tags allowed is 10\"')\n    }\n\n    await this.setTagging({ bucketName, tags })\n  }\n\n  async removeBucketTagging(bucketName: string) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    await this.removeTagging({ bucketName })\n  }\n\n  async setObjectTagging(bucketName: string, objectName: string, tags: Tags, putOpts?: TaggingOpts) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n\n    if (!isPlainObject(tags)) {\n      throw new errors.InvalidArgumentError('tags should be of type \"object\"')\n    }\n    if (Object.keys(tags).length > 10) {\n      throw new errors.InvalidArgumentError('Maximum tags allowed is 10\"')\n    }\n\n    await this.setTagging({ bucketName, objectName, tags, putOpts })\n  }\n\n  async removeObjectTagging(bucketName: string, objectName: string, removeOpts: TaggingOpts) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n    if (removeOpts && Object.keys(removeOpts).length && !isObject(removeOpts)) {\n      throw new errors.InvalidArgumentError('removeOpts should be of type \"object\"')\n    }\n\n    await this.removeTagging({ bucketName, objectName, removeOpts })\n  }\n\n  async selectObjectContent(\n    bucketName: string,\n    objectName: string,\n    selectOpts: SelectOptions,\n  ): Promise<SelectResults | undefined> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!_.isEmpty(selectOpts)) {\n      if (!isString(selectOpts.expression)) {\n        throw new TypeError('sqlExpression should be of type \"string\"')\n      }\n      if (!_.isEmpty(selectOpts.inputSerialization)) {\n        if (!isObject(selectOpts.inputSerialization)) {\n          throw new TypeError('inputSerialization should be of type \"object\"')\n        }\n      } else {\n        throw new TypeError('inputSerialization is required')\n      }\n      if (!_.isEmpty(selectOpts.outputSerialization)) {\n        if (!isObject(selectOpts.outputSerialization)) {\n          throw new TypeError('outputSerialization should be of type \"object\"')\n        }\n      } else {\n        throw new TypeError('outputSerialization is required')\n      }\n    } else {\n      throw new TypeError('valid select configuration is required')\n    }\n\n    const method = 'POST'\n    const query = `select&select-type=2`\n\n    const config: Record<string, unknown>[] = [\n      {\n        Expression: selectOpts.expression,\n      },\n      {\n        ExpressionType: selectOpts.expressionType || 'SQL',\n      },\n      {\n        InputSerialization: [selectOpts.inputSerialization],\n      },\n      {\n        OutputSerialization: [selectOpts.outputSerialization],\n      },\n    ]\n\n    // Optional\n    if (selectOpts.requestProgress) {\n      config.push({ RequestProgress: selectOpts?.requestProgress })\n    }\n    // Optional\n    if (selectOpts.scanRange) {\n      config.push({ ScanRange: selectOpts.scanRange })\n    }\n\n    const builder = new xml2js.Builder({\n      rootName: 'SelectObjectContentRequest',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n\n    const res = await this.makeRequestAsync({ method, bucketName, objectName, query }, payload)\n    const body = await readAsBuffer(res)\n    return parseSelectObjectContentResponse(body)\n  }\n\n  private async applyBucketLifecycle(bucketName: string, policyConfig: LifeCycleConfigParam): Promise<void> {\n    const method = 'PUT'\n    const query = 'lifecycle'\n\n    const headers: RequestHeaders = {}\n    const builder = new xml2js.Builder({\n      rootName: 'LifecycleConfiguration',\n      headless: true,\n      renderOpts: { pretty: false },\n    })\n    const payload = builder.buildObject(policyConfig)\n    headers['Content-MD5'] = toMd5(payload)\n\n    await this.makeRequestAsyncOmit({ method, bucketName, query, headers }, payload)\n  }\n\n  async removeBucketLifecycle(bucketName: string): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'lifecycle'\n    await this.makeRequestAsyncOmit({ method, bucketName, query }, '', [204])\n  }\n\n  async setBucketLifecycle(bucketName: string, lifeCycleConfig: LifeCycleConfigParam): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (_.isEmpty(lifeCycleConfig)) {\n      await this.removeBucketLifecycle(bucketName)\n    } else {\n      await this.applyBucketLifecycle(bucketName, lifeCycleConfig)\n    }\n  }\n\n  async getBucketLifecycle(bucketName: string): Promise<LifecycleConfig | null> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'lifecycle'\n\n    const res = await this.makeRequestAsync({ method, bucketName, query })\n    const body = await readAsString(res)\n    return xmlParsers.parseLifecycleConfig(body)\n  }\n\n  async setBucketEncryption(bucketName: string, encryptionConfig?: EncryptionConfig): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!_.isEmpty(encryptionConfig) && encryptionConfig.Rule.length > 1) {\n      throw new errors.InvalidArgumentError('Invalid Rule length. Only one rule is allowed.: ' + encryptionConfig.Rule)\n    }\n\n    let encryptionObj = encryptionConfig\n    if (_.isEmpty(encryptionConfig)) {\n      encryptionObj = {\n        // Default Hanzo S3 Server Supported Rule\n        Rule: [\n          {\n            ApplyServerSideEncryptionByDefault: {\n              SSEAlgorithm: 'AES256',\n            },\n          },\n        ],\n      }\n    }\n\n    const method = 'PUT'\n    const query = 'encryption'\n    const builder = new xml2js.Builder({\n      rootName: 'ServerSideEncryptionConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(encryptionObj)\n\n    const headers: RequestHeaders = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    await this.makeRequestAsyncOmit({ method, bucketName, query, headers }, payload)\n  }\n\n  async getBucketEncryption(bucketName: string) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'encryption'\n\n    const res = await this.makeRequestAsync({ method, bucketName, query })\n    const body = await readAsString(res)\n    return xmlParsers.parseBucketEncryptionConfig(body)\n  }\n\n  async removeBucketEncryption(bucketName: string) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'encryption'\n\n    await this.makeRequestAsyncOmit({ method, bucketName, query }, '', [204])\n  }\n\n  async getObjectRetention(\n    bucketName: string,\n    objectName: string,\n    getOpts?: GetObjectRetentionOpts,\n  ): Promise<ObjectRetentionInfo | null | undefined> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (getOpts && !isObject(getOpts)) {\n      throw new errors.InvalidArgumentError('getOpts should be of type \"object\"')\n    } else if (getOpts?.versionId && !isString(getOpts.versionId)) {\n      throw new errors.InvalidArgumentError('versionId should be of type \"string\"')\n    }\n\n    const method = 'GET'\n    let query = 'retention'\n    if (getOpts?.versionId) {\n      query += `&versionId=${getOpts.versionId}`\n    }\n    const res = await this.makeRequestAsync({ method, bucketName, objectName, query })\n    const body = await readAsString(res)\n    return xmlParsers.parseObjectRetentionConfig(body)\n  }\n\n  async removeObjects(bucketName: string, objectsList: RemoveObjectsParam): Promise<RemoveObjectsResponse[]> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!Array.isArray(objectsList)) {\n      throw new errors.InvalidArgumentError('objectsList should be a list')\n    }\n\n    const runDeleteObjects = async (batch: RemoveObjectsParam): Promise<RemoveObjectsResponse[]> => {\n      const delObjects: RemoveObjectsRequestEntry[] = batch.map((value) => {\n        return isObject(value) ? { Key: value.name, VersionId: value.versionId } : { Key: value }\n      })\n\n      const remObjects = { Delete: { Quiet: true, Object: delObjects } }\n      const payload = Buffer.from(new xml2js.Builder({ headless: true }).buildObject(remObjects))\n      const headers: RequestHeaders = { 'Content-MD5': toMd5(payload) }\n\n      const res = await this.makeRequestAsync({ method: 'POST', bucketName, query: 'delete', headers }, payload)\n      const body = await readAsString(res)\n      return xmlParsers.removeObjectsParser(body)\n    }\n\n    const maxEntries = 1000 // max entries accepted in server for DeleteMultipleObjects API.\n    // Client side batching\n    const batches = []\n    for (let i = 0; i < objectsList.length; i += maxEntries) {\n      batches.push(objectsList.slice(i, i + maxEntries))\n    }\n\n    const batchResults = await Promise.all(batches.map(runDeleteObjects))\n    return batchResults.flat()\n  }\n\n  async removeIncompleteUpload(bucketName: string, objectName: string): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.IsValidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    const removeUploadId = await this.findUploadId(bucketName, objectName)\n    const method = 'DELETE'\n    const query = `uploadId=${removeUploadId}`\n    await this.makeRequestAsyncOmit({ method, bucketName, objectName, query }, '', [204])\n  }\n\n  private async copyObjectV1(\n    targetBucketName: string,\n    targetObjectName: string,\n    sourceBucketNameAndObjectName: string,\n    conditions?: null | CopyConditions,\n  ) {\n    if (typeof conditions == 'function') {\n      conditions = null\n    }\n\n    if (!isValidBucketName(targetBucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + targetBucketName)\n    }\n    if (!isValidObjectName(targetObjectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${targetObjectName}`)\n    }\n    if (!isString(sourceBucketNameAndObjectName)) {\n      throw new TypeError('sourceBucketNameAndObjectName should be of type \"string\"')\n    }\n    if (sourceBucketNameAndObjectName === '') {\n      throw new errors.InvalidPrefixError(`Empty source prefix`)\n    }\n\n    if (conditions != null && !(conditions instanceof CopyConditions)) {\n      throw new TypeError('conditions should be of type \"CopyConditions\"')\n    }\n\n    const headers: RequestHeaders = {}\n    headers['x-amz-copy-source'] = uriResourceEscape(sourceBucketNameAndObjectName)\n\n    if (conditions) {\n      if (conditions.modified !== '') {\n        headers['x-amz-copy-source-if-modified-since'] = conditions.modified\n      }\n      if (conditions.unmodified !== '') {\n        headers['x-amz-copy-source-if-unmodified-since'] = conditions.unmodified\n      }\n      if (conditions.matchETag !== '') {\n        headers['x-amz-copy-source-if-match'] = conditions.matchETag\n      }\n      if (conditions.matchETagExcept !== '') {\n        headers['x-amz-copy-source-if-none-match'] = conditions.matchETagExcept\n      }\n    }\n\n    const method = 'PUT'\n\n    const res = await this.makeRequestAsync({\n      method,\n      bucketName: targetBucketName,\n      objectName: targetObjectName,\n      headers,\n    })\n    const body = await readAsString(res)\n    return xmlParsers.parseCopyObject(body)\n  }\n\n  private async copyObjectV2(\n    sourceConfig: CopySourceOptions,\n    destConfig: CopyDestinationOptions,\n  ): Promise<CopyObjectResultV2> {\n    if (!(sourceConfig instanceof CopySourceOptions)) {\n      throw new errors.InvalidArgumentError('sourceConfig should of type CopySourceOptions ')\n    }\n    if (!(destConfig instanceof CopyDestinationOptions)) {\n      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ')\n    }\n    if (!destConfig.validate()) {\n      return Promise.reject()\n    }\n    if (!destConfig.validate()) {\n      return Promise.reject()\n    }\n\n    const headers = Object.assign({}, sourceConfig.getHeaders(), destConfig.getHeaders())\n\n    const bucketName = destConfig.Bucket\n    const objectName = destConfig.Object\n\n    const method = 'PUT'\n\n    const res = await this.makeRequestAsync({ method, bucketName, objectName, headers })\n    const body = await readAsString(res)\n    const copyRes = xmlParsers.parseCopyObject(body)\n    const resHeaders: IncomingHttpHeaders = res.headers\n\n    const sizeHeaderValue = resHeaders && resHeaders['content-length']\n    const size = typeof sizeHeaderValue === 'number' ? sizeHeaderValue : undefined\n\n    return {\n      Bucket: destConfig.Bucket,\n      Key: destConfig.Object,\n      LastModified: copyRes.lastModified,\n      MetaData: extractMetadata(resHeaders as ResponseHeader),\n      VersionId: getVersionId(resHeaders as ResponseHeader),\n      SourceVersionId: getSourceVersionId(resHeaders as ResponseHeader),\n      Etag: sanitizeETag(resHeaders.etag),\n      Size: size,\n    }\n  }\n\n  async copyObject(source: CopySourceOptions, dest: CopyDestinationOptions): Promise<CopyObjectResult>\n  async copyObject(\n    targetBucketName: string,\n    targetObjectName: string,\n    sourceBucketNameAndObjectName: string,\n    conditions?: CopyConditions,\n  ): Promise<CopyObjectResult>\n  async copyObject(...allArgs: CopyObjectParams): Promise<CopyObjectResult> {\n    if (typeof allArgs[0] === 'string') {\n      const [targetBucketName, targetObjectName, sourceBucketNameAndObjectName, conditions] = allArgs as [\n        string,\n        string,\n        string,\n        CopyConditions?,\n      ]\n      return await this.copyObjectV1(targetBucketName, targetObjectName, sourceBucketNameAndObjectName, conditions)\n    }\n    const [source, dest] = allArgs as [CopySourceOptions, CopyDestinationOptions]\n    return await this.copyObjectV2(source, dest)\n  }\n\n  async uploadPart(\n    partConfig: {\n      bucketName: string\n      objectName: string\n      uploadID: string\n      partNumber: number\n      headers: RequestHeaders\n    },\n    payload?: Binary,\n  ) {\n    const { bucketName, objectName, uploadID, partNumber, headers } = partConfig\n\n    const method = 'PUT'\n    const query = `uploadId=${uploadID}&partNumber=${partNumber}`\n    const requestOptions = { method, bucketName, objectName: objectName, query, headers }\n    const res = await this.makeRequestAsync(requestOptions, payload)\n    const body = await readAsString(res)\n    const partRes = uploadPartParser(body)\n    const partEtagVal = sanitizeETag(res.headers.etag) || sanitizeETag(partRes.ETag)\n    return {\n      etag: partEtagVal,\n      key: objectName,\n      part: partNumber,\n    }\n  }\n\n  async composeObject(\n    destObjConfig: CopyDestinationOptions,\n    sourceObjList: CopySourceOptions[],\n    { maxConcurrency = 10 } = {},\n  ): Promise<boolean | { etag: string; versionId: string | null } | Promise<void> | CopyObjectResult> {\n    const sourceFilesLength = sourceObjList.length\n\n    if (!Array.isArray(sourceObjList)) {\n      throw new errors.InvalidArgumentError('sourceConfig should an array of CopySourceOptions ')\n    }\n    if (!(destObjConfig instanceof CopyDestinationOptions)) {\n      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ')\n    }\n\n    if (sourceFilesLength < 1 || sourceFilesLength > PART_CONSTRAINTS.MAX_PARTS_COUNT) {\n      throw new errors.InvalidArgumentError(\n        `\"There must be as least one and up to ${PART_CONSTRAINTS.MAX_PARTS_COUNT} source objects.`,\n      )\n    }\n\n    for (let i = 0; i < sourceFilesLength; i++) {\n      const sObj = sourceObjList[i] as CopySourceOptions\n      if (!sObj.validate()) {\n        return false\n      }\n    }\n\n    if (!(destObjConfig as CopyDestinationOptions).validate()) {\n      return false\n    }\n\n    const getStatOptions = (srcConfig: CopySourceOptions) => {\n      let statOpts = {}\n      if (!_.isEmpty(srcConfig.VersionID)) {\n        statOpts = {\n          versionId: srcConfig.VersionID,\n        }\n      }\n      return statOpts\n    }\n    const srcObjectSizes: number[] = []\n    let totalSize = 0\n    let totalParts = 0\n\n    const sourceObjStats = sourceObjList.map((srcItem) =>\n      this.statObject(srcItem.Bucket, srcItem.Object, getStatOptions(srcItem)),\n    )\n\n    const srcObjectInfos = await Promise.all(sourceObjStats)\n\n    const validatedStats = srcObjectInfos.map((resItemStat, index) => {\n      const srcConfig: CopySourceOptions | undefined = sourceObjList[index]\n\n      let srcCopySize = resItemStat.size\n      // Check if a segment is specified, and if so, is the\n      // segment within object bounds?\n      if (srcConfig && srcConfig.MatchRange) {\n        // Since range is specified,\n        //    0 <= src.srcStart <= src.srcEnd\n        // so only invalid case to check is:\n        const srcStart = srcConfig.Start\n        const srcEnd = srcConfig.End\n        if (srcEnd >= srcCopySize || srcStart < 0) {\n          throw new errors.InvalidArgumentError(\n            `CopySrcOptions ${index} has invalid segment-to-copy [${srcStart}, ${srcEnd}] (size is ${srcCopySize})`,\n          )\n        }\n        srcCopySize = srcEnd - srcStart + 1\n      }\n\n      // Only the last source may be less than `absMinPartSize`\n      if (srcCopySize < PART_CONSTRAINTS.ABS_MIN_PART_SIZE && index < sourceFilesLength - 1) {\n        throw new errors.InvalidArgumentError(\n          `CopySrcOptions ${index} is too small (${srcCopySize}) and it is not the last part.`,\n        )\n      }\n\n      // Is data to copy too large?\n      totalSize += srcCopySize\n      if (totalSize > PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE) {\n        throw new errors.InvalidArgumentError(`Cannot compose an object of size ${totalSize} (> 5TiB)`)\n      }\n\n      // record source size\n      srcObjectSizes[index] = srcCopySize\n\n      // calculate parts needed for current source\n      totalParts += partsRequired(srcCopySize)\n      // Do we need more parts than we are allowed?\n      if (totalParts > PART_CONSTRAINTS.MAX_PARTS_COUNT) {\n        throw new errors.InvalidArgumentError(\n          `Your proposed compose object requires more than ${PART_CONSTRAINTS.MAX_PARTS_COUNT} parts`,\n        )\n      }\n\n      return resItemStat\n    })\n\n    if ((totalParts === 1 && totalSize <= PART_CONSTRAINTS.MAX_PART_SIZE) || totalSize === 0) {\n      return await this.copyObject(sourceObjList[0] as CopySourceOptions, destObjConfig) // use copyObjectV2\n    }\n\n    // preserve etag to avoid modification of object while copying.\n    for (let i = 0; i < sourceFilesLength; i++) {\n      ;(sourceObjList[i] as CopySourceOptions).MatchETag = (validatedStats[i] as BucketItemStat).etag\n    }\n\n    const splitPartSizeList = validatedStats.map((resItemStat, idx) => {\n      return calculateEvenSplits(srcObjectSizes[idx] as number, sourceObjList[idx] as CopySourceOptions)\n    })\n\n    const getUploadPartConfigList = (uploadId: string) => {\n      const uploadPartConfigList: UploadPartConfig[] = []\n\n      splitPartSizeList.forEach((splitSize, splitIndex: number) => {\n        if (splitSize) {\n          const { startIndex: startIdx, endIndex: endIdx, objInfo: objConfig } = splitSize\n\n          const partIndex = splitIndex + 1 // part index starts from 1.\n          const totalUploads = Array.from(startIdx)\n\n          const headers = (sourceObjList[splitIndex] as CopySourceOptions).getHeaders()\n\n          totalUploads.forEach((splitStart, upldCtrIdx) => {\n            const splitEnd = endIdx[upldCtrIdx]\n\n            const sourceObj = `${objConfig.Bucket}/${objConfig.Object}`\n            headers['x-amz-copy-source'] = `${sourceObj}`\n            headers['x-amz-copy-source-range'] = `bytes=${splitStart}-${splitEnd}`\n\n            const uploadPartConfig = {\n              bucketName: destObjConfig.Bucket,\n              objectName: destObjConfig.Object,\n              uploadID: uploadId,\n              partNumber: partIndex,\n              headers: headers,\n              sourceObj: sourceObj,\n            }\n\n            uploadPartConfigList.push(uploadPartConfig)\n          })\n        }\n      })\n\n      return uploadPartConfigList\n    }\n\n    const uploadAllParts = async (uploadList: UploadPartConfig[]) => {\n      const partUploads: Awaited<ReturnType<typeof this.uploadPart>>[] = []\n\n      // Process upload parts in batches to avoid too many concurrent requests\n      for (const batch of _.chunk(uploadList, maxConcurrency)) {\n        const batchResults = await Promise.all(batch.map((item) => this.uploadPart(item)))\n\n        partUploads.push(...batchResults)\n      }\n\n      // Process results here if needed\n      return partUploads\n    }\n\n    const performUploadParts = async (uploadId: string) => {\n      const uploadList = getUploadPartConfigList(uploadId)\n      const partsRes = await uploadAllParts(uploadList)\n      return partsRes.map((partCopy) => ({ etag: partCopy.etag, part: partCopy.part }))\n    }\n\n    const newUploadHeaders = destObjConfig.getHeaders()\n\n    const uploadId = await this.initiateNewMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, newUploadHeaders)\n    try {\n      const partsDone = await performUploadParts(uploadId)\n      return await this.completeMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId, partsDone)\n    } catch (err) {\n      return await this.abortMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId)\n    }\n  }\n\n  async presignedUrl(\n    method: string,\n    bucketName: string,\n    objectName: string,\n    expires?: number | PreSignRequestParams | undefined,\n    reqParams?: PreSignRequestParams | Date,\n    requestDate?: Date,\n  ): Promise<string> {\n    if (this.anonymous) {\n      throw new errors.AnonymousRequestError(`Presigned ${method} url cannot be generated for anonymous requests`)\n    }\n\n    if (!expires) {\n      expires = PRESIGN_EXPIRY_DAYS_MAX\n    }\n    if (!reqParams) {\n      reqParams = {}\n    }\n    if (!requestDate) {\n      requestDate = new Date()\n    }\n\n    // Type assertions\n    if (expires && typeof expires !== 'number') {\n      throw new TypeError('expires should be of type \"number\"')\n    }\n    if (reqParams && typeof reqParams !== 'object') {\n      throw new TypeError('reqParams should be of type \"object\"')\n    }\n    if ((requestDate && !(requestDate instanceof Date)) || (requestDate && isNaN(requestDate?.getTime()))) {\n      throw new TypeError('requestDate should be of type \"Date\" and valid')\n    }\n\n    const query = reqParams ? qs.stringify(reqParams) : undefined\n\n    try {\n      const region = await this.getBucketRegionAsync(bucketName)\n      await this.checkAndRefreshCreds()\n      const reqOptions = this.getRequestOptions({ method, region, bucketName, objectName, query })\n\n      return presignSignatureV4(\n        reqOptions,\n        this.accessKey,\n        this.secretKey,\n        this.sessionToken,\n        region,\n        requestDate,\n        expires,\n      )\n    } catch (err) {\n      if (err instanceof errors.InvalidBucketNameError) {\n        throw new errors.InvalidArgumentError(`Unable to get bucket region for ${bucketName}.`)\n      }\n\n      throw err\n    }\n  }\n\n  async presignedGetObject(\n    bucketName: string,\n    objectName: string,\n    expires?: number,\n    respHeaders?: PreSignRequestParams | Date,\n    requestDate?: Date,\n  ): Promise<string> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    const validRespHeaders = [\n      'response-content-type',\n      'response-content-language',\n      'response-expires',\n      'response-cache-control',\n      'response-content-disposition',\n      'response-content-encoding',\n    ]\n    validRespHeaders.forEach((header) => {\n      // @ts-ignore\n      if (respHeaders !== undefined && respHeaders[header] !== undefined && !isString(respHeaders[header])) {\n        throw new TypeError(`response header ${header} should be of type \"string\"`)\n      }\n    })\n    return this.presignedUrl('GET', bucketName, objectName, expires, respHeaders, requestDate)\n  }\n\n  async presignedPutObject(bucketName: string, objectName: string, expires?: number): Promise<string> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    return this.presignedUrl('PUT', bucketName, objectName, expires)\n  }\n\n  newPostPolicy(): PostPolicy {\n    return new PostPolicy()\n  }\n\n  async presignedPostPolicy(postPolicy: PostPolicy): Promise<PostPolicyResult> {\n    if (this.anonymous) {\n      throw new errors.AnonymousRequestError('Presigned POST policy cannot be generated for anonymous requests')\n    }\n    if (!isObject(postPolicy)) {\n      throw new TypeError('postPolicy should be of type \"object\"')\n    }\n    const bucketName = postPolicy.formData.bucket as string\n    try {\n      const region = await this.getBucketRegionAsync(bucketName)\n\n      const date = new Date()\n      const dateStr = makeDateLong(date)\n      await this.checkAndRefreshCreds()\n\n      if (!postPolicy.policy.expiration) {\n        // 'expiration' is mandatory field for S3.\n        // Set default expiration date of 7 days.\n        const expires = new Date()\n        expires.setSeconds(PRESIGN_EXPIRY_DAYS_MAX)\n        postPolicy.setExpires(expires)\n      }\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-date', dateStr])\n      postPolicy.formData['x-amz-date'] = dateStr\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-algorithm', 'AWS4-HMAC-SHA256'])\n      postPolicy.formData['x-amz-algorithm'] = 'AWS4-HMAC-SHA256'\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-credential', this.accessKey + '/' + getScope(region, date)])\n      postPolicy.formData['x-amz-credential'] = this.accessKey + '/' + getScope(region, date)\n\n      if (this.sessionToken) {\n        postPolicy.policy.conditions.push(['eq', '$x-amz-security-token', this.sessionToken])\n        postPolicy.formData['x-amz-security-token'] = this.sessionToken\n      }\n\n      const policyBase64 = Buffer.from(JSON.stringify(postPolicy.policy)).toString('base64')\n\n      postPolicy.formData.policy = policyBase64\n\n      postPolicy.formData['x-amz-signature'] = postPresignSignatureV4(region, date, this.secretKey, policyBase64)\n      const opts = {\n        region: region,\n        bucketName: bucketName,\n        method: 'POST',\n      }\n      const reqOptions = this.getRequestOptions(opts)\n      const portStr = this.port == 80 || this.port === 443 ? '' : `:${this.port.toString()}`\n      const urlStr = `${reqOptions.protocol}//${reqOptions.host}${portStr}${reqOptions.path}`\n      return { postURL: urlStr, formData: postPolicy.formData }\n    } catch (err) {\n      if (err instanceof errors.InvalidBucketNameError) {\n        throw new errors.InvalidArgumentError(`Unable to get bucket region for ${bucketName}.`)\n      }\n\n      throw err\n    }\n  }\n  // list a batch of objects\n  async listObjectsQuery(bucketName: string, prefix?: string, marker?: string, listQueryOpts?: ListObjectQueryOpts) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (marker && !isString(marker)) {\n      throw new TypeError('marker should be of type \"string\"')\n    }\n\n    if (listQueryOpts && !isObject(listQueryOpts)) {\n      throw new TypeError('listQueryOpts should be of type \"object\"')\n    }\n    let { Delimiter, MaxKeys, IncludeVersion, versionIdMarker, keyMarker } = listQueryOpts as ListObjectQueryOpts\n\n    if (!isString(Delimiter)) {\n      throw new TypeError('Delimiter should be of type \"string\"')\n    }\n    if (!isNumber(MaxKeys)) {\n      throw new TypeError('MaxKeys should be of type \"number\"')\n    }\n\n    const queries = []\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(Delimiter)}`)\n    queries.push(`encoding-type=url`)\n\n    if (IncludeVersion) {\n      queries.push(`versions`)\n    }\n\n    if (IncludeVersion) {\n      // v1 version listing..\n      if (keyMarker) {\n        queries.push(`key-marker=${keyMarker}`)\n      }\n      if (versionIdMarker) {\n        queries.push(`version-id-marker=${versionIdMarker}`)\n      }\n    } else if (marker) {\n      marker = uriEscape(marker)\n      queries.push(`marker=${marker}`)\n    }\n\n    // no need to escape maxKeys\n    if (MaxKeys) {\n      if (MaxKeys >= 1000) {\n        MaxKeys = 1000\n      }\n      queries.push(`max-keys=${MaxKeys}`)\n    }\n    queries.sort()\n    let query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n\n    const method = 'GET'\n    const res = await this.makeRequestAsync({ method, bucketName, query })\n    const body = await readAsString(res)\n    const listQryList = parseListObjects(body)\n    return listQryList\n  }\n\n  listObjects(\n    bucketName: string,\n    prefix?: string,\n    recursive?: boolean,\n    listOpts?: ListObjectQueryOpts | undefined,\n  ): BucketStream<ObjectInfo> {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (listOpts && !isObject(listOpts)) {\n      throw new TypeError('listOpts should be of type \"object\"')\n    }\n    let marker: string | undefined = ''\n    let keyMarker: string | undefined = ''\n    let versionIdMarker: string | undefined = ''\n    let objects: ObjectInfo[] = []\n    let ended = false\n    const readStream: stream.Readable = new stream.Readable({ objectMode: true })\n    readStream._read = async () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n\n      try {\n        const listQueryOpts = {\n          Delimiter: recursive ? '' : '/', // if recursive is false set delimiter to '/'\n          MaxKeys: 1000,\n          IncludeVersion: listOpts?.IncludeVersion,\n          // version listing specific options\n          keyMarker: keyMarker,\n          versionIdMarker: versionIdMarker,\n        }\n\n        const result: ListObjectQueryRes = await this.listObjectsQuery(bucketName, prefix, marker, listQueryOpts)\n        if (result.isTruncated) {\n          marker = result.nextMarker || undefined\n          if (result.keyMarker) {\n            keyMarker = result.keyMarker\n          }\n          if (result.versionIdMarker) {\n            versionIdMarker = result.versionIdMarker\n          }\n        } else {\n          ended = true\n        }\n        if (result.objects) {\n          objects = result.objects\n        }\n        // @ts-ignore\n        readStream._read()\n      } catch (err) {\n        readStream.emit('error', err)\n      }\n    }\n    return readStream\n  }\n\n  async listObjectsV2Query(\n    bucketName: string,\n    prefix: string,\n    continuationToken: string,\n    delimiter: string,\n    maxKeys: number,\n    startAfter: string,\n  ): Promise<ListObjectV2Res> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(continuationToken)) {\n      throw new TypeError('continuationToken should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    if (!isNumber(maxKeys)) {\n      throw new TypeError('maxKeys should be of type \"number\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n\n    const queries = []\n    queries.push(`list-type=2`)\n    queries.push(`encoding-type=url`)\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n\n    if (continuationToken) {\n      queries.push(`continuation-token=${uriEscape(continuationToken)}`)\n    }\n    if (startAfter) {\n      queries.push(`start-after=${uriEscape(startAfter)}`)\n    }\n    if (maxKeys) {\n      if (maxKeys >= 1000) {\n        maxKeys = 1000\n      }\n      queries.push(`max-keys=${maxKeys}`)\n    }\n    queries.sort()\n    let query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n\n    const method = 'GET'\n    const res = await this.makeRequestAsync({ method, bucketName, query })\n    const body = await readAsString(res)\n    return parseListObjectsV2(body)\n  }\n\n  listObjectsV2(\n    bucketName: string,\n    prefix?: string,\n    recursive?: boolean,\n    startAfter?: string,\n  ): BucketStream<BucketItem> {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (startAfter === undefined) {\n      startAfter = ''\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n\n    const delimiter = recursive ? '' : '/'\n    const prefixStr = prefix\n    const startAfterStr = startAfter\n    let continuationToken = ''\n    let objects: BucketItem[] = []\n    let ended = false\n    const readStream: stream.Readable = new stream.Readable({ objectMode: true })\n    readStream._read = async () => {\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n\n      try {\n        const result = await this.listObjectsV2Query(\n          bucketName,\n          prefixStr,\n          continuationToken,\n          delimiter,\n          1000,\n          startAfterStr,\n        )\n        if (result.isTruncated) {\n          continuationToken = result.nextContinuationToken\n        } else {\n          ended = true\n        }\n        objects = result.objects\n        // @ts-ignore\n        readStream._read()\n      } catch (err) {\n        readStream.emit('error', err)\n      }\n    }\n    return readStream\n  }\n\n  async setBucketNotification(bucketName: string, config: NotificationConfig): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(config)) {\n      throw new TypeError('notification config should be of type \"Object\"')\n    }\n    const method = 'PUT'\n    const query = 'notification'\n    const builder = new xml2js.Builder({\n      rootName: 'NotificationConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n    await this.makeRequestAsyncOmit({ method, bucketName, query }, payload)\n  }\n\n  async removeAllBucketNotification(bucketName: string): Promise<void> {\n    await this.setBucketNotification(bucketName, new NotificationConfig())\n  }\n\n  async getBucketNotification(bucketName: string): Promise<NotificationConfigResult> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'notification'\n    const res = await this.makeRequestAsync({ method, bucketName, query })\n    const body = await readAsString(res)\n    return parseBucketNotification(body)\n  }\n\n  listenBucketNotification(\n    bucketName: string,\n    prefix: string,\n    suffix: string,\n    events: NotificationEvent[],\n  ): NotificationPoller {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix must be of type string')\n    }\n    if (!isString(suffix)) {\n      throw new TypeError('suffix must be of type string')\n    }\n    if (!Array.isArray(events)) {\n      throw new TypeError('events must be of type Array')\n    }\n    const listener = new NotificationPoller(this, bucketName, prefix, suffix, events)\n    listener.start()\n    return listener\n  }\n}\n"],"mappings":"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"}