@commercetools-frontend-extensions/operations 0.0.0-canary-20251209161906

package/dist/commercetools-frontend-extensions-operations.cjs.dev.js

@@ -0,0 +1,3273 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _Object$getOwnPropertySymbols = require('@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols');
+var _filterInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/filter');
+var _Object$getOwnPropertyDescriptor = require('@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor');
+var _Object$getOwnPropertyDescriptors = require('@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors');
+var _Object$defineProperties = require('@babel/runtime-corejs3/core-js-stable/object/define-properties');
+var _Object$defineProperty = require('@babel/runtime-corejs3/core-js-stable/object/define-property');
+var _defineProperty = require('@babel/runtime-corejs3/helpers/defineProperty');
+var _forEachInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/for-each');
+var _Object$keys = require('@babel/runtime-corejs3/core-js-stable/object/keys');
+var applicationShell = require('@commercetools-frontend/application-shell');
+var applicationShellConnectors = require('@commercetools-frontend/application-shell-connectors');
+var _Reflect$construct = require('@babel/runtime-corejs3/core-js-stable/reflect/construct');
+var _createClass = require('@babel/runtime-corejs3/helpers/createClass');
+var _classCallCheck = require('@babel/runtime-corejs3/helpers/classCallCheck');
+var _possibleConstructorReturn = require('@babel/runtime-corejs3/helpers/possibleConstructorReturn');
+var _getPrototypeOf = require('@babel/runtime-corejs3/helpers/getPrototypeOf');
+var _inherits = require('@babel/runtime-corejs3/helpers/inherits');
+var _wrapNativeSuper = require('@babel/runtime-corejs3/helpers/wrapNativeSuper');
+var constants = require('@commercetools-frontend/constants');
+var _everyInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/every');
+var _Array$isArray = require('@babel/runtime-corejs3/core-js-stable/array/is-array');
+var pluralize = require('pluralize');
+var _reduceInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/reduce');
+var _flatMapInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/flat-map');
+var _mapInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/map');
+var _Promise = require('@babel/runtime-corejs3/core-js-stable/promise');
+var _findInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/find');
+var _includesInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/includes');
+var _someInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/some');
+var _Set = require('@babel/runtime-corejs3/core-js-stable/set');
+var _findIndexInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/find-index');
+var _trimInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/trim');
+var _bindInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/bind');
+var Papa = require('papaparse');
+var _sliceInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/slice');
+var _JSON$stringify = require('@babel/runtime-corejs3/core-js-stable/json/stringify');
+var _startsWithInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/starts-with');
+var _setTimeout = require('@babel/runtime-corejs3/core-js-stable/set-timeout');
+var _concatInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/concat');
+var _slicedToArray = require('@babel/runtime-corejs3/helpers/slicedToArray');
+var _URLSearchParams = require('@babel/runtime-corejs3/core-js-stable/url-search-params');
+var _Object$entries = require('@babel/runtime-corejs3/core-js-stable/object/entries');
+var uiKit = require('@commercetools-frontend/ui-kit');
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('@emotion/react');
+var _styled = require('@emotion/styled/base');
+var reactDropzone = require('react-dropzone');
+var applicationComponents = require('@commercetools-frontend/application-components');
+var _setInterval = require('@babel/runtime-corejs3/core-js-stable/set-interval');
+var sentry = require('@commercetools-frontend/sentry');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var _Object$getOwnPropertySymbols__default = /*#__PURE__*/_interopDefault(_Object$getOwnPropertySymbols);
+var _filterInstanceProperty__default = /*#__PURE__*/_interopDefault(_filterInstanceProperty);
+var _Object$getOwnPropertyDescriptor__default = /*#__PURE__*/_interopDefault(_Object$getOwnPropertyDescriptor);
+var _Object$getOwnPropertyDescriptors__default = /*#__PURE__*/_interopDefault(_Object$getOwnPropertyDescriptors);
+var _Object$defineProperties__default = /*#__PURE__*/_interopDefault(_Object$defineProperties);
+var _Object$defineProperty__default = /*#__PURE__*/_interopDefault(_Object$defineProperty);
+var _forEachInstanceProperty__default = /*#__PURE__*/_interopDefault(_forEachInstanceProperty);
+var _Object$keys__default = /*#__PURE__*/_interopDefault(_Object$keys);
+var _Reflect$construct__default = /*#__PURE__*/_interopDefault(_Reflect$construct);
+var _everyInstanceProperty__default = /*#__PURE__*/_interopDefault(_everyInstanceProperty);
+var _Array$isArray__default = /*#__PURE__*/_interopDefault(_Array$isArray);
+var _reduceInstanceProperty__default = /*#__PURE__*/_interopDefault(_reduceInstanceProperty);
+var _flatMapInstanceProperty__default = /*#__PURE__*/_interopDefault(_flatMapInstanceProperty);
+var _mapInstanceProperty__default = /*#__PURE__*/_interopDefault(_mapInstanceProperty);
+var _Promise__default = /*#__PURE__*/_interopDefault(_Promise);
+var _findInstanceProperty__default = /*#__PURE__*/_interopDefault(_findInstanceProperty);
+var _includesInstanceProperty__default = /*#__PURE__*/_interopDefault(_includesInstanceProperty);
+var _someInstanceProperty__default = /*#__PURE__*/_interopDefault(_someInstanceProperty);
+var _Set__default = /*#__PURE__*/_interopDefault(_Set);
+var _findIndexInstanceProperty__default = /*#__PURE__*/_interopDefault(_findIndexInstanceProperty);
+var _trimInstanceProperty__default = /*#__PURE__*/_interopDefault(_trimInstanceProperty);
+var _bindInstanceProperty__default = /*#__PURE__*/_interopDefault(_bindInstanceProperty);
+var Papa__default = /*#__PURE__*/_interopDefault(Papa);
+var _sliceInstanceProperty__default = /*#__PURE__*/_interopDefault(_sliceInstanceProperty);
+var _JSON$stringify__default = /*#__PURE__*/_interopDefault(_JSON$stringify);
+var _startsWithInstanceProperty__default = /*#__PURE__*/_interopDefault(_startsWithInstanceProperty);
+var _setTimeout__default = /*#__PURE__*/_interopDefault(_setTimeout);
+var _concatInstanceProperty__default = /*#__PURE__*/_interopDefault(_concatInstanceProperty);
+var _URLSearchParams__default = /*#__PURE__*/_interopDefault(_URLSearchParams);
+var _Object$entries__default = /*#__PURE__*/_interopDefault(_Object$entries);
+var React__default = /*#__PURE__*/_interopDefault(React);
+var _styled__default = /*#__PURE__*/_interopDefault(_styled);
+var _setInterval__default = /*#__PURE__*/_interopDefault(_setInterval);
+
+function _callSuper$8(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct$8() ? _Reflect$construct__default["default"](o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct$8() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct__default["default"](Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct$8 = function () { return !!t; })(); }
+let HttpError = /*#__PURE__*/function (_Error) {
+  function HttpError(statusCode, statusText, errorData) {
+    var _this;
+    _classCallCheck(this, HttpError);
+    _this = _callSuper$8(this, HttpError, [`HTTP Error! Status code: ${statusCode}, message: "${statusText ? statusText : ''}"`]);
+    _this.statusCode = void 0;
+    _this.errorData = void 0;
+    _this.name = 'HttpError';
+    _this.statusCode = statusCode;
+    _this.errorData = errorData;
+    return _this;
+  }
+  _inherits(HttpError, _Error);
+  return _createClass(HttpError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+function _callSuper$7(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct$7() ? _Reflect$construct__default["default"](o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct$7() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct__default["default"](Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct$7 = function () { return !!t; })(); }
+let InvalidResponseError = /*#__PURE__*/function (_Error) {
+  function InvalidResponseError(message) {
+    var _this;
+    _classCallCheck(this, InvalidResponseError);
+    _this = _callSuper$7(this, InvalidResponseError, [message]);
+    _this.name = 'InvalidResponseError';
+    return _this;
+  }
+  _inherits(InvalidResponseError, _Error);
+  return _createClass(InvalidResponseError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+function _callSuper$6(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct$6() ? _Reflect$construct__default["default"](o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct$6() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct__default["default"](Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct$6 = function () { return !!t; })(); }
+let NoResourcesToExportError = /*#__PURE__*/function (_Error) {
+  function NoResourcesToExportError() {
+    var _this;
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'There are no resources to export.';
+    _classCallCheck(this, NoResourcesToExportError);
+    _this = _callSuper$6(this, NoResourcesToExportError, [message]);
+    _this.name = 'NoResourcesToExportError';
+    return _this;
+  }
+  _inherits(NoResourcesToExportError, _Error);
+  return _createClass(NoResourcesToExportError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+function _callSuper$5(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct$5() ? _Reflect$construct__default["default"](o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct$5() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct__default["default"](Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct$5 = function () { return !!t; })(); }
+let PollingAbortedError = /*#__PURE__*/function (_Error) {
+  function PollingAbortedError() {
+    var _this;
+    _classCallCheck(this, PollingAbortedError);
+    _this = _callSuper$5(this, PollingAbortedError, ['Polling was aborted']);
+    _this.name = 'PollingAbortedError';
+    return _this;
+  }
+  _inherits(PollingAbortedError, _Error);
+  return _createClass(PollingAbortedError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+function _callSuper$4(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct$4() ? _Reflect$construct__default["default"](o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct$4() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct__default["default"](Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct$4 = function () { return !!t; })(); }
+let ProjectKeyNotAvailableError = /*#__PURE__*/function (_Error) {
+  function ProjectKeyNotAvailableError() {
+    var _this;
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Project key is not available';
+    _classCallCheck(this, ProjectKeyNotAvailableError);
+    _this = _callSuper$4(this, ProjectKeyNotAvailableError, [message]);
+    _this.name = 'ProjectKeyNotAvailableError';
+    return _this;
+  }
+  _inherits(ProjectKeyNotAvailableError, _Error);
+  return _createClass(ProjectKeyNotAvailableError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+function _callSuper$3(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct$3() ? _Reflect$construct__default["default"](o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct$3() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct__default["default"](Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct$3 = function () { return !!t; })(); }
+let QueryPredicateError = /*#__PURE__*/function (_Error) {
+  function QueryPredicateError() {
+    var _this;
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'There is an error with the query predicate. Make sure the syntax is correct.';
+    _classCallCheck(this, QueryPredicateError);
+    _this = _callSuper$3(this, QueryPredicateError, [message]);
+    _this.field = 'queryPredicate';
+    _this.name = 'QueryPredicateError';
+    return _this;
+  }
+  _inherits(QueryPredicateError, _Error);
+  return _createClass(QueryPredicateError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+function _callSuper$2(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct$2() ? _Reflect$construct__default["default"](o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct$2() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct__default["default"](Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct$2 = function () { return !!t; })(); }
+let UnexpectedColumnError = /*#__PURE__*/function (_Error) {
+  function UnexpectedColumnError(columnName) {
+    var _this;
+    _classCallCheck(this, UnexpectedColumnError);
+    _this = _callSuper$2(this, UnexpectedColumnError, [`Unexpected column "${columnName}"`]);
+    _this.name = 'UnexpectedColumnError';
+    return _this;
+  }
+  _inherits(UnexpectedColumnError, _Error);
+  return _createClass(UnexpectedColumnError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+function _callSuper$1(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct$1() ? _Reflect$construct__default["default"](o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct$1() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct__default["default"](Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct$1 = function () { return !!t; })(); }
+let UnexpectedOperationStateError = /*#__PURE__*/function (_Error) {
+  function UnexpectedOperationStateError(state) {
+    var _this;
+    _classCallCheck(this, UnexpectedOperationStateError);
+    _this = _callSuper$1(this, UnexpectedOperationStateError, [`Unexpected operation state "${state}"`]);
+    _this.name = 'UnexpectedOperationStateError';
+    return _this;
+  }
+  _inherits(UnexpectedOperationStateError, _Error);
+  return _createClass(UnexpectedOperationStateError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? _Reflect$construct__default["default"](o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct__default["default"](Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function () { return !!t; })(); }
+let UnexpectedResourceTypeError = /*#__PURE__*/function (_Error) {
+  function UnexpectedResourceTypeError(resourceType) {
+    var _this;
+    _classCallCheck(this, UnexpectedResourceTypeError);
+    _this = _callSuper(this, UnexpectedResourceTypeError, [`Unexpected resource type "${resourceType}"`]);
+    _this.name = 'UnexpectedResourceTypeError';
+    return _this;
+  }
+  _inherits(UnexpectedResourceTypeError, _Error);
+  return _createClass(UnexpectedResourceTypeError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+function ownKeys$9(e, r) { var t = _Object$keys__default["default"](e); if (_Object$getOwnPropertySymbols__default["default"]) { var o = _Object$getOwnPropertySymbols__default["default"](e); r && (o = _filterInstanceProperty__default["default"](o).call(o, function (r) { return _Object$getOwnPropertyDescriptor__default["default"](e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$9(e) { for (var r = 1; r < arguments.length; r++) { var _context2, _context3; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty__default["default"](_context2 = ownKeys$9(Object(t), !0)).call(_context2, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](e, _Object$getOwnPropertyDescriptors__default["default"](t)) : _forEachInstanceProperty__default["default"](_context3 = ownKeys$9(Object(t))).call(_context3, function (r) { _Object$defineProperty__default["default"](e, r, _Object$getOwnPropertyDescriptor__default["default"](t, r)); }); } return e; }
+const addProxyPrefixToUrl = (uri, proxy) => {
+  return proxy ? `/proxy/${proxy}${uri}` : uri;
+};
+const fetcher = async _ref => {
+  let url = _ref.url,
+    payload = _ref.payload,
+    config = _ref.config;
+  const data = await applicationShell.executeHttpClientRequest(async options => {
+    const res = await fetch(applicationShell.buildApiUrl(addProxyPrefixToUrl(url, config?.proxy)), _objectSpread$9(_objectSpread$9({}, options), {}, {
+      method: config?.method,
+      body: payload,
+      signal: config?.abortSignal
+    }));
+    if (!res.ok) {
+      const errorData = await res.json();
+      throw new HttpError(res.status, res.statusText, errorData);
+    }
+    const data = res.json();
+    return {
+      data,
+      statusCode: res.status,
+      getHeader: key => res.headers.get(key)
+    };
+  }, {
+    headers: _objectSpread$9({
+      'Content-Type': 'application/json'
+    }, config?.headers)
+  });
+  return data;
+};
+const fetchUsingXhr = _ref2 => {
+  let url = _ref2.url,
+    payload = _ref2.payload,
+    config = _ref2.config,
+    onProgress = _ref2.onProgress,
+    onSuccess = _ref2.onSuccess,
+    onError = _ref2.onError;
+  const options = applicationShell.createHttpClientOptions({
+    headers: _objectSpread$9({
+      'Content-Type': 'application/json'
+    }, config?.headers)
+  });
+  const xhr = new XMLHttpRequest();
+  xhr.open(config?.method, applicationShell.buildApiUrl(addProxyPrefixToUrl(url, config?.proxy)), true);
+  xhr.withCredentials = true;
+  if (options.headers) {
+    var _context;
+    _forEachInstanceProperty__default["default"](_context = _Object$keys__default["default"](options.headers)).call(_context, key => {
+      xhr.setRequestHeader(key, options.headers[key]);
+    });
+  }
+  xhr.upload.onprogress = function (event) {
+    if (event.lengthComputable) {
+      const percentComplete = event.loaded / event.total * 100;
+      onProgress(percentComplete);
+    }
+  };
+  const throwError = errorData => {
+    onError(new HttpError(xhr.status, xhr.statusText, errorData));
+  };
+  xhr.onload = function () {
+    const data = JSON.parse(xhr.responseText);
+    // Code copied from `executeHttpClientRequest` to replicate the same behavior
+    const refreshedSessionToken = xhr.getResponseHeader('x-refreshed-session-token');
+    if (refreshedSessionToken) {
+      applicationShellConnectors.oidcStorage.setActiveSession(refreshedSessionToken);
+    }
+    if (xhr.status >= 200 && xhr.status < 300) {
+      onSuccess(data);
+    } else {
+      throwError(data);
+    }
+  };
+  xhr.onerror = function () {
+    const errorData = JSON.parse(xhr.responseText);
+    throwError(errorData);
+  };
+  xhr.onabort = function () {
+    onError(new DOMException('Aborted', 'AbortError'));
+  };
+  if (config.abortSignal) {
+    if (config.abortSignal.aborted) {
+      xhr.abort();
+    } else {
+      config.abortSignal.addEventListener('abort', () => xhr.abort(), {
+        once: true
+      });
+    }
+  }
+  xhr.send(payload);
+  return xhr;
+};
+
+function hasOwnProperty(obj, prop) {
+  return typeof obj === 'object' && obj !== null && obj.hasOwnProperty(prop);
+}
+function hasRequiredFields(maybeValidObject, requiredFields) {
+  return typeof maybeValidObject === 'object' && maybeValidObject !== null && _everyInstanceProperty__default["default"](requiredFields).call(requiredFields, property => hasOwnProperty(maybeValidObject, property));
+}
+function getMissingRequiredFields(maybeValidObject, requiredFields) {
+  return typeof maybeValidObject === 'object' && maybeValidObject !== null && _filterInstanceProperty__default["default"](requiredFields).call(requiredFields, property => !(property in maybeValidObject));
+}
+function isError(maybeError) {
+  if (maybeError instanceof Error) return true;
+  return false;
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === 'AbortError';
+}
+function isResourceType(maybeResourceType) {
+  return typeof maybeResourceType === 'string';
+}
+function assertResourceType(maybeResourceType) {
+  if (typeof maybeResourceType === 'string') return;
+  throw new Error(`Invalid value: ${maybeResourceType}`);
+}
+
+function assertPaginatedExportOperationResponse(maybePaginatedExportOperationResponseOrExportOperationsResponse) {
+  const requiredFields = ['results', 'total'];
+  if (hasRequiredFields(maybePaginatedExportOperationResponseOrExportOperationsResponse, requiredFields)) return;
+  throw new Error('Invalid response');
+}
+function assertExportOperationsDownloadFileResponse(maybeExportOperationDownloadFileResponse) {
+  const requiredFields = ['uri'];
+  if (hasRequiredFields(maybeExportOperationDownloadFileResponse, requiredFields)) return;
+  throw new Error('Invalid response');
+}
+
+function assertFileImportJob(maybeJob) {
+  const requiredFields = ['id', 'fileName', 'importContainerKey', 'state'];
+  if (hasRequiredFields(maybeJob, requiredFields)) return;
+  throw new Error('Invalid File Import Job response');
+}
+function assertFileImportJobRecordsResponse(maybeRecords) {
+  const requiredFields = ['results', 'total', 'limit', 'offset', 'count'];
+  if (!hasRequiredFields(maybeRecords, requiredFields)) {
+    throw new Error('Invalid File Import Job records response: missing required fields');
+  }
+}
+function assertProcessFileImportJobResponse(maybeResponse) {
+  const requiredFields = ['message'];
+  if (hasRequiredFields(maybeResponse, requiredFields)) return;
+  throw new Error('Invalid Process File Import Job response');
+}
+function assertListFileImportJobsResponse(maybeResponse) {
+  if (!_Array$isArray__default["default"](maybeResponse)) {
+    throw new Error('Invalid List File Import Jobs response: expected an array');
+  }
+  if (maybeResponse.length > 0) {
+    const requiredFields = ['id', 'fileName', 'importContainerKey', 'state'];
+    if (!hasRequiredFields(maybeResponse[0], requiredFields)) {
+      throw new Error('Invalid List File Import Jobs response: missing required fields');
+    }
+  }
+}
+
+function assertImportContainerPagedResponse(maybeImportContainerPagedResponse) {
+  const requiredFields = ['count', 'results'];
+  if (hasRequiredFields(maybeImportContainerPagedResponse, requiredFields)) return;
+  throw new Error('Invalid response');
+}
+function assertImportSummary(maybeImportSummary) {
+  const requiredFields = ['states', 'total'];
+  if (hasRequiredFields(maybeImportSummary, requiredFields)) return;
+  throw new Error('Invalid response');
+}
+function assertImportContainer(maybeImportContainerResponse) {
+  const requiredFields = ['key', 'version'];
+  if (hasRequiredFields(maybeImportContainerResponse, requiredFields)) return;
+  throw new Error('Invalid response');
+}
+function assertCancelContainerResponse(maybeCancelContainerResponse) {
+  if (typeof maybeCancelContainerResponse === 'object' && maybeCancelContainerResponse !== null) {
+    const responseData = maybeCancelContainerResponse;
+    if (typeof responseData.message === 'string') {
+      return;
+    }
+  }
+  throw new Error('Invalid response');
+}
+
+// Extended types to support settings that aren't in the base SDK yet
+
+// TODO: Remove the temporarily extended ImportOperation when the SDK is updated
+
+// TODO: Remove the temporarily extended ImportOperationPagedResponse when the SDK is updated
+
+function assertImportOperationPagedResponse(maybeImportOperationPagedResponse) {
+  const requiredFields = ['count', 'total', 'results'];
+  if (hasRequiredFields(maybeImportOperationPagedResponse, requiredFields)) return;
+  throw new Error('Invalid response');
+}
+
+let ImportStates = /*#__PURE__*/function (ImportStates) {
+  ImportStates["Processing"] = "processing";
+  ImportStates["WaitForUnresolvedReferences"] = "wait-for-unresolved-references";
+  ImportStates["PartiallyCompleted"] = "partially-completed";
+  ImportStates["Failed"] = "failed";
+  ImportStates["SuccessfullyCompleted"] = "successfully-completed";
+  ImportStates["NoRunningImports"] = "no-running-imports";
+  ImportStates["Canceled"] = "canceled";
+  return ImportStates;
+}({});
+
+function getFileUploadErrorsCount(errors) {
+  if (!errors || !_Array$isArray__default["default"](errors)) return 0;
+  return _reduceInstanceProperty__default["default"](errors).call(errors, (acc, curr) => acc += curr.errors.length, 0);
+}
+
+// TODO: After fully migrating to new flow, remove `row` and only use `index`
+function mapUploadFileErrorsResponseToUploadFileErrorRows(uploadFileErrorsResponse) {
+  if (!uploadFileErrorsResponse || !_Array$isArray__default["default"](uploadFileErrorsResponse)) return [];
+  let idCounter = 1;
+  return _flatMapInstanceProperty__default["default"](uploadFileErrorsResponse).call(uploadFileErrorsResponse, rowErrorsResponse => {
+    var _context;
+    // TODO: use `row` if available, otherwise fall back to `index`
+    // Old flow uses `row`, new flow uses `index`
+    const rowNumber = rowErrorsResponse.row ?? rowErrorsResponse.index;
+    return _mapInstanceProperty__default["default"](_context = rowErrorsResponse.errors).call(_context, rowError => ({
+      id: String(idCounter++),
+      row: rowNumber,
+      index: rowNumber,
+      field: rowError.field,
+      code: rowError.code,
+      validationMessage: rowError.message
+    }));
+  });
+}
+
+function getFileImportJobFileType(resourceType) {
+  return resourceType === 'custom-object' ? 'json' : 'csv';
+}
+function toImportApiResourceType(resourceType) {
+  return resourceType === 'product' ? 'product-draft' : resourceType;
+}
+function isImportJobQueued(job) {
+  return job?.state === 'queued';
+}
+function isImportJobProcessing(job) {
+  return job?.state === 'processing';
+}
+function isImportJobValidated(job) {
+  return job?.state === 'validated';
+}
+function isImportJobInitializing(job) {
+  return job?.state === 'initialising';
+}
+function isImportJobReady(job) {
+  return job?.state === 'ready';
+}
+function isImportJobRejected(job) {
+  return job?.state === 'rejected';
+}
+function isImportJobTerminal(job) {
+  return isImportJobValidated(job) || isImportJobRejected(job);
+}
+function shouldContinuePollingForImportValidation(job) {
+  if (!job) return true;
+  return isImportJobQueued(job) || isImportJobProcessing(job);
+}
+
+function ownKeys$8(e, r) { var t = _Object$keys__default["default"](e); if (_Object$getOwnPropertySymbols__default["default"]) { var o = _Object$getOwnPropertySymbols__default["default"](e); r && (o = _filterInstanceProperty__default["default"](o).call(o, function (r) { return _Object$getOwnPropertyDescriptor__default["default"](e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$8(e) { for (var r = 1; r < arguments.length; r++) { var _context6, _context7; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty__default["default"](_context6 = ownKeys$8(Object(t), !0)).call(_context6, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](e, _Object$getOwnPropertyDescriptors__default["default"](t)) : _forEachInstanceProperty__default["default"](_context7 = ownKeys$8(Object(t))).call(_context7, function (r) { _Object$defineProperty__default["default"](e, r, _Object$getOwnPropertyDescriptor__default["default"](t, r)); }); } return e; }
+
+/**
+ * Convert megabytes to bytes
+ */
+const toBytes = megabytes => megabytes * 1024 * 1024;
+
+/**
+ * Returns the number of rows in a CSV file excluding the header
+ * @param file The CSV file to process
+ * @returns A promise that resolves to the number of rows
+ */
+const getRowCount = file => {
+  return new _Promise__default["default"](resolve => {
+    let lineCount = 0;
+    Papa__default["default"].parse(file, {
+      step: _ref => {
+        let data = _ref.data;
+        // empty lines at the end of the file should not be counted
+        if (_Array$isArray__default["default"](data) && _findInstanceProperty__default["default"](data).call(data, Boolean)) lineCount++;
+      },
+      complete: () => {
+        // Subtract 1 for the header row
+        // We use Math.max to make sure the count is not less than 0, this is needed for empty files
+        resolve(Math.max(0, lineCount - 1));
+      }
+    });
+  });
+};
+
+/**
+ * Check if a CSV file has a single key column
+ * @param file The CSV file to check
+ * @returns A promise that resolves to true if the file has only one column named 'key'
+ */
+const hasSingleKeyColumn = file => {
+  return new _Promise__default["default"](resolve => {
+    Papa__default["default"].parse(file, {
+      preview: 1,
+      complete: result => {
+        const headerRow = result.data?.[0];
+        const hasSingleColumn = _Array$isArray__default["default"](headerRow) && headerRow.length === 1;
+        const isKeyColumn = hasSingleColumn && headerRow[0].toLowerCase() === 'key';
+        resolve(isKeyColumn);
+      }
+    });
+  });
+};
+
+/**
+ * Validate delimiter in a CSV file
+ * @param file The CSV file to validate
+ * @param allowedDelimiters Array of allowed delimiters
+ * @returns A promise that resolves to false if delimiter is invalid
+ */
+const validateDelimiter = (file, allowedDelimiters) => {
+  // Delimiters not included in this array may be treated as part of a column content
+  // potentially causing the file to be parsed as a single-column CSV and pass this validation
+  const NON_ALLOWED_COLUMN_DELIMITERS = ['%', '.', ' '];
+  const DELIMITERS_TO_GUESS = [...allowedDelimiters, ...NON_ALLOWED_COLUMN_DELIMITERS];
+  return new _Promise__default["default"](resolve => {
+    Papa__default["default"].parse(file, {
+      delimitersToGuess: DELIMITERS_TO_GUESS,
+      preview: 10,
+      complete: result => {
+        const headerRow = result.data?.[0];
+        const isOnlyOneColumn = _Array$isArray__default["default"](headerRow) && headerRow.length === 1;
+        if (isOnlyOneColumn) {
+          resolve(true);
+          return;
+        }
+        const detectedDelimiter = result.meta.delimiter;
+        let isValid = false;
+        if (detectedDelimiter !== null && _includesInstanceProperty__default["default"](allowedDelimiters).call(allowedDelimiters, detectedDelimiter)) {
+          var _context;
+          const isUndetectableDelimiter = _someInstanceProperty__default["default"](_context = result.errors).call(_context, error => error.code === 'UndetectableDelimiter');
+          if (!isUndetectableDelimiter) {
+            isValid = true;
+          }
+        }
+        resolve(isValid);
+      }
+    });
+  });
+};
+
+/**
+ * Returns columns from the provided `columns` excluding those specified in the `ignoredColumns`
+ */
+const getValidatedColumns = (columns, ignoredColumns) => {
+  return _filterInstanceProperty__default["default"](columns).call(columns, column => !_includesInstanceProperty__default["default"](ignoredColumns).call(ignoredColumns, column));
+};
+
+/**
+ * Count items in a JSON file
+ * @param file The JSON file to process
+ * @returns Object with isValid flag and optional itemsCount
+ */
+const countJsonFileItems = async file => {
+  const jsonContent = await file.text();
+  try {
+    const content = JSON.parse(jsonContent);
+    const isValid = _Array$isArray__default["default"](content);
+    if (isValid) {
+      return {
+        isValid,
+        itemsCount: content.length
+      };
+    }
+    return {
+      isValid
+    };
+  } catch {
+    return {
+      isValid: false
+    };
+  }
+};
+
+/**
+ * Count unique resources in a CSV file by counting unique values in the "key" column.
+ * A single resource can span multiple rows (when it has array fields like variants, assets...),
+ * so we count unique keys rather than rows.
+ * @param file The CSV file to process
+ * @returns A promise that resolves to the number of unique resources
+ */
+const countUniqueResourcesInCsv = file => {
+  return new _Promise__default["default"](resolve => {
+    const uniqueKeys = new _Set__default["default"]();
+    let keyColumnIndex = -1;
+    let isFirstRow = true;
+    Papa__default["default"].parse(file, {
+      step: _ref2 => {
+        var _context4, _context5;
+        let data = _ref2.data;
+        if (!_Array$isArray__default["default"](data)) return;
+        if (isFirstRow) {
+          keyColumnIndex = _findIndexInstanceProperty__default["default"](data).call(data, col => {
+            var _context2, _context3;
+            return ((_context2 = col?.toLowerCase()) == null ? void 0 : _bindInstanceProperty__default["default"](_context3 = Function.call).call(_context3, _trimInstanceProperty__default["default"](_context2), _context2))?.() === 'key';
+          });
+          isFirstRow = false;
+          return;
+        }
+        if (keyColumnIndex === -1) return;
+        const keyValue = ((_context4 = data[keyColumnIndex]) == null ? void 0 : _bindInstanceProperty__default["default"](_context5 = Function.call).call(_context5, _trimInstanceProperty__default["default"](_context4), _context4))?.();
+        if (keyValue) {
+          uniqueKeys.add(keyValue);
+        }
+      },
+      complete: () => {
+        resolve(uniqueKeys.size);
+      }
+    });
+  });
+};
+
+/**
+ * Map file upload errors to upload file error rows with unique IDs
+ * @param uploadFileErrors Array of file upload errors
+ * @returns Array of upload file errors with unique id field
+ */
+const mapFileUploadErrorsToUploadFileErrorRows = uploadFileErrors => {
+  let idCounter = 1;
+  return _mapInstanceProperty__default["default"](uploadFileErrors).call(uploadFileErrors, uploadFileError => _objectSpread$8(_objectSpread$8({}, uploadFileError), {}, {
+    id: String(idCounter++)
+  }));
+};
+
+function ownKeys$7(e, r) { var t = _Object$keys__default["default"](e); if (_Object$getOwnPropertySymbols__default["default"]) { var o = _Object$getOwnPropertySymbols__default["default"](e); r && (o = _filterInstanceProperty__default["default"](o).call(o, function (r) { return _Object$getOwnPropertyDescriptor__default["default"](e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$7(e) { for (var r = 1; r < arguments.length; r++) { var _context, _context2; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty__default["default"](_context = ownKeys$7(Object(t), !0)).call(_context, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](e, _Object$getOwnPropertyDescriptors__default["default"](t)) : _forEachInstanceProperty__default["default"](_context2 = ownKeys$7(Object(t))).call(_context2, function (r) { _Object$defineProperty__default["default"](e, r, _Object$getOwnPropertyDescriptor__default["default"](t, r)); }); } return e; }
+const mapFormikErrors = error => {
+  if (typeof error === 'string') {
+    return {
+      [error]: true
+    };
+  }
+  if (_Array$isArray__default["default"](error)) {
+    return _reduceInstanceProperty__default["default"](error).call(error, (errorAggregator, currentError) => _objectSpread$7(_objectSpread$7({}, errorAggregator), {}, {
+      [currentError]: true
+    }), {});
+  }
+  if (!error) return {};
+  return error;
+};
+
+function formatErrorCode(code) {
+  try {
+    const formattedCode = code.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/([A-Z])([A-Z][a-z])/g, '$1 $2').toLowerCase();
+    let result = formattedCode.charAt(0).toUpperCase() + _sliceInstanceProperty__default["default"](formattedCode).call(formattedCode, 1);
+    const specialWords = ['json', 'api', 'http'];
+    _forEachInstanceProperty__default["default"](specialWords).call(specialWords, word => {
+      const regex = new RegExp(`\\b${word}\\b`, 'gi');
+      result = result.replace(regex, word.toUpperCase());
+    });
+    return result;
+  } catch (error) {
+    return code;
+  }
+}
+function extractErrorDescriptionFromValidationMessage(message) {
+  return message.split('"').pop();
+}
+function formatKeys(obj) {
+  var _context;
+  let conjunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'and';
+  if (typeof obj !== 'object' || obj === null) return '';
+  const keys = _mapInstanceProperty__default["default"](_context = _Object$keys__default["default"](obj)).call(_context, key => key.replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase());
+  if (keys.length === 0) return '';
+  if (keys.length === 1) return keys[0];
+  return `${_sliceInstanceProperty__default["default"](keys).call(keys, 0, -1).join(', ')} ${conjunction} ${keys[keys.length - 1]}`;
+}
+function appendCsvOrJsonExtensionIfAbsent(fileName, fileFormat) {
+  const extensionRegex = /\.(csv|json)$/i;
+  if (!extensionRegex.test(fileName)) return `${fileName}.${fileFormat}`;
+  return fileName;
+}
+function convertFileSizeToKB(sizeInBytes) {
+  return sizeInBytes / 1000;
+}
+
+const encodeFileNameWithTimestampToContainerKey = fileName => {
+  return btoa(_JSON$stringify__default["default"]({
+    timestamp: new Date().getTime(),
+    fileName
+  })).replace(/=+$/g, '');
+};
+
+/**
+ * Check if an import container is a file upload import
+ * @param tags - Array of tags from the import container
+ * @returns True if the tags indicate this is a file upload import
+ */
+const checkIfFileUploadImport = tags => {
+  var _context, _context2;
+  return ((_context = tags) == null ? void 0 : _bindInstanceProperty__default["default"](_context2 = Function.call).call(_context2, _someInstanceProperty__default["default"](_context), _context))?.(tag => _startsWithInstanceProperty__default["default"](tag).call(tag, 'source:file-upload')) ?? false;
+};
+const decodeFileNameFromImportContainerKey = importContainerKey => {
+  try {
+    const decodedImportContainerKey = atob(importContainerKey);
+    const importInfo = JSON.parse(decodedImportContainerKey);
+    return importInfo.fileName;
+  } catch {
+    return '';
+  }
+};
+
+const pollJobUntilValidated = async _ref => {
+  let projectKey = _ref.projectKey,
+    jobId = _ref.jobId,
+    importContainerKey = _ref.importContainerKey,
+    _ref$pollingInterval = _ref.pollingInterval,
+    pollingInterval = _ref$pollingInterval === void 0 ? 5000 : _ref$pollingInterval,
+    _ref$maxAttempts = _ref.maxAttempts,
+    maxAttempts = _ref$maxAttempts === void 0 ? 120 : _ref$maxAttempts,
+    onJobUpdate = _ref.onJobUpdate,
+    abortSignal = _ref.abortSignal;
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    if (abortSignal?.aborted) {
+      throw new PollingAbortedError();
+    }
+    const job = await getFileImportJob({
+      projectKey,
+      importContainerKey,
+      jobId
+    });
+    if (abortSignal?.aborted) {
+      throw new PollingAbortedError();
+    }
+    onJobUpdate?.(job);
+    if (isImportJobTerminal(job)) {
+      return job;
+    }
+    await new _Promise__default["default"]((resolve, reject) => {
+      let timeoutId;
+      const onAbort = () => {
+        clearTimeout(timeoutId);
+        reject(new PollingAbortedError());
+      };
+      if (abortSignal?.aborted) {
+        reject(new PollingAbortedError());
+        return;
+      }
+      timeoutId = _setTimeout__default["default"](() => {
+        abortSignal?.removeEventListener('abort', onAbort);
+        resolve();
+      }, pollingInterval);
+      abortSignal?.addEventListener('abort', onAbort);
+    });
+    attempts++;
+  }
+  throw new Error(`Job validation timeout after ${maxAttempts} attempts (${maxAttempts * pollingInterval / 1000}s)`);
+};
+
+/**
+ * Formats an object into a URL query string
+ * @param queryParams - Object containing query parameters
+ * @returns Formatted query string with leading '?' or empty string
+ */
+function formatQueryString() {
+  let queryParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const queryString = new _URLSearchParams__default["default"]();
+  for (const _ref of _Object$entries__default["default"](queryParams)) {
+    var _ref2 = _slicedToArray(_ref, 2);
+    const key = _ref2[0];
+    const value = _ref2[1];
+    if (value !== undefined && value !== null) {
+      if (_Array$isArray__default["default"](value)) {
+        _forEachInstanceProperty__default["default"](value).call(value, v => queryString.append(key, String(v)));
+      } else {
+        queryString.append(key, String(value));
+      }
+    }
+  }
+  return queryString.toString() ? `?${queryString.toString()}` : '';
+}
+
+function getImportContainersURL(_ref) {
+  let projectKey = _ref.projectKey,
+    queryParams = _ref.queryParams;
+  const queryString = formatQueryString(queryParams);
+  return `/${projectKey}/import-containers${queryString}`;
+}
+function getImportOperationsURL(_ref2) {
+  let projectKey = _ref2.projectKey,
+    importContainerKey = _ref2.importContainerKey,
+    queryParams = _ref2.queryParams;
+  const queryString = formatQueryString(queryParams);
+  return `/${projectKey}/import-containers/${importContainerKey}/import-operations${queryString}&debug=true`;
+}
+function getImportContainerByKeyURL(_ref3) {
+  let projectKey = _ref3.projectKey,
+    importContainerKey = _ref3.importContainerKey;
+  return `/${projectKey}/import-containers/${importContainerKey}`;
+}
+function getCreateImportContainerURL(_ref4) {
+  let projectKey = _ref4.projectKey;
+  return `/${projectKey}/import-containers`;
+}
+function getImportContainerTasksURL(_ref5) {
+  let projectKey = _ref5.projectKey,
+    importContainerKey = _ref5.importContainerKey;
+  return `/${projectKey}/import-containers/${importContainerKey}/tasks`;
+}
+function getDeleteImportContainerURL(_ref6) {
+  let projectKey = _ref6.projectKey,
+    importContainerKey = _ref6.importContainerKey;
+  return `/${projectKey}/import-containers/${importContainerKey}`;
+}
+function getImportSummaryURL(_ref7) {
+  let projectKey = _ref7.projectKey,
+    importContainerKey = _ref7.importContainerKey;
+  return `/${projectKey}/import-containers/${importContainerKey}/import-summaries`;
+}
+function getFileUploadURL(_ref8) {
+  let projectKey = _ref8.projectKey,
+    resourceType = _ref8.resourceType,
+    importContainerKey = _ref8.importContainerKey;
+  return `/${projectKey}/${pluralize.plural(resourceType)}/import-containers/${importContainerKey}/file-upload`;
+}
+function getProccessFileURL(_ref9) {
+  let projectKey = _ref9.projectKey,
+    resourceType = _ref9.resourceType,
+    importContainerKey = _ref9.importContainerKey;
+  return `/${projectKey}/${pluralize.plural(resourceType)}/import-containers/${importContainerKey}/process-file`;
+}
+function getExportOperationsURL(_ref0) {
+  let projectKey = _ref0.projectKey,
+    queryParams = _ref0.queryParams;
+  const queryString = formatQueryString(queryParams);
+  return `/${projectKey}/export-operations${queryString}`;
+}
+function getFileImportJobsURL(_ref1) {
+  let projectKey = _ref1.projectKey,
+    resourceType = _ref1.resourceType,
+    importContainerKey = _ref1.importContainerKey;
+  return `/${projectKey}/${pluralize.plural(toImportApiResourceType(resourceType))}/import-containers/${importContainerKey}/file-import-jobs`;
+}
+function getFileImportJobByIdURL(_ref10) {
+  let projectKey = _ref10.projectKey,
+    importContainerKey = _ref10.importContainerKey,
+    jobId = _ref10.jobId;
+  return `/${projectKey}/import-containers/${importContainerKey}/file-import-jobs/${jobId}`;
+}
+function getFileImportJobRecordsURL(_ref11) {
+  let projectKey = _ref11.projectKey,
+    importContainerKey = _ref11.importContainerKey,
+    jobId = _ref11.jobId;
+  return `/${projectKey}/import-containers/${importContainerKey}/file-import-jobs/${jobId}/records`;
+}
+function getFileImportJobProcessURL(_ref12) {
+  let projectKey = _ref12.projectKey,
+    resourceType = _ref12.resourceType,
+    importContainerKey = _ref12.importContainerKey,
+    jobId = _ref12.jobId;
+  return `/${projectKey}/${pluralize.plural(toImportApiResourceType(resourceType))}/import-containers/${importContainerKey}/file-import-jobs/${jobId}/process`;
+}
+function getFileImportJobDeleteURL(_ref13) {
+  let projectKey = _ref13.projectKey,
+    importContainerKey = _ref13.importContainerKey,
+    jobId = _ref13.jobId;
+  return `/${projectKey}/import-containers/${importContainerKey}/file-import-jobs/${jobId}`;
+}
+function getFileImportJobsListURL(_ref14) {
+  let projectKey = _ref14.projectKey,
+    importContainerKey = _ref14.importContainerKey;
+  return `/${projectKey}/import-containers/${importContainerKey}/file-import-jobs`;
+}
+
+function uploadFileForImport(_ref) {
+  let projectKey = _ref.projectKey,
+    importContainerKey = _ref.importContainerKey,
+    resourceType = _ref.resourceType,
+    file = _ref.file,
+    abortSignal = _ref.abortSignal,
+    onSuccess = _ref.onSuccess,
+    onProgress = _ref.onProgress,
+    onError = _ref.onError;
+  const uri = getFileUploadURL({
+    projectKey,
+    resourceType,
+    importContainerKey
+  });
+  const formData = new FormData();
+  formData.append('file', file, file.name);
+  return fetchUsingXhr({
+    url: uri,
+    payload: formData,
+    config: {
+      abortSignal,
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'POST',
+      headers: {
+        'Content-Type': null
+      }
+    },
+    onProgress,
+    onSuccess,
+    onError
+  });
+}
+function assertFileUploadResponse(maybeFileUploadResponse) {
+  const requiredFields = ['results', 'valid'];
+  if (hasRequiredFields(maybeFileUploadResponse, requiredFields)) return;
+  throw new Error('Invalid response');
+}
+
+function createFileImportJob(_ref) {
+  let projectKey = _ref.projectKey,
+    resourceType = _ref.resourceType,
+    importContainerKey = _ref.importContainerKey,
+    payload = _ref.payload,
+    onProgress = _ref.onProgress,
+    abortSignal = _ref.abortSignal;
+  const url = getFileImportJobsURL({
+    projectKey,
+    resourceType,
+    importContainerKey
+  });
+  if ('fileType' in payload) {
+    return new _Promise__default["default"]((resolve, reject) => {
+      const formData = new FormData();
+      formData.append('fileType', payload.fileType);
+      formData.append('fileName', payload.fileName);
+      formData.append('file', payload.file, payload.fileName);
+      fetchUsingXhr({
+        url,
+        payload: formData,
+        config: {
+          proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+          method: 'POST',
+          headers: {
+            'Content-Type': null
+          },
+          abortSignal
+        },
+        onProgress: onProgress || (() => {}),
+        onSuccess: response => {
+          assertFileImportJob(response);
+          resolve(response);
+        },
+        onError: reject
+      });
+    });
+  }
+  return fetcher({
+    url,
+    payload: _JSON$stringify__default["default"](payload),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'POST',
+      headers: {
+        accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    }
+  }).then(response => {
+    assertFileImportJob(response);
+    return response;
+  });
+}
+async function getFileImportJob(_ref2) {
+  let projectKey = _ref2.projectKey,
+    importContainerKey = _ref2.importContainerKey,
+    jobId = _ref2.jobId;
+  const url = getFileImportJobByIdURL({
+    projectKey,
+    importContainerKey,
+    jobId
+  });
+  const response = await fetcher({
+    url,
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'GET'
+    }
+  });
+  assertFileImportJob(response);
+  return response;
+}
+async function getFileImportJobRecords(_ref3) {
+  let projectKey = _ref3.projectKey,
+    importContainerKey = _ref3.importContainerKey,
+    jobId = _ref3.jobId,
+    limit = _ref3.limit,
+    offset = _ref3.offset,
+    isValid = _ref3.isValid;
+  const baseUrl = getFileImportJobRecordsURL({
+    projectKey,
+    importContainerKey,
+    jobId
+  });
+  const queryString = formatQueryString({
+    limit,
+    offset,
+    isValid
+  });
+  const url = `${baseUrl}${queryString}`;
+  const response = await fetcher({
+    url,
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'GET'
+    }
+  });
+  assertFileImportJobRecordsResponse(response);
+  return response;
+}
+async function processFileImportJob(_ref4) {
+  let projectKey = _ref4.projectKey,
+    resourceType = _ref4.resourceType,
+    importContainerKey = _ref4.importContainerKey,
+    jobId = _ref4.jobId,
+    action = _ref4.action;
+  const url = getFileImportJobProcessURL({
+    projectKey,
+    resourceType,
+    importContainerKey,
+    jobId
+  });
+  const payload = action ? {
+    action
+  } : {};
+  const response = await fetcher({
+    url,
+    payload: _JSON$stringify__default["default"](payload),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'POST',
+      headers: {
+        accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    }
+  });
+  assertProcessFileImportJobResponse(response);
+  return response;
+}
+async function deleteFileImportJob(_ref5) {
+  let projectKey = _ref5.projectKey,
+    importContainerKey = _ref5.importContainerKey,
+    jobId = _ref5.jobId;
+  const url = getFileImportJobDeleteURL({
+    projectKey,
+    importContainerKey,
+    jobId
+  });
+  await fetcher({
+    url,
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'DELETE'
+    }
+  });
+}
+async function listFileImportJobs(_ref6) {
+  let projectKey = _ref6.projectKey,
+    importContainerKey = _ref6.importContainerKey,
+    limit = _ref6.limit,
+    offset = _ref6.offset;
+  const baseUrl = getFileImportJobsListURL({
+    projectKey,
+    importContainerKey
+  });
+  const queryString = formatQueryString({
+    limit,
+    offset
+  });
+  const url = `${baseUrl}${queryString}`;
+  const response = await fetcher({
+    url,
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'GET'
+    }
+  });
+  assertListFileImportJobsResponse(response);
+  return response;
+}
+
+function ownKeys$6(e, r) { var t = _Object$keys__default["default"](e); if (_Object$getOwnPropertySymbols__default["default"]) { var o = _Object$getOwnPropertySymbols__default["default"](e); r && (o = _filterInstanceProperty__default["default"](o).call(o, function (r) { return _Object$getOwnPropertyDescriptor__default["default"](e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$6(e) { for (var r = 1; r < arguments.length; r++) { var _context2, _context3; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty__default["default"](_context2 = ownKeys$6(Object(t), !0)).call(_context2, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](e, _Object$getOwnPropertyDescriptors__default["default"](t)) : _forEachInstanceProperty__default["default"](_context3 = ownKeys$6(Object(t))).call(_context3, function (r) { _Object$defineProperty__default["default"](e, r, _Object$getOwnPropertyDescriptor__default["default"](t, r)); }); } return e; }
+function getImportState(importSummary) {
+  const processing = importSummary.states.processing > 0;
+  if (processing) return ImportStates.Processing;
+  const waitForUnresolvedReferences = importSummary.states.waitForMasterVariant > 0 || importSummary.states.unresolved > 0;
+  if (waitForUnresolvedReferences) return ImportStates.WaitForUnresolvedReferences;
+  const partiallyCompleted = importSummary.states.imported > 0 && importSummary.states.imported < importSummary.total || importSummary.states.deleted > 0 && importSummary.states.deleted < importSummary.total;
+  if (partiallyCompleted) return ImportStates.PartiallyCompleted;
+  const noRunning = importSummary.total === 0;
+  if (noRunning) return ImportStates.NoRunningImports;
+  const successfullyCompleted = importSummary.states.imported === importSummary.total || importSummary.states.deleted === importSummary.total;
+  if (successfullyCompleted) return ImportStates.SuccessfullyCompleted;
+  const failed = importSummary.states.rejected + importSummary.states.validationFailed === importSummary.total;
+  if (failed) return ImportStates.Failed;
+  const canceled = importSummary.states.canceled > 0;
+  if (canceled) return ImportStates.Canceled;
+  throw new Error(`Unsupported state ${_JSON$stringify__default["default"](importSummary.states)}`);
+}
+function createImportContainerForFileUpload(_ref) {
+  let importContainerDraft = _ref.importContainerDraft,
+    projectKey = _ref.projectKey;
+  return fetcher({
+    url: getCreateImportContainerURL({
+      projectKey
+    }),
+    payload: _JSON$stringify__default["default"](_objectSpread$6({
+      retentionPolicy: {
+        strategy: 'ttl',
+        config: {
+          timeToLive: '54h' // 2 days and 6 hours
+        }
+      }
+    }, importContainerDraft)),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'POST',
+      headers: {
+        accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    }
+  });
+}
+function deleteImportContainer(_ref2) {
+  let projectKey = _ref2.projectKey,
+    importContainerKey = _ref2.importContainerKey;
+  return fetcher({
+    url: getDeleteImportContainerURL({
+      projectKey,
+      importContainerKey
+    }),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'DELETE',
+      headers: {
+        accept: 'application/json'
+      }
+    }
+  });
+}
+async function fetchImportSummary(_ref3) {
+  let projectKey = _ref3.projectKey,
+    importContainerKey = _ref3.importContainerKey;
+  const importSummary = await fetcher({
+    url: getImportSummaryURL({
+      projectKey,
+      importContainerKey
+    }),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'GET'
+    }
+  });
+  assertImportSummary(importSummary);
+  return importSummary;
+}
+async function fetchImportContainers(_ref4) {
+  let projectKey = _ref4.projectKey,
+    queryParams = _ref4.queryParams;
+  const importContainers = await fetcher({
+    url: getImportContainersURL({
+      projectKey,
+      queryParams
+    }),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'GET'
+    }
+  });
+  assertImportContainerPagedResponse(importContainers);
+  return importContainers;
+}
+async function fetchImportSummaries(_ref5) {
+  var _context;
+  let projectKey = _ref5.projectKey,
+    queryParams = _ref5.queryParams;
+  const importContainers = await fetchImportContainers({
+    projectKey,
+    queryParams
+  });
+  const results = _mapInstanceProperty__default["default"](_context = importContainers.results).call(_context, async importContainer => {
+    return await importContainerToContainerDetails(projectKey, importContainer);
+  });
+  return {
+    results,
+    count: importContainers.count,
+    total: importContainers.total ?? 0,
+    queryParams: {
+      limit: importContainers.limit,
+      offset: importContainers.offset
+    }
+  };
+}
+async function fetchImportContainerDetails(_ref6) {
+  let projectKey = _ref6.projectKey,
+    importContainerKey = _ref6.importContainerKey;
+  const importContainer = await fetchImportContainerByKey({
+    projectKey,
+    importContainerKey
+  });
+  return await importContainerToContainerDetails(projectKey, importContainer);
+}
+async function fetchImportContainerByKey(_ref7) {
+  let projectKey = _ref7.projectKey,
+    importContainerKey = _ref7.importContainerKey;
+  const importContainer = await fetcher({
+    url: getImportContainerByKeyURL({
+      projectKey,
+      importContainerKey
+    }),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'GET'
+    }
+  });
+  assertImportContainer(importContainer);
+  return importContainer;
+}
+async function cancelImportContainerByKey(_ref8) {
+  let projectKey = _ref8.projectKey,
+    importContainerKey = _ref8.importContainerKey;
+  const response = await fetcher({
+    url: getImportContainerTasksURL({
+      projectKey,
+      importContainerKey
+    }),
+    payload: _JSON$stringify__default["default"]({
+      task: 'cancel'
+    }),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'POST'
+    }
+  });
+  assertCancelContainerResponse(response);
+  return response;
+}
+async function importContainerToContainerDetails(projectKey, importContainer) {
+  const importSummary = await fetchImportSummary({
+    projectKey,
+    importContainerKey: importContainer.key
+  });
+  const importState = getImportState(importSummary);
+  const isFileUploadImport = checkIfFileUploadImport(importContainer.tags);
+  return {
+    importContainer: importContainer,
+    importState,
+    importSummary,
+    isFileUploadImport
+  };
+}
+
+async function fetchImportOperations(_ref) {
+  let projectKey = _ref.projectKey,
+    importContainerKey = _ref.importContainerKey,
+    queryParams = _ref.queryParams;
+  const importOperations = await fetcher({
+    url: getImportOperationsURL({
+      projectKey,
+      importContainerKey,
+      queryParams
+    }),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'GET'
+    }
+  });
+  assertImportOperationPagedResponse(importOperations);
+  return importOperations;
+}
+
+async function fetchExportOperations(_ref) {
+  let projectKey = _ref.projectKey,
+    queryParams = _ref.queryParams;
+  const exportOperations = await fetcher({
+    url: getExportOperationsURL({
+      projectKey,
+      queryParams
+    }),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.EXPORT,
+      method: 'GET'
+    }
+  });
+  assertPaginatedExportOperationResponse(exportOperations);
+  return exportOperations;
+}
+
+async function processUploadedFile(_ref) {
+  let projectKey = _ref.projectKey,
+    importContainerKey = _ref.importContainerKey,
+    resourceType = _ref.resourceType,
+    action = _ref.action;
+  // For delete operations with action (like 'delete') -> use different URL and payload structure
+  const uri = action ? getImportContainerTasksURL({
+    projectKey,
+    importContainerKey
+  }) : getProccessFileURL({
+    projectKey,
+    resourceType,
+    importContainerKey
+  });
+  const payload = action ? {
+    task: 'process-file',
+    parameter: {
+      resourceType,
+      action
+    }
+  } : {};
+  const response = await fetcher({
+    url: uri,
+    payload: _JSON$stringify__default["default"](payload),
+    config: {
+      proxy: constants.MC_API_PROXY_TARGETS.IMPORT,
+      method: 'POST',
+      headers: {
+        accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    }
+  });
+  assertProcessFileResponse(response);
+  return response;
+}
+function assertProcessFileResponse(maybeProcessFileResponse) {
+  const requiredFields = ['message'];
+  if (hasRequiredFields(maybeProcessFileResponse, requiredFields)) return;
+  throw new Error('Invalid response');
+}
+
+const DELIMITERS = {
+  COMMA: ',',
+  SEMICOLON: ';',
+  POINT: '.',
+  TAB: '\t',
+  PIPE: '|'
+};
+const COLUMN_DELIMITERS = [DELIMITERS.COMMA, DELIMITERS.SEMICOLON, DELIMITERS.PIPE, DELIMITERS.TAB];
+
+const FILE_IMPORT_JOB_POLLING_INTERVAL = 2000;
+
+const IMPORT_MAX_FILE_SIZE_MB = 200;
+const IMPORT_MAX_ITEM_COUNT = 500_000;
+
+// =============================================================================
+// Legacy constants (old flow) - Remove after testing and migration is complete
+// =============================================================================
+
+/** @deprecated Use IMPORT_MAX_FILE_SIZE_MB instead. Remove after migration. */
+const IMPORT_LEGACY_MAX_FILE_SIZE_MB = 35;
+
+/** @deprecated Use IMPORT_MAX_ITEM_COUNT instead. Remove after migration. */
+const IMPORT_LEGACY_MAX_ROW_COUNT = 80_000;
+
+const IMPORT_TAG_KEYS = {
+  source: 'source'
+};
+const IMPORT_TAG_VALUES = {
+  fileUpload: 'file-upload'
+};
+const TAG_KEY_SOURCE_FILE_UPLOAD = `${IMPORT_TAG_KEYS.source}:${IMPORT_TAG_VALUES.fileUpload}`;
+
+/**
+ * CommerceTools API documentation base URL
+ */
+const CT_API_DOCS_URL = 'https://docs.commercetools.com/api/';
+
+/**
+ * Template download links for each resource type
+ */
+const RESOURCE_TYPE_TEMPLATE_DOWNLOAD_LINKS = {
+  category: 'https://docs.commercetools.com/merchant-center/downloads/category_import_template.csv',
+  'custom-object': 'https://docs.commercetools.com/merchant-center/downloads/custom_object_import_template.json',
+  product: 'https://docs.commercetools.com/merchant-center/import-data#download-a-template',
+  'inventory-entry': 'https://docs.commercetools.com/merchant-center/downloads/inventory_entry_import_template.csv',
+  // TODO: remove `inventory` after aligning the resource type names in the Import API and Export API
+  inventory: 'https://docs.commercetools.com/merchant-center/downloads/inventory_entry_import_template.csv',
+  'discount-code': 'https://docs.commercetools.com/merchant-center/downloads/discount_code_import_template.csv',
+  customer: 'https://docs.commercetools.com/merchant-center/import-data#download-a-template',
+  order: 'https://docs.commercetools.com/merchant-center/import-data#download-a-template',
+  'product-type': 'https://docs.commercetools.com/merchant-center/downloads/product_type_import_template.csv',
+  'business-unit': 'https://docs.commercetools.com/merchant-center/downloads/business_unit_import_template.csv'
+};
+const RESOURCE_TYPE_DOCUMENTATION_LINKS = {
+  category: 'https://docs.commercetools.com/merchant-center/import-categories#supported-headers-and-values',
+  'custom-object': 'https://docs.commercetools.com/merchant-center/import-custom-objects#supported-fields-and-values',
+  product: 'https://docs.commercetools.com/merchant-center/import-products#supported-headers-and-values',
+  'inventory-entry': 'https://docs.commercetools.com/merchant-center/import-inventory#supported-headers-and-values',
+  // TODO: remove `inventory` after aligning the resource type names in the Import API and Export API
+  inventory: 'https://docs.commercetools.com/merchant-center/import-inventory#supported-headers-and-values',
+  'discount-code': 'https://docs.commercetools.com/merchant-center/import-discount-codes#supported-headers-and-values',
+  customer: 'https://docs.commercetools.com/merchant-center/import-customers#supported-headers-and-values',
+  order: 'https://docs.commercetools.com/merchant-center/import-orders#supported-headers-and-values',
+  'product-type': 'https://docs.commercetools.com/merchant-center/import-product-types#supported-headers-and-values',
+  'business-unit': 'https://docs.commercetools.com/merchant-center/import-business-units#supported-headers-and-values'
+};
+
+const automatedImportContainerKey = 'automated-container-key';
+const fileUploadImportContainerKey = 'eyJ0aW1lc3RhbXAiOiAxNzA1MDc0MzIxODY4LCAiZmlsZU5hbWUiOiAiZmlsZS11cGxvYWQtY29udGFpbmVyLWtleS5jc3YifQ';
+const manualImports = [{
+  key: 'eyJ0aW1lc3RhbXAiOjE2MjE0MTM0NzU4MzcsImZpbGVOYW1lIjoiX3ZhbGlkLXByb2R1Y3QuY3N2IiwiaW1wb3J0VHlwZSI6Im1hbnVhbCJ9',
+  version: 0,
+  resourceType: 'product',
+  createdAt: '2021-05-19T08:37:56.021Z',
+  lastModifiedAt: '2021-05-19T08:37:56.021Z',
+  tags: [TAG_KEY_SOURCE_FILE_UPLOAD]
+}, {
+  key: 'eyJ0aW1lc3RhbXAiOjE2MjE0MTM3Mjc0ODksImZpbGVOYW1lIjoiX3ZhbGlkLWNhdGVnb3J5LmNzdiIsImltcG9ydFR5cGUiOiJtYW51YWwifQ',
+  version: 0,
+  resourceType: 'category',
+  createdAt: '2021-05-19T08:42:07.720Z',
+  lastModifiedAt: '2021-05-19T08:42:07.720Z',
+  tags: [TAG_KEY_SOURCE_FILE_UPLOAD]
+}];
+const automatedImports = [{
+  key: 'product-import-container',
+  version: 0,
+  resourceType: 'product',
+  createdAt: '2021-04-06T06:41:33.622Z',
+  lastModifiedAt: '2021-04-06T06:41:33.622Z',
+  tags: []
+}, {
+  key: 'product-import-container-1',
+  version: 0,
+  resourceType: 'product',
+  createdAt: '2021-05-26T14:46:12.673Z',
+  lastModifiedAt: '2021-05-26T14:46:12.673Z',
+  tags: []
+}];
+const importContainers = {
+  count: 4,
+  total: 100,
+  results: _concatInstanceProperty__default["default"](manualImports).call(manualImports, automatedImports)
+};
+const importsSummaries = {
+  eyJ0aW1lc3RhbXAiOjE2MjE0MTM0NzU4MzcsImZpbGVOYW1lIjoiX3ZhbGlkLXByb2R1Y3QuY3N2IiwiaW1wb3J0VHlwZSI6Im1hbnVhbCJ9: {
+    states: {
+      validationFailed: 0,
+      unresolved: 3,
+      waitForMasterVariant: 0,
+      imported: 0,
+      rejected: 0
+    },
+    total: 3
+  },
+  eyJ0aW1lc3RhbXAiOjE2MjE0MTM3Mjc0ODksImZpbGVOYW1lIjoiX3ZhbGlkLWNhdGVnb3J5LmNzdiIsImltcG9ydFR5cGUiOiJtYW51YWwifQ: {
+    states: {
+      validationFailed: 0,
+      unresolved: 0,
+      waitForMasterVariant: 0,
+      imported: 0,
+      rejected: 0
+    },
+    total: 0
+  },
+  'product-import-container': {
+    states: {
+      validationFailed: 0,
+      unresolved: 0,
+      waitForMasterVariant: 0,
+      imported: 0,
+      rejected: 0
+    },
+    total: 0
+  },
+  'product-import-container-1': {
+    states: {
+      validationFailed: 0,
+      unresolved: 0,
+      waitForMasterVariant: 0,
+      imported: 0,
+      rejected: 0
+    },
+    total: 0
+  }
+};
+const importStatesMap = {
+  [ImportStates.Processing]: [{
+    states: {
+      unresolved: 0,
+      imported: 0,
+      rejected: 0,
+      validationFailed: 0,
+      waitForMasterVariant: 0,
+      processing: 10,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 10
+  }],
+  [ImportStates.WaitForUnresolvedReferences]: [{
+    states: {
+      unresolved: 0,
+      imported: 0,
+      rejected: 0,
+      validationFailed: 0,
+      waitForMasterVariant: 10,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 10
+  }, {
+    states: {
+      unresolved: 10,
+      imported: 0,
+      rejected: 0,
+      validationFailed: 0,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 10
+  }, {
+    states: {
+      unresolved: 10,
+      imported: 10,
+      rejected: 10,
+      validationFailed: 10,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 40
+  }],
+  [ImportStates.Failed]: [{
+    states: {
+      unresolved: 0,
+      imported: 0,
+      rejected: 4,
+      validationFailed: 4,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 8
+  }, {
+    states: {
+      unresolved: 0,
+      imported: 0,
+      rejected: 10,
+      validationFailed: 0,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 10
+  }, {
+    states: {
+      unresolved: 0,
+      imported: 0,
+      rejected: 0,
+      validationFailed: 10,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 10
+  }],
+  [ImportStates.PartiallyCompleted]: [{
+    states: {
+      unresolved: 0,
+      imported: 2,
+      rejected: 1,
+      validationFailed: 0,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 3
+  }, {
+    states: {
+      unresolved: 0,
+      imported: 10,
+      rejected: 10,
+      validationFailed: 10,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 30
+  }],
+  [ImportStates.SuccessfullyCompleted]: [{
+    states: {
+      unresolved: 0,
+      imported: 20,
+      rejected: 0,
+      validationFailed: 0,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 20
+  }, {
+    states: {
+      unresolved: 0,
+      imported: 10,
+      rejected: 0,
+      validationFailed: 0,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 10
+  }],
+  [ImportStates.NoRunningImports]: [{
+    states: {
+      unresolved: 0,
+      imported: 0,
+      rejected: 0,
+      validationFailed: 0,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 0,
+      deleted: 0
+    },
+    total: 0
+  }],
+  [ImportStates.Canceled]: [{
+    states: {
+      unresolved: 0,
+      imported: 0,
+      rejected: 0,
+      validationFailed: 0,
+      waitForMasterVariant: 0,
+      processing: 0,
+      canceled: 10,
+      deleted: 0
+    },
+    total: 10
+  }]
+};
+const validFileUploadResponse = {
+  results: [],
+  invalid: 0,
+  valid: 2,
+  fileName: 'categories.csv',
+  itemsCount: 2,
+  rowsCount: 2,
+  columnsCount: 11,
+  fields: ['id', 'lastModifiedAt', 'key', 'name.en', 'name.de', 'slug.en', 'slug.de', 'orderHint', 'externalId', 'description.en', 'description.de'],
+  ignoredFields: ['id', 'lastModifiedAt']
+};
+const invalidFileUploadResponse = {
+  invalid: 2,
+  valid: 0,
+  fileName: 'categories.csv',
+  itemsCount: 2,
+  rowsCount: 2,
+  columnsCount: 11,
+  fields: ['key', 'externalId2', 'orderHint', 'name.de2', 'description.de2', 'slug.RU', 'name.enn', 'description.en', 'slug.RU', 'test1', 'test2'],
+  ignoredFields: [],
+  results: [{
+    row: 1,
+    errors: [{
+      code: 'InvalidField',
+      message: '"externalId2" is not allowed',
+      field: 'externalId2'
+    }, {
+      code: 'InvalidField',
+      message: '"name.de2" is not allowed',
+      field: 'name.de2'
+    }, {
+      code: 'InvalidField',
+      message: '"name.enn" is not allowed',
+      field: 'name.enn'
+    }, {
+      code: 'InvalidField',
+      message: '"slug.RU" is not allowed',
+      field: 'slug.RU'
+    }, {
+      code: 'InvalidField',
+      message: '"test1" is not allowed',
+      field: 'test1'
+    }, {
+      code: 'InvalidField',
+      message: '"test2" is not allowed',
+      field: 'test2'
+    }]
+  }]
+};
+const allAutomatedImportOperations = [{
+  version: 1,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'sample-3',
+  id: 'fcbdb268-6bf0-4161-82ae-5bcd2c0ca1c3',
+  state: 'ValidationFailed',
+  errors: [{
+    code: 'InvalidOperation',
+    message: "The attributes contain definitions with duplicate names: '[product-ref-attribute]'."
+  }],
+  createdAt: '2021-08-03T10:13:52.867Z',
+  lastModifiedAt: '2021-08-03T10:13:53.031Z',
+  expiresAt: '2021-08-05T10:13:52.867Z'
+}, {
+  version: 1,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'sample-2',
+  id: 'c350f282-af46-44bd-b7fb-7767fe060b5d',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-03T10:13:10.544Z',
+  lastModifiedAt: '2021-08-03T10:13:11.056Z',
+  expiresAt: '2021-08-05T10:13:10.544Z'
+}, {
+  version: 1,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'sample',
+  id: '50e01254-842a-4a94-9dc5-bd5d907a96f3',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-03T10:12:16.293Z',
+  lastModifiedAt: '2021-08-03T10:12:16.352Z',
+  expiresAt: '2021-08-05T10:12:16.293Z'
+}, {
+  version: 1,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'sample',
+  id: '5679b11b-e6b2-44e3-bb32-feec7ee4295f',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-03T10:12:13.955Z',
+  lastModifiedAt: '2021-08-03T10:12:14.019Z',
+  expiresAt: '2021-08-05T10:12:13.955Z'
+}, {
+  version: 1,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'sample',
+  id: '8ed41629-9e00-4779-abd7-ca054102690e',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-03T10:12:07.214Z',
+  lastModifiedAt: '2021-08-03T10:12:07.364Z',
+  expiresAt: '2021-08-05T10:12:07.214Z'
+}, {
+  version: 3,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'product-draft-key',
+  id: '3f4d0fb6-95c0-444b-8e25-dbe1d6f25a54',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-02T12:25:17.465Z',
+  lastModifiedAt: '2021-08-02T12:25:34.673Z',
+  expiresAt: '2021-08-04T12:25:17.465Z'
+}, {
+  version: 3,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'product-draft-key',
+  id: 'b3e4e438-3afd-46ed-929c-761286b839b4',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-02T12:25:20.019Z',
+  lastModifiedAt: '2021-08-02T12:25:34.657Z',
+  expiresAt: '2021-08-04T12:25:20.019Z'
+}, {
+  version: 3,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'product-draft-key',
+  id: '8991ee30-2ad0-4e95-b784-e26e7672b49d',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-02T12:25:20.454Z',
+  lastModifiedAt: '2021-08-02T12:25:34.629Z',
+  expiresAt: '2021-08-04T12:25:20.454Z'
+}, {
+  version: 3,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'product-draft-key',
+  id: 'd0a97b14-2927-414e-ae66-d20a27048418',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-02T12:25:21.108Z',
+  lastModifiedAt: '2021-08-02T12:25:34.570Z',
+  expiresAt: '2021-08-04T12:25:21.108Z'
+}, {
+  version: 1,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'sample',
+  id: '702fbe9e-81c2-4daf-abd9-4c3f10ed9431',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-02T12:25:27.585Z',
+  lastModifiedAt: '2021-08-02T12:25:32.802Z',
+  expiresAt: '2021-08-04T12:25:27.585Z'
+}];
+const successfulFileUploadImportOperations = [{
+  version: 1,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'sample-2',
+  id: 'c350f282-af46-44bd-b7fb-7767fe060b5d',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-03T10:13:10.544Z',
+  lastModifiedAt: '2021-08-03T10:13:11.056Z',
+  expiresAt: '2021-08-05T10:13:10.544Z',
+  tags: ['rowStartNumber:1']
+}];
+const allFileUploadImportOperations = [{
+  version: 1,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'sample-3',
+  id: 'fcbdb268-6bf0-4161-82ae-5bcd2c0ca1c3',
+  state: 'ValidationFailed',
+  errors: [{
+    code: 'InvalidOperation',
+    message: "The attributes contain definitions with duplicate names: '[product-ref-attribute]'."
+  }],
+  createdAt: '2021-08-03T10:13:52.867Z',
+  lastModifiedAt: '2021-08-03T10:13:53.031Z',
+  expiresAt: '2021-08-05T10:13:52.867Z',
+  tags: ['rowStartNumber:1']
+}, {
+  version: 1,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'sample-2',
+  id: 'c350f282-af46-44bd-b7fb-7767fe060b5d',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-03T10:13:10.544Z',
+  lastModifiedAt: '2021-08-03T10:13:11.056Z',
+  expiresAt: '2021-08-05T10:13:10.544Z',
+  tags: ['rowStartNumber:2']
+}, {
+  version: 1,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'sample',
+  id: '50e01254-842a-4a94-9dc5-bd5d907a96f3',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-03T10:12:16.293Z',
+  lastModifiedAt: '2021-08-03T10:12:16.352Z',
+  expiresAt: '2021-08-05T10:12:16.293Z',
+  tags: ['rowStartNumber:3']
+}, {
+  version: 1,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'sample',
+  id: '5679b11b-e6b2-44e3-bb32-feec7ee4295f',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-03T10:12:13.955Z',
+  lastModifiedAt: '2021-08-03T10:12:14.019Z',
+  expiresAt: '2021-08-05T10:12:13.955Z',
+  tags: ['rowStartNumber:4']
+}, {
+  version: 1,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'sample',
+  id: '8ed41629-9e00-4779-abd7-ca054102690e',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-03T10:12:07.214Z',
+  lastModifiedAt: '2021-08-03T10:12:07.364Z',
+  expiresAt: '2021-08-05T10:12:07.214Z',
+  tags: ['rowStartNumber:5']
+}, {
+  version: 3,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'product-draft-key',
+  id: '3f4d0fb6-95c0-444b-8e25-dbe1d6f25a54',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-02T12:25:17.465Z',
+  lastModifiedAt: '2021-08-02T12:25:34.673Z',
+  expiresAt: '2021-08-04T12:25:17.465Z',
+  tags: ['rowStartNumber:6']
+}, {
+  version: 3,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'product-draft-key',
+  id: 'b3e4e438-3afd-46ed-929c-761286b839b4',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-02T12:25:20.019Z',
+  lastModifiedAt: '2021-08-02T12:25:34.657Z',
+  expiresAt: '2021-08-04T12:25:20.019Z',
+  tags: ['rowStartNumber:7']
+}, {
+  version: 3,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'product-draft-key',
+  id: '8991ee30-2ad0-4e95-b784-e26e7672b49d',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-02T12:25:20.454Z',
+  lastModifiedAt: '2021-08-02T12:25:34.629Z',
+  expiresAt: '2021-08-04T12:25:20.454Z',
+  tags: ['rowStartNumber:8']
+}, {
+  version: 3,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'product-draft-key',
+  id: 'd0a97b14-2927-414e-ae66-d20a27048418',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-02T12:25:21.108Z',
+  lastModifiedAt: '2021-08-02T12:25:34.570Z',
+  expiresAt: '2021-08-04T12:25:21.108Z',
+  tags: ['rowStartNumber:9']
+}, {
+  version: 1,
+  importContainerKey: fileUploadImportContainerKey,
+  resourceKey: 'sample',
+  id: '702fbe9e-81c2-4daf-abd9-4c3f10ed9431',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-02T12:25:27.585Z',
+  lastModifiedAt: '2021-08-02T12:25:32.802Z',
+  expiresAt: '2021-08-04T12:25:27.585Z',
+  tags: ['rowStartNumber:10']
+}];
+const allFileUploadImportOperationsResponse = {
+  limit: 20,
+  offset: 0,
+  count: 10,
+  total: 10,
+  results: allFileUploadImportOperations
+};
+const allAutomatedImportOperationsResponse = {
+  limit: 20,
+  offset: 0,
+  count: 10,
+  total: 10,
+  results: allAutomatedImportOperations
+};
+const successfulAutomatedImportOperations = [{
+  version: 1,
+  importContainerKey: automatedImportContainerKey,
+  resourceKey: 'sample-2',
+  id: 'c350f282-af46-44bd-b7fb-7767fe060b5d',
+  state: 'imported',
+  resourceVersion: 1,
+  errors: [],
+  createdAt: '2021-08-03T10:13:10.544Z',
+  lastModifiedAt: '2021-08-03T10:13:11.056Z',
+  expiresAt: '2021-08-05T10:13:10.544Z'
+}];
+const successfulAutomatedImportOperationsResponse = {
+  limit: 1,
+  offset: 0,
+  count: 1,
+  total: 1,
+  results: successfulAutomatedImportOperations
+};
+const successfulFileUploadImportOperationsResponse = {
+  limit: 1,
+  offset: 0,
+  count: 1,
+  total: 1,
+  results: successfulFileUploadImportOperations
+};
+const fileUploadMissingKeysResponse = {
+  code: 'MissingCsvFieldIdentifier',
+  message: 'Importing a new field without an identifier is not allowed',
+  rowValue: {
+    uri: 'http://example.com/asset-source-without-key',
+    key: undefined
+  },
+  metadata: {
+    row: 1
+  }
+};
+const validProcessFileResponse = {
+  message: 'acknowledged'
+};
+const exportOperationsCompleted = [{
+  id: '10df6fe9252eeb1d54485795',
+  fileName: 'test-12345.json',
+  fileFormat: 'json',
+  resourceType: 'category',
+  createdAt: '2023-04-01T12:00:00.000Z',
+  state: 'completed',
+  query: 'query ExportCategories { categories { id } }',
+  completedPercentage: 100,
+  resourceCount: 100,
+  fields: ['id'],
+  locales: ['en']
+}, {
+  id: '10df6fe9252eeb1d54485796',
+  fileName: 'test-123456.csv',
+  fileFormat: 'csv',
+  resourceType: 'category',
+  createdAt: '2023-04-02T12:00:00.000Z',
+  state: 'completed',
+  query: 'query ExportCategories { categories { id } }',
+  completedPercentage: 100,
+  resourceCount: 100,
+  fields: ['id'],
+  locales: ['en']
+}];
+const exportOperationsProcessing = [{
+  id: '10df6fe9252eeb1d54485797',
+  fileName: 'test-1234567.json',
+  fileFormat: 'json',
+  resourceType: 'category',
+  createdAt: '2023-04-01T12:00:00.000Z',
+  state: 'processing',
+  query: 'query ExportCategories { categories { id } }',
+  completedPercentage: 50,
+  resourceCount: 100,
+  fields: ['id'],
+  locales: ['en']
+}, {
+  id: '10df6fe9252eeb1d54485798',
+  fileName: 'test-12345678.csv',
+  fileFormat: 'csv',
+  resourceType: 'category',
+  createdAt: '2023-04-02T12:00:00.000Z',
+  state: 'processing',
+  query: 'query ExportCategories { categories { id } }',
+  completedPercentage: 33,
+  resourceCount: 100,
+  fields: ['id'],
+  locales: ['en']
+}];
+const validFileImportJobQueued = {
+  id: 'job-uuid-12345',
+  fileName: 'categories.csv',
+  importContainerKey: 'container-key',
+  state: 'queued',
+  summary: {
+    total: 0,
+    valid: 0,
+    invalid: 0,
+    fieldsCount: 0,
+    fields: [],
+    ignoredFields: []
+  }
+};
+const validFileImportJobProcessing = {
+  id: 'job-uuid-12345',
+  fileName: 'categories.csv',
+  importContainerKey: 'container-key',
+  state: 'processing',
+  summary: {
+    total: 0,
+    valid: 0,
+    invalid: 0,
+    fieldsCount: 0,
+    fields: [],
+    ignoredFields: []
+  }
+};
+const validFileImportJobValidated = {
+  id: 'job-uuid-12345',
+  fileName: 'categories.csv',
+  importContainerKey: 'container-key',
+  state: 'validated',
+  summary: {
+    total: 2,
+    valid: 2,
+    invalid: 0,
+    fieldsCount: 2,
+    fields: ['key', 'name.en'],
+    ignoredFields: ['id', 'lastModifiedAt']
+  }
+};
+const invalidFileImportJobValidated = {
+  id: 'job-uuid-12345',
+  fileName: 'categories.csv',
+  importContainerKey: 'container-key',
+  state: 'validated',
+  summary: {
+    total: 2,
+    valid: 0,
+    invalid: 2,
+    fieldsCount: 11,
+    fields: ['key', 'externalId2', 'orderHint', 'name.de2', 'description.de2', 'slug.RU', 'name.enn', 'description.en', 'slug.RU', 'test1', 'test2'],
+    ignoredFields: []
+  }
+};
+const validFileImportJobRecordsResponse = {
+  results: [],
+  total: 0,
+  limit: 20,
+  offset: 0,
+  count: 0
+};
+const invalidFileImportJobRecordsResponse = {
+  results: [{
+    index: 1,
+    errors: [{
+      code: 'InvalidField',
+      message: '"externalId2" is not allowed',
+      field: 'externalId2'
+    }, {
+      code: 'InvalidField',
+      message: '"orderHint" is not allowed',
+      field: 'orderHint'
+    }]
+  }, {
+    index: 2,
+    errors: [{
+      code: 'InvalidField',
+      message: '"name.de2" is not allowed',
+      field: 'name.de2'
+    }]
+  }],
+  total: 2,
+  limit: 20,
+  offset: 0,
+  count: 2
+};
+const processFileImportJobResponse = {
+  message: 'acknowledged'
+};
+
+function ownKeys$5(e, r) { var t = _Object$keys__default["default"](e); if (_Object$getOwnPropertySymbols__default["default"]) { var o = _Object$getOwnPropertySymbols__default["default"](e); r && (o = _filterInstanceProperty__default["default"](o).call(o, function (r) { return _Object$getOwnPropertyDescriptor__default["default"](e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$5(e) { for (var r = 1; r < arguments.length; r++) { var _context, _context2; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty__default["default"](_context = ownKeys$5(Object(t), !0)).call(_context, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](e, _Object$getOwnPropertyDescriptors__default["default"](t)) : _forEachInstanceProperty__default["default"](_context2 = ownKeys$5(Object(t))).call(_context2, function (r) { _Object$defineProperty__default["default"](e, r, _Object$getOwnPropertyDescriptor__default["default"](t, r)); }); } return e; }
+const FileIcon = props => /*#__PURE__*/jsxRuntime.jsxs("svg", _objectSpread$5(_objectSpread$5({
+  width: "32",
+  height: "32",
+  viewBox: "0 0 32 32",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+}, props), {}, {
+  children: [/*#__PURE__*/jsxRuntime.jsx("mask", {
+    id: "mask0_17_6643",
+    style: {
+      maskType: 'alpha'
+    },
+    maskUnits: "userSpaceOnUse",
+    x: "0",
+    y: "0",
+    width: "32",
+    height: "32",
+    children: /*#__PURE__*/jsxRuntime.jsx("rect", {
+      width: "32",
+      height: "32",
+      fill: "#D9D9D9"
+    })
+  }), /*#__PURE__*/jsxRuntime.jsx("g", {
+    mask: "url(#mask0_17_6643)",
+    children: /*#__PURE__*/jsxRuntime.jsx("path", {
+      d: "M14.6667 25.3333H17.3333V19.7667L19.4667 21.9L21.3333 20L16 14.6667L10.6667 20L12.5667 21.8667L14.6667 19.7667V25.3333ZM8 29.3333C7.26667 29.3333 6.63889 29.0722 6.11667 28.55C5.59444 28.0278 5.33333 27.4 5.33333 26.6667V5.33332C5.33333 4.59999 5.59444 3.97221 6.11667 3.44999C6.63889 2.92777 7.26667 2.66666 8 2.66666H18.6667L26.6667 10.6667V26.6667C26.6667 27.4 26.4056 28.0278 25.8833 28.55C25.3611 29.0722 24.7333 29.3333 24 29.3333H8ZM17.3333 12H24L17.3333 5.33332V12Z",
+      fill: "#B1ACFF"
+    })
+  })]
+}));
+
+const EnabledDropArea = _ref => {
+  let dragAndDropText = _ref.dragAndDropText,
+    orText = _ref.orText,
+    browseFileText = _ref.browseFileText;
+  return /*#__PURE__*/jsxRuntime.jsxs(uiKit.Spacings.Inline, {
+    alignItems: "center",
+    justifyContent: "center",
+    scale: "s",
+    children: [/*#__PURE__*/jsxRuntime.jsx(FileIcon, {}), /*#__PURE__*/jsxRuntime.jsxs(uiKit.Spacings.Inline, {
+      alignItems: "center",
+      scale: "s",
+      children: [/*#__PURE__*/jsxRuntime.jsx(uiKit.Text.Subheadline, {
+        as: "h4",
+        children: dragAndDropText
+      }), /*#__PURE__*/jsxRuntime.jsx(uiKit.Text.Body, {
+        children: orText
+      }), /*#__PURE__*/jsxRuntime.jsx(uiKit.Link, {
+        tone: "secondary",
+        to: "",
+        onClick: ev => ev.preventDefault(),
+        children: browseFileText
+      })]
+    })]
+  });
+};
+
+const FileDroppedArea = _ref => {
+  let fileName = _ref.fileName,
+    chooseFileLabel = _ref.chooseFileLabel;
+  return /*#__PURE__*/jsxRuntime.jsxs(uiKit.Spacings.Stack, {
+    alignItems: "center",
+    scale: "s",
+    children: [/*#__PURE__*/jsxRuntime.jsxs(uiKit.Spacings.Inline, {
+      alignItems: "flex-start",
+      scale: "xs",
+      children: [/*#__PURE__*/jsxRuntime.jsx(uiKit.PaperclipIcon, {
+        color: "neutral60"
+      }), /*#__PURE__*/jsxRuntime.jsx(uiKit.Constraints.Horizontal, {
+        max: 13,
+        children: /*#__PURE__*/jsxRuntime.jsx(uiKit.Text.Body, {
+          children: fileName
+        })
+      })]
+    }), /*#__PURE__*/jsxRuntime.jsx(uiKit.SecondaryButton, {
+      tone: "secondary",
+      size: "medium",
+      label: chooseFileLabel
+    })]
+  });
+};
+
+const ActiveDragDropArea = _ref => {
+  let isFileDropped = _ref.isFileDropped,
+    fileName = _ref.fileName,
+    chooseFileLabel = _ref.chooseFileLabel,
+    dragAndDropText = _ref.dragAndDropText,
+    orText = _ref.orText,
+    browseFileText = _ref.browseFileText;
+  if (isFileDropped) {
+    return /*#__PURE__*/jsxRuntime.jsx(FileDroppedArea, {
+      fileName: fileName,
+      chooseFileLabel: chooseFileLabel
+    });
+  }
+  return /*#__PURE__*/jsxRuntime.jsx(EnabledDropArea, {
+    dragAndDropText: dragAndDropText,
+    orText: orText,
+    browseFileText: browseFileText
+  });
+};
+
+function ownKeys$4(e, r) { var t = _Object$keys__default["default"](e); if (_Object$getOwnPropertySymbols__default["default"]) { var o = _Object$getOwnPropertySymbols__default["default"](e); r && (o = _filterInstanceProperty__default["default"](o).call(o, function (r) { return _Object$getOwnPropertyDescriptor__default["default"](e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$4(e) { for (var r = 1; r < arguments.length; r++) { var _context, _context2; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty__default["default"](_context = ownKeys$4(Object(t), !0)).call(_context, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](e, _Object$getOwnPropertyDescriptors__default["default"](t)) : _forEachInstanceProperty__default["default"](_context2 = ownKeys$4(Object(t))).call(_context2, function (r) { _Object$defineProperty__default["default"](e, r, _Object$getOwnPropertyDescriptor__default["default"](t, r)); }); } return e; }
+const LockIcon = props => /*#__PURE__*/jsxRuntime.jsxs("svg", _objectSpread$4(_objectSpread$4({
+  width: "87px",
+  height: "118px",
+  viewBox: "0 0 87 118",
+  version: "1.1",
+  xmlns: "http://www.w3.org/2000/svg",
+  xmlnsXlink: "http://www.w3.org/1999/xlink"
+}, props), {}, {
+  children: [/*#__PURE__*/jsxRuntime.jsx("title", {
+    children: "Shape"
+  }), /*#__PURE__*/jsxRuntime.jsx("g", {
+    id: "Final-ImportBoard",
+    stroke: "none",
+    strokeWidth: "1",
+    fill: "none",
+    fillRule: "evenodd",
+    children: /*#__PURE__*/jsxRuntime.jsx("g", {
+      id: "2-Upload-files---Locked",
+      transform: "translate(-697.000000, -285.000000)",
+      fill: "#999999",
+      fillRule: "nonzero",
+      children: /*#__PURE__*/jsxRuntime.jsx("path", {
+        d: "M781.167075,334.924997 L774.342717,334.924997 L774.342717,319.039771 C774.342717,300.267972 759.042508,285 740.22093,285 C721.403902,285 706.099143,300.267972 706.099143,319.039771 L706.099143,334.924997 L699.274786,334.924997 C698.019104,334.924997 697,335.941652 697,337.194315 L697,389.184392 C697,389.974114 697.414011,390.709373 698.087348,391.122389 C710.839797,398.892534 725.407525,403 740.22093,403 C755.034335,403 769.602064,398.892534 782.359062,391.122389 C783.027849,390.709373 783.44186,389.974114 783.44186,389.184392 L783.44186,337.194315 C783.44186,335.941652 782.418207,334.924997 781.167075,334.924997 Z M745.590495,368.913821 L745.590495,384.782392 C745.590495,386.353821 744.382343,387.639535 742.905713,387.639535 L737.536148,387.639535 C736.054148,387.639535 734.851365,386.353821 734.851365,384.782392 L734.851365,368.913821 C731.651104,366.930963 729.4818,363.296678 729.4818,359.068106 C729.4818,352.759535 734.29293,347.639535 740.22093,347.639535 C746.14893,347.639535 750.960061,352.759535 750.960061,359.068106 C750.960061,363.285249 748.790756,366.930963 745.590495,368.913821 Z M760.116279,334.395349 L718.953488,334.395349 L718.953488,318.787791 C718.953488,307.724262 728.187674,298.72093 739.534884,298.72093 C750.877519,298.72093 760.116279,307.724262 760.116279,318.787791 L760.116279,334.395349 Z",
+        id: "Shape"
+      })
+    })
+  })]
+}));
+
+const DisabledDropArea = _ref => {
+  let disabledMessage = _ref.disabledMessage;
+  return /*#__PURE__*/jsxRuntime.jsxs(uiKit.Spacings.Stack, {
+    alignItems: "center",
+    children: [/*#__PURE__*/jsxRuntime.jsx(LockIcon, {}), disabledMessage && /*#__PURE__*/jsxRuntime.jsx(uiKit.Text.Body, {
+      children: disabledMessage
+    })]
+  });
+};
+
+const getBorderColor = state => {
+  const borderColors = {
+    default: '#909dbc',
+    error: '#e60050',
+    active: uiKit.customProperties.colorPrimary
+  };
+  return borderColors[state] || borderColors.default;
+};
+const getDashedBorder = function () {
+  let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'default';
+  const color = getBorderColor(state);
+  const svgContent = `
+    <svg width="100%" height="100%" xmlns="http://www.w3.org/2000/svg">
+      <rect width="100%" height="100%" fill="none" stroke="${color}" stroke-width="2px" stroke-dasharray="6,6" stroke-dashoffset="0" stroke-linecap="square"/>
+    </svg>
+  `;
+  return `data:image/svg+xml,${encodeURIComponent(svgContent)}`;
+};
+const base = /*#__PURE__*/react.css("border-radius:", uiKit.customProperties.borderRadius6, ";min-height:136px;display:flex;justify-content:center;align-items:center;" + (process.env.NODE_ENV === "production" ? "" : ";label:base;"));
+const disabled = /*#__PURE__*/react.css(process.env.NODE_ENV === "production" ? "" : ";label:disabled;");
+const readyForDrop = /*#__PURE__*/react.css("background-image:url('", getDashedBorder(), "');background-color:", uiKit.customProperties.colorSurface, ";" + (process.env.NODE_ENV === "production" ? "" : ";label:readyForDrop;"));
+const activeDrag = /*#__PURE__*/react.css("background-image:url('", getDashedBorder('active'), "');background-color:", uiKit.customProperties.colorPrimary95, ";padding:", uiKit.customProperties.spacing50, " 100px;" + (process.env.NODE_ENV === "production" ? "" : ";label:activeDrag;"));
+const fileDropped = /*#__PURE__*/react.css("background-image:url('", getDashedBorder(), "');background-color:", uiKit.customProperties.colorSurface, ";padding:", uiKit.customProperties.spacing50, " 100px;" + (process.env.NODE_ENV === "production" ? "" : ";label:fileDropped;"));
+const invalid = /*#__PURE__*/react.css("background-image:url('", getDashedBorder('default'), "');background-color:", uiKit.customProperties.colorSurface, ";padding:", uiKit.customProperties.spacing70, " 100px;" + (process.env.NODE_ENV === "production" ? "" : ";label:invalid;"));
+const parsing = /*#__PURE__*/react.css("background-image:url('", getDashedBorder(), "');background-color:", uiKit.customProperties.colorSurface, ";padding:", uiKit.customProperties.spacing50, " 100px;" + (process.env.NODE_ENV === "production" ? "" : ";label:parsing;"));
+const dropAreaStyles = {
+  base,
+  readyForDrop,
+  fileDropped,
+  disabled,
+  activeDrag,
+  invalid,
+  parsing
+};
+
+const DropAreaWrapper = /*#__PURE__*/_styled__default["default"]("div", process.env.NODE_ENV === "production" ? {
+  target: "exmxphg0"
+} : {
+  target: "exmxphg0",
+  label: "DropAreaWrapper"
+})(dropAreaStyles.base, " ", props => {
+  if (props.dropAreaState === 'disabled') {
+    return dropAreaStyles.disabled;
+  }
+  if (props.dropAreaState === 'ready-for-drop') {
+    return dropAreaStyles.readyForDrop;
+  }
+  if (props.dropAreaState === 'active-drag') {
+    return dropAreaStyles.activeDrag;
+  }
+  if (props.dropAreaState === 'invalid') {
+    return dropAreaStyles.invalid;
+  }
+  if (props.dropAreaState === 'is-parsing') {
+    return dropAreaStyles.parsing;
+  }
+  if (props.dropAreaState === 'file-dropped') {
+    return dropAreaStyles.fileDropped;
+  }
+  return getDefaultDropWrapperStyles(props.dropAreaState);
+}, ";");
+function getDefaultDropWrapperStyles(_dropAreaState) {
+  return /*#__PURE__*/react.css(process.env.NODE_ENV === "production" ? "" : ";label:getDefaultDropWrapperStyles;");
+}
+
+function ownKeys$3(e, r) { var t = _Object$keys__default["default"](e); if (_Object$getOwnPropertySymbols__default["default"]) { var o = _Object$getOwnPropertySymbols__default["default"](e); r && (o = _filterInstanceProperty__default["default"](o).call(o, function (r) { return _Object$getOwnPropertyDescriptor__default["default"](e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$3(e) { for (var r = 1; r < arguments.length; r++) { var _context7, _context8; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty__default["default"](_context7 = ownKeys$3(Object(t), !0)).call(_context7, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](e, _Object$getOwnPropertyDescriptors__default["default"](t)) : _forEachInstanceProperty__default["default"](_context8 = ownKeys$3(Object(t))).call(_context8, function (r) { _Object$defineProperty__default["default"](e, r, _Object$getOwnPropertyDescriptor__default["default"](t, r)); }); } return e; }
+const FileDropArea = _ref => {
+  let onDrop = _ref.onDrop,
+    disabled = _ref.disabled,
+    accept = _ref.accept,
+    getDropAreaState = _ref.getDropAreaState,
+    children = _ref.children,
+    handleDropRejected = _ref.onDropRejected;
+  const _useDropzone = reactDropzone.useDropzone({
+      onDrop,
+      multiple: false,
+      disabled,
+      accept,
+      onDropRejected: _ref2 => {
+        var _context, _context2, _context3, _context4, _context5, _context6;
+        let _ref3 = _slicedToArray(_ref2, 1),
+          rejectedFile = _ref3[0];
+        if (!handleDropRejected) return;
+        if (((_context = rejectedFile) == null ? void 0 : _bindInstanceProperty__default["default"](_context3 = Function.call).call(_context3, _someInstanceProperty__default["default"](_context2 = _context.errors), _context2))?.(error => error.code === 'too-many-files')) {
+          handleDropRejected('too-many-files');
+          return;
+        }
+        if (((_context4 = rejectedFile) == null ? void 0 : _bindInstanceProperty__default["default"](_context6 = Function.call).call(_context6, _someInstanceProperty__default["default"](_context5 = _context4.errors), _context5))?.(error => error.code === 'file-invalid-type')) {
+          handleDropRejected('invalid-type');
+        } else {
+          handleDropRejected('generic');
+        }
+      }
+    }),
+    getRootProps = _useDropzone.getRootProps,
+    getInputProps = _useDropzone.getInputProps,
+    isDragActive = _useDropzone.isDragActive;
+  const dropAreaState = getDropAreaState(isDragActive);
+  return /*#__PURE__*/jsxRuntime.jsxs(DropAreaWrapper, _objectSpread$3(_objectSpread$3({
+    role: "presentation"
+  }, getRootProps()), {}, {
+    dropAreaState: dropAreaState,
+    children: [/*#__PURE__*/jsxRuntime.jsx("input", _objectSpread$3({
+      "data-testid": "file-input"
+    }, getInputProps())), /*#__PURE__*/jsxRuntime.jsx(uiKit.Constraints.Horizontal, {
+      children: children(dropAreaState)
+    })]
+  }));
+};
+
+const InfoBox = _ref => {
+  let title = _ref.title,
+    description = _ref.description;
+  return /*#__PURE__*/jsxRuntime.jsx(uiKit.ContentNotification, {
+    type: "info",
+    children: /*#__PURE__*/jsxRuntime.jsx(uiKit.Spacings.Inset, {
+      scale: "xs",
+      children: /*#__PURE__*/jsxRuntime.jsxs(uiKit.Spacings.Stack, {
+        scale: "xs",
+        children: [/*#__PURE__*/jsxRuntime.jsx(uiKit.Text.Subheadline, {
+          as: "h4",
+          children: title
+        }), /*#__PURE__*/jsxRuntime.jsx(uiKit.Text.Body, {
+          children: description
+        })]
+      })
+    })
+  });
+};
+
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+var _ref = process.env.NODE_ENV === "production" ? {
+  name: "lt3z56",
+  styles: "width:calc(50% - 16px)"
+} : {
+  name: "1vfe1dp-UploadSeparator",
+  styles: "width:calc(50% - 16px);label:UploadSeparator;",
+  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+};
+const UploadSeparator = _ref2 => {
+  let value = _ref2.value,
+    onChange = _ref2.onChange,
+    separatorTitle = _ref2.separatorTitle,
+    decimalsSeparatorDescription = _ref2.decimalsSeparatorDescription,
+    decimalSeparatorPointLabel = _ref2.decimalSeparatorPointLabel,
+    decimalSeparatorCommaLabel = _ref2.decimalSeparatorCommaLabel,
+    decimalsLabel = _ref2.decimalsLabel;
+  const decimalSeparatorOptions = [{
+    label: decimalSeparatorPointLabel,
+    value: DELIMITERS.POINT
+  }, {
+    label: decimalSeparatorCommaLabel,
+    value: DELIMITERS.COMMA
+  }];
+  return /*#__PURE__*/jsxRuntime.jsxs(uiKit.Spacings.Stack, {
+    scale: "m",
+    children: [/*#__PURE__*/jsxRuntime.jsxs("div", {
+      children: [/*#__PURE__*/jsxRuntime.jsx(uiKit.Text.Subheadline, {
+        as: "h4",
+        children: separatorTitle
+      }), /*#__PURE__*/jsxRuntime.jsx(uiKit.Text.Caption, {
+        tone: "tertiary",
+        children: decimalsSeparatorDescription
+      })]
+    }), /*#__PURE__*/jsxRuntime.jsx("div", {
+      css: _ref,
+      children: /*#__PURE__*/jsxRuntime.jsx(uiKit.SelectField, {
+        title: decimalsLabel,
+        isSearchable: false,
+        options: decimalSeparatorOptions,
+        value: value,
+        onChange: e => {
+          onChange(e.target.value);
+        }
+      })
+    })]
+  });
+};
+
+const UploadSettings = _ref => {
+  let resourceType = _ref.resourceType,
+    isPublishChecked = _ref.isPublishChecked,
+    onPublishChange = _ref.onPublishChange,
+    publishProductsLabel = _ref.publishProductsLabel,
+    dataTrackingTarget = _ref.dataTrackingTarget,
+    canPublishProducts = _ref.canPublishProducts;
+  if (resourceType !== 'product' || !canPublishProducts) {
+    return null;
+  }
+  return /*#__PURE__*/jsxRuntime.jsx(uiKit.CheckboxInput, {
+    "data-tracking-target": dataTrackingTarget,
+    isChecked: isPublishChecked,
+    onChange: e => {
+      onPublishChange(e.target.checked);
+    },
+    children: publishProductsLabel
+  });
+};
+
+const UploadingModal = _ref => {
+  let isOpen = _ref.isOpen,
+    title = _ref.title,
+    fileName = _ref.fileName,
+    fileSize = _ref.fileSize,
+    progress = _ref.progress,
+    cancelLabel = _ref.cancelLabel,
+    onCancel = _ref.onCancel,
+    onClose = _ref.onClose,
+    statusMessage = _ref.statusMessage;
+  return /*#__PURE__*/jsxRuntime.jsx(applicationComponents.InfoDialog, {
+    size: 16,
+    isOpen: isOpen,
+    title: title,
+    onClose: onClose,
+    children: /*#__PURE__*/jsxRuntime.jsxs(uiKit.Spacings.Stack, {
+      scale: "m",
+      children: [/*#__PURE__*/jsxRuntime.jsxs(uiKit.Spacings.Inline, {
+        alignItems: "center",
+        justifyContent: "space-between",
+        children: [/*#__PURE__*/jsxRuntime.jsxs(uiKit.Spacings.Inline, {
+          alignItems: "center",
+          children: [/*#__PURE__*/jsxRuntime.jsx(FileIcon, {}), /*#__PURE__*/jsxRuntime.jsx(uiKit.Spacings.Inline, {
+            children: /*#__PURE__*/jsxRuntime.jsx(uiKit.Constraints.Horizontal, {
+              max: 10,
+              children: /*#__PURE__*/jsxRuntime.jsx(uiKit.Text.Body, {
+                truncate: true,
+                isBold: true,
+                children: fileName
+              })
+            })
+          }), /*#__PURE__*/jsxRuntime.jsxs(uiKit.Text.Body, {
+            tone: "secondary",
+            children: ["(", convertFileSizeToKB(fileSize).toLocaleString(), " KB)"]
+          })]
+        }), /*#__PURE__*/jsxRuntime.jsx(uiKit.SecondaryButton, {
+          tone: "secondary",
+          size: "medium",
+          label: cancelLabel,
+          onClick: onCancel
+        })]
+      }), /*#__PURE__*/jsxRuntime.jsx(uiKit.ProgressBar, {
+        barWidth: "scale",
+        height: "10",
+        progress: progress
+      }), statusMessage && /*#__PURE__*/jsxRuntime.jsx(uiKit.Text.Detail, {
+        tone: "tertiary",
+        children: statusMessage
+      })]
+    })
+  });
+};
+
+const useFetch = function (fetchFunction) {
+  let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const _React$useState = React__default["default"].useState(null),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    data = _React$useState2[0],
+    setData = _React$useState2[1];
+  const _React$useState3 = React__default["default"].useState(null),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    error = _React$useState4[0],
+    setError = _React$useState4[1];
+  const _React$useState5 = React__default["default"].useState(false),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    isLoading = _React$useState6[0],
+    setIsLoading = _React$useState6[1];
+  const _React$useState7 = React__default["default"].useState(0),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    refetchCount = _React$useState8[0],
+    setRefetchCount = _React$useState8[1];
+  const _React$useState9 = React__default["default"].useState(new Date()),
+    _React$useState0 = _slicedToArray(_React$useState9, 2),
+    lastFetchTime = _React$useState0[0],
+    setLastFetchTime = _React$useState0[1];
+  const refetch = React__default["default"].useCallback(() => {
+    setRefetchCount(count => count + 1);
+  }, []);
+  React__default["default"].useEffect(() => {
+    let pollingId = null;
+    const fetchData = async () => {
+      setIsLoading(true);
+      try {
+        const response = await fetchFunction();
+        setData(response);
+        setLastFetchTime(new Date());
+        if (config.shouldContinuePolling && !config.shouldContinuePolling(response)) {
+          if (pollingId) {
+            clearInterval(pollingId);
+            pollingId = null;
+          }
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        setError(error);
+        if (!(err instanceof HttpError)) {
+          sentry.reportErrorToSentry(new Error('An unexpected error occurred in the `useFetch` hook'), {
+            extra: {
+              error: err
+            }
+          });
+        }
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    fetchData();
+    if (config.pollingInterval && config.pollingInterval > 0) {
+      pollingId = _setInterval__default["default"](fetchData, config.pollingInterval);
+    }
+    return () => {
+      if (pollingId) {
+        clearInterval(pollingId);
+      }
+      setError(null);
+      setIsLoading(false);
+    };
+  }, [fetchFunction, refetchCount, config.pollingInterval, config.shouldContinuePolling]);
+  return {
+    data,
+    error,
+    isLoading,
+    refetch,
+    lastFetchTime
+  };
+};
+
+const useFetchExportOperations = _ref => {
+  let projectKey = _ref.projectKey,
+    queryParams = _ref.queryParams,
+    pollingInterval = _ref.pollingInterval,
+    shouldContinuePolling = _ref.shouldContinuePolling;
+  const fetchData = React__default["default"].useCallback(() => {
+    if (!projectKey) {
+      return _Promise__default["default"].reject(new ProjectKeyNotAvailableError());
+    }
+    return fetchExportOperations({
+      projectKey,
+      queryParams
+    });
+  }, [projectKey, queryParams]);
+  return useFetch(fetchData, {
+    pollingInterval,
+    shouldContinuePolling
+  });
+};
+
+const useFetchFileImportJob = _ref => {
+  let projectKey = _ref.projectKey,
+    importContainerKey = _ref.importContainerKey,
+    jobId = _ref.jobId,
+    pollingInterval = _ref.pollingInterval,
+    shouldContinuePolling = _ref.shouldContinuePolling;
+  const fetchData = React__default["default"].useCallback(() => {
+    if (!projectKey) {
+      return _Promise__default["default"].reject(new ProjectKeyNotAvailableError());
+    }
+    return getFileImportJob({
+      projectKey,
+      importContainerKey,
+      jobId
+    });
+  }, [projectKey, importContainerKey, jobId]);
+  return useFetch(fetchData, {
+    pollingInterval,
+    shouldContinuePolling
+  });
+};
+
+const useFetchImportContainerDetails = _ref => {
+  let projectKey = _ref.projectKey,
+    importContainerKey = _ref.importContainerKey,
+    pollingInterval = _ref.pollingInterval,
+    shouldContinuePolling = _ref.shouldContinuePolling;
+  const fetchData = React__default["default"].useCallback(() => {
+    if (!projectKey) {
+      return _Promise__default["default"].reject(new ProjectKeyNotAvailableError());
+    }
+    return fetchImportContainerDetails({
+      projectKey,
+      importContainerKey
+    });
+  }, [projectKey, importContainerKey]);
+  return useFetch(fetchData, {
+    pollingInterval,
+    shouldContinuePolling
+  });
+};
+
+const useFetchImportOperations = _ref => {
+  let projectKey = _ref.projectKey,
+    importContainerKey = _ref.importContainerKey,
+    queryParams = _ref.queryParams,
+    pollingInterval = _ref.pollingInterval,
+    shouldContinuePolling = _ref.shouldContinuePolling;
+  const fetchData = React__default["default"].useCallback(() => {
+    if (!projectKey) {
+      return _Promise__default["default"].reject(new ProjectKeyNotAvailableError());
+    }
+    return fetchImportOperations({
+      projectKey,
+      importContainerKey,
+      queryParams
+    });
+  }, [projectKey, importContainerKey, queryParams]);
+  return useFetch(fetchData, {
+    pollingInterval,
+    shouldContinuePolling
+  });
+};
+
+const useFetchImportSummaries = _ref => {
+  let projectKey = _ref.projectKey,
+    queryParams = _ref.queryParams,
+    pollingInterval = _ref.pollingInterval,
+    shouldContinuePolling = _ref.shouldContinuePolling;
+  const fetchData = React__default["default"].useCallback(async () => {
+    if (!projectKey) {
+      return _Promise__default["default"].reject(new ProjectKeyNotAvailableError());
+    }
+    const summary = await fetchImportSummaries({
+      projectKey,
+      queryParams
+    });
+    const resolvedResults = await _Promise__default["default"].all(summary.results);
+    return {
+      results: resolvedResults,
+      count: summary.count,
+      total: summary.total
+    };
+  }, [projectKey, queryParams]);
+  return useFetch(fetchData, {
+    pollingInterval,
+    shouldContinuePolling
+  });
+};
+
+function ownKeys$2(e, r) { var t = _Object$keys__default["default"](e); if (_Object$getOwnPropertySymbols__default["default"]) { var o = _Object$getOwnPropertySymbols__default["default"](e); r && (o = _filterInstanceProperty__default["default"](o).call(o, function (r) { return _Object$getOwnPropertyDescriptor__default["default"](e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var _context, _context2; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty__default["default"](_context = ownKeys$2(Object(t), !0)).call(_context, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](e, _Object$getOwnPropertyDescriptors__default["default"](t)) : _forEachInstanceProperty__default["default"](_context2 = ownKeys$2(Object(t))).call(_context2, function (r) { _Object$defineProperty__default["default"](e, r, _Object$getOwnPropertyDescriptor__default["default"](t, r)); }); } return e; }
+const useFileImportJobUpload = _ref => {
+  let projectKey = _ref.projectKey;
+  const _React$useState = React__default["default"].useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isUploading = _React$useState2[0],
+    setIsUploading = _React$useState2[1];
+  const _React$useState3 = React__default["default"].useState(0),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    progress = _React$useState4[0],
+    setProgress = _React$useState4[1];
+  const upload = React__default["default"].useCallback(async config => {
+    if (!projectKey) {
+      throw new ProjectKeyNotAvailableError();
+    }
+    setIsUploading(true);
+    setProgress(0);
+    const importContainerKey = encodeFileNameWithTimestampToContainerKey(config.file.name);
+    try {
+      await createImportContainerForFileUpload({
+        importContainerDraft: _objectSpread$2({
+          key: importContainerKey,
+          resourceType: config.resourceType,
+          tags: [TAG_KEY_SOURCE_FILE_UPLOAD]
+        }, config.settings ? {
+          settings: config.settings
+        } : {}),
+        projectKey
+      });
+      const jobResponse = await createFileImportJob({
+        projectKey,
+        resourceType: config.resourceType,
+        importContainerKey,
+        payload: {
+          fileType: getFileImportJobFileType(config.resourceType),
+          fileName: config.file.name,
+          file: config.file
+        },
+        onProgress: uploadProgress => {
+          setProgress(uploadProgress);
+          config.onProgress?.(uploadProgress);
+        },
+        abortSignal: config.abortSignal
+      });
+      setIsUploading(false);
+      setProgress(100);
+      config.onSuccess(jobResponse.id, importContainerKey);
+    } catch (error) {
+      try {
+        await deleteImportContainer({
+          projectKey,
+          importContainerKey
+        });
+      } catch {
+        // Ignore cleanup errors - container will be cleaned up by TTL retention policy
+        // Cleanup errors are unlikely unless there is a network issue or container was removed externally
+      }
+      setIsUploading(false);
+      setProgress(0);
+      config.onError?.(error);
+    }
+  }, [projectKey]);
+  return {
+    upload,
+    isUploading,
+    progress
+  };
+};
+
+function ownKeys$1(e, r) { var t = _Object$keys__default["default"](e); if (_Object$getOwnPropertySymbols__default["default"]) { var o = _Object$getOwnPropertySymbols__default["default"](e); r && (o = _filterInstanceProperty__default["default"](o).call(o, function (r) { return _Object$getOwnPropertyDescriptor__default["default"](e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$1(e) { for (var r = 1; r < arguments.length; r++) { var _context, _context2; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty__default["default"](_context = ownKeys$1(Object(t), !0)).call(_context, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](e, _Object$getOwnPropertyDescriptors__default["default"](t)) : _forEachInstanceProperty__default["default"](_context2 = ownKeys$1(Object(t))).call(_context2, function (r) { _Object$defineProperty__default["default"](e, r, _Object$getOwnPropertyDescriptor__default["default"](t, r)); }); } return e; }
+const useImportContainerUpload = _ref => {
+  let projectKey = _ref.projectKey;
+  const _React$useState = React__default["default"].useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isUploading = _React$useState2[0],
+    setIsUploading = _React$useState2[1];
+  const _React$useState3 = React__default["default"].useState(0),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    progress = _React$useState4[0],
+    setProgress = _React$useState4[1];
+  const xhrRef = React__default["default"].useRef(null);
+  const upload = async _ref2 => {
+    let file = _ref2.file,
+      resourceType = _ref2.resourceType,
+      settings = _ref2.settings,
+      onSuccess = _ref2.onSuccess,
+      onError = _ref2.onError,
+      onProgress = _ref2.onProgress,
+      abortSignal = _ref2.abortSignal;
+    if (!projectKey) {
+      throw new ProjectKeyNotAvailableError();
+    }
+    setIsUploading(true);
+    setProgress(0);
+    const importContainerKey = encodeFileNameWithTimestampToContainerKey(file.name);
+    try {
+      await createImportContainerForFileUpload({
+        importContainerDraft: _objectSpread$1({
+          key: importContainerKey,
+          resourceType,
+          tags: [TAG_KEY_SOURCE_FILE_UPLOAD]
+        }, settings ? {
+          settings
+        } : {}),
+        projectKey
+      });
+      const xhr = uploadFileForImport({
+        projectKey,
+        importContainerKey,
+        resourceType,
+        file,
+        abortSignal,
+        onSuccess: response => {
+          setIsUploading(false);
+          setProgress(100);
+          onSuccess(response, importContainerKey);
+        },
+        onProgress: prog => {
+          setProgress(prog);
+          onProgress?.(prog);
+        },
+        onError: async error => {
+          try {
+            await deleteImportContainer({
+              projectKey,
+              importContainerKey
+            });
+          } catch {
+            // Ignore cleanup errors - container will be cleaned up by TTL retention policy
+            // Cleanup errors are unlikely unless there is a network issue or container was removed externally
+          }
+          setIsUploading(false);
+          setProgress(0);
+          onError?.(error);
+        }
+      });
+      xhrRef.current = xhr;
+      return xhr;
+    } catch (error) {
+      try {
+        await deleteImportContainer({
+          projectKey,
+          importContainerKey
+        });
+      } catch {
+        // Ignore cleanup errors - container will be cleaned up by TTL retention policy
+        // Cleanup errors are unlikely unless there is a network issue or container was removed externally
+      }
+      setIsUploading(false);
+      setProgress(0);
+      onError?.(error);
+      return undefined;
+    }
+  };
+  const abort = () => {
+    xhrRef.current?.abort();
+    setIsUploading(false);
+    setProgress(0);
+  };
+  return {
+    upload,
+    abort,
+    isUploading,
+    progress
+  };
+};
+
+function ownKeys(e, r) { var t = _Object$keys__default["default"](e); if (_Object$getOwnPropertySymbols__default["default"]) { var o = _Object$getOwnPropertySymbols__default["default"](e); r && (o = _filterInstanceProperty__default["default"](o).call(o, function (r) { return _Object$getOwnPropertyDescriptor__default["default"](e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var _context, _context2; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty__default["default"](_context = ownKeys(Object(t), !0)).call(_context, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors__default["default"] ? _Object$defineProperties__default["default"](e, _Object$getOwnPropertyDescriptors__default["default"](t)) : _forEachInstanceProperty__default["default"](_context2 = ownKeys(Object(t))).call(_context2, function (r) { _Object$defineProperty__default["default"](e, r, _Object$getOwnPropertyDescriptor__default["default"](t, r)); }); } return e; }
+const safeDeleteContainer = async _ref => {
+  let projectKey = _ref.projectKey,
+    containerKey = _ref.containerKey;
+  try {
+    await deleteImportContainer({
+      projectKey,
+      importContainerKey: containerKey
+    });
+  } catch {}
+};
+const useFileUpload = _ref2 => {
+  let projectKey = _ref2.projectKey,
+    _ref2$useJobBasedFlow = _ref2.useJobBasedFlow,
+    useJobBasedFlow = _ref2$useJobBasedFlow === void 0 ? false : _ref2$useJobBasedFlow,
+    _ref2$pollingInterval = _ref2.pollingInterval,
+    pollingInterval = _ref2$pollingInterval === void 0 ? 5000 : _ref2$pollingInterval,
+    _ref2$maxPollingAttem = _ref2.maxPollingAttempts,
+    maxPollingAttempts = _ref2$maxPollingAttem === void 0 ? 120 : _ref2$maxPollingAttem;
+  const _React$useState = React__default["default"].useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isUploading = _React$useState2[0],
+    setIsUploading = _React$useState2[1];
+  const _React$useState3 = React__default["default"].useState(0),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    progress = _React$useState4[0],
+    setProgress = _React$useState4[1];
+  const _React$useState5 = React__default["default"].useState({
+      processed: 0,
+      isValidating: false
+    }),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    validationProgress = _React$useState6[0],
+    setValidationProgress = _React$useState6[1];
+  const containerUpload = useImportContainerUpload({
+    projectKey
+  });
+  const jobUpload = useFileImportJobUpload({
+    projectKey
+  });
+  const resetState = React__default["default"].useCallback(() => {
+    setIsUploading(false);
+    setProgress(0);
+    setValidationProgress({
+      processed: 0,
+      isValidating: false
+    });
+  }, []);
+  const upload = React__default["default"].useCallback(async config => {
+    setIsUploading(true);
+    setProgress(0);
+    try {
+      if (useJobBasedFlow) {
+        await jobUpload.upload({
+          file: config.file,
+          resourceType: config.resourceType,
+          settings: config.settings,
+          abortSignal: config.abortSignal,
+          onSuccess: async (jobId, containerKey) => {
+            try {
+              setValidationProgress({
+                processed: 0,
+                isValidating: true
+              });
+              const validatedJob = await pollJobUntilValidated({
+                projectKey,
+                jobId,
+                importContainerKey: containerKey,
+                pollingInterval,
+                maxAttempts: maxPollingAttempts,
+                abortSignal: config.abortSignal,
+                onJobUpdate: job => {
+                  const processed = job.summary?.total ?? 0;
+                  setValidationProgress({
+                    processed,
+                    isValidating: true
+                  });
+                  config.onValidationProgress?.(job);
+                }
+              });
+
+              // Handle rejected job with jobError for the new flow (like MissingCsvFieldIdentifier error)
+              // We wrap it in HttpError to reuse existing error handling (for the old flow) in consumers until BE supports this error type
+              if (validatedJob.jobError) {
+                throw new HttpError(400, validatedJob.jobError.message, validatedJob.jobError);
+              }
+              let results = [];
+              if (validatedJob.summary.invalid > 0) {
+                const recordsResponse = await getFileImportJobRecords({
+                  projectKey,
+                  importContainerKey: containerKey,
+                  jobId,
+                  limit: 500,
+                  isValid: false
+                });
+                results = recordsResponse.results;
+                await safeDeleteContainer({
+                  projectKey,
+                  containerKey
+                });
+              }
+              const result = {
+                containerKey,
+                summary: _objectSpread(_objectSpread({}, validatedJob.summary), {}, {
+                  results
+                }),
+                jobId,
+                job: validatedJob
+              };
+              setIsUploading(false);
+              setValidationProgress({
+                processed: 0,
+                isValidating: false
+              });
+              config.onSuccess(result);
+            } catch (error) {
+              await safeDeleteContainer({
+                projectKey,
+                containerKey
+              });
+              resetState();
+              if (!(error instanceof PollingAbortedError)) {
+                config.onError?.(error);
+              }
+            }
+          },
+          onProgress: prog => {
+            setProgress(prog);
+            config.onProgress?.(prog);
+          },
+          onError: error => {
+            resetState();
+            config.onError?.(error);
+          }
+        });
+      } else {
+        await containerUpload.upload({
+          file: config.file,
+          resourceType: config.resourceType,
+          settings: config.settings,
+          abortSignal: config.abortSignal,
+          onSuccess: async (fileUploadResponse, containerKey) => {
+            if (config.abortSignal?.aborted) {
+              await safeDeleteContainer({
+                projectKey,
+                containerKey
+              });
+              resetState();
+              return;
+            }
+            if (fileUploadResponse.invalid > 0) {
+              await safeDeleteContainer({
+                projectKey,
+                containerKey
+              });
+            }
+            const result = {
+              containerKey,
+              summary: {
+                total: fileUploadResponse.itemsCount,
+                valid: fileUploadResponse.valid,
+                invalid: fileUploadResponse.invalid,
+                fieldsCount: fileUploadResponse.columnsCount,
+                fields: fileUploadResponse.fields || [],
+                ignoredFields: fileUploadResponse.ignoredFields || [],
+                results: fileUploadResponse.results || []
+              }
+            };
+            setIsUploading(false);
+            config.onSuccess(result);
+          },
+          onProgress: prog => {
+            setProgress(prog);
+            config.onProgress?.(prog);
+          },
+          onError: error => {
+            resetState();
+            config.onError?.(error);
+          }
+        });
+      }
+    } catch (error) {
+      resetState();
+      config.onError?.(error);
+    }
+  }, [projectKey, useJobBasedFlow, pollingInterval, maxPollingAttempts, containerUpload, jobUpload]);
+  return {
+    upload,
+    isUploading,
+    progress,
+    validationProgress
+  };
+};
+
+exports.ActiveDragDropArea = ActiveDragDropArea;
+exports.COLUMN_DELIMITERS = COLUMN_DELIMITERS;
+exports.CT_API_DOCS_URL = CT_API_DOCS_URL;
+exports.DELIMITERS = DELIMITERS;
+exports.DisabledDropArea = DisabledDropArea;
+exports.DropAreaWrapper = DropAreaWrapper;
+exports.EnabledDropArea = EnabledDropArea;
+exports.FILE_IMPORT_JOB_POLLING_INTERVAL = FILE_IMPORT_JOB_POLLING_INTERVAL;
+exports.FileDropArea = FileDropArea;
+exports.FileDroppedArea = FileDroppedArea;
+exports.FileIcon = FileIcon;
+exports.HttpError = HttpError;
+exports.IMPORT_LEGACY_MAX_FILE_SIZE_MB = IMPORT_LEGACY_MAX_FILE_SIZE_MB;
+exports.IMPORT_LEGACY_MAX_ROW_COUNT = IMPORT_LEGACY_MAX_ROW_COUNT;
+exports.IMPORT_MAX_FILE_SIZE_MB = IMPORT_MAX_FILE_SIZE_MB;
+exports.IMPORT_MAX_ITEM_COUNT = IMPORT_MAX_ITEM_COUNT;
+exports.IMPORT_TAG_KEYS = IMPORT_TAG_KEYS;
+exports.IMPORT_TAG_VALUES = IMPORT_TAG_VALUES;
+exports.ImportStates = ImportStates;
+exports.InfoBox = InfoBox;
+exports.InvalidResponseError = InvalidResponseError;
+exports.LockIcon = LockIcon;
+exports.NoResourcesToExportError = NoResourcesToExportError;
+exports.PollingAbortedError = PollingAbortedError;
+exports.ProjectKeyNotAvailableError = ProjectKeyNotAvailableError;
+exports.QueryPredicateError = QueryPredicateError;
+exports.RESOURCE_TYPE_DOCUMENTATION_LINKS = RESOURCE_TYPE_DOCUMENTATION_LINKS;
+exports.RESOURCE_TYPE_TEMPLATE_DOWNLOAD_LINKS = RESOURCE_TYPE_TEMPLATE_DOWNLOAD_LINKS;
+exports.TAG_KEY_SOURCE_FILE_UPLOAD = TAG_KEY_SOURCE_FILE_UPLOAD;
+exports.UnexpectedColumnError = UnexpectedColumnError;
+exports.UnexpectedOperationStateError = UnexpectedOperationStateError;
+exports.UnexpectedResourceTypeError = UnexpectedResourceTypeError;
+exports.UploadSeparator = UploadSeparator;
+exports.UploadSettings = UploadSettings;
+exports.UploadingModal = UploadingModal;
+exports.allAutomatedImportOperations = allAutomatedImportOperations;
+exports.allAutomatedImportOperationsResponse = allAutomatedImportOperationsResponse;
+exports.allFileUploadImportOperations = allFileUploadImportOperations;
+exports.allFileUploadImportOperationsResponse = allFileUploadImportOperationsResponse;
+exports.appendCsvOrJsonExtensionIfAbsent = appendCsvOrJsonExtensionIfAbsent;
+exports.assertCancelContainerResponse = assertCancelContainerResponse;
+exports.assertExportOperationsDownloadFileResponse = assertExportOperationsDownloadFileResponse;
+exports.assertFileImportJob = assertFileImportJob;
+exports.assertFileImportJobRecordsResponse = assertFileImportJobRecordsResponse;
+exports.assertFileUploadResponse = assertFileUploadResponse;
+exports.assertImportContainer = assertImportContainer;
+exports.assertImportContainerPagedResponse = assertImportContainerPagedResponse;
+exports.assertImportOperationPagedResponse = assertImportOperationPagedResponse;
+exports.assertImportSummary = assertImportSummary;
+exports.assertListFileImportJobsResponse = assertListFileImportJobsResponse;
+exports.assertPaginatedExportOperationResponse = assertPaginatedExportOperationResponse;
+exports.assertProcessFileImportJobResponse = assertProcessFileImportJobResponse;
+exports.assertProcessFileResponse = assertProcessFileResponse;
+exports.assertResourceType = assertResourceType;
+exports.automatedImportContainerKey = automatedImportContainerKey;
+exports.automatedImports = automatedImports;
+exports.cancelImportContainerByKey = cancelImportContainerByKey;
+exports.checkIfFileUploadImport = checkIfFileUploadImport;
+exports.convertFileSizeToKB = convertFileSizeToKB;
+exports.countJsonFileItems = countJsonFileItems;
+exports.countUniqueResourcesInCsv = countUniqueResourcesInCsv;
+exports.createFileImportJob = createFileImportJob;
+exports.createImportContainerForFileUpload = createImportContainerForFileUpload;
+exports.decodeFileNameFromImportContainerKey = decodeFileNameFromImportContainerKey;
+exports.deleteFileImportJob = deleteFileImportJob;
+exports.deleteImportContainer = deleteImportContainer;
+exports.dropAreaStyles = dropAreaStyles;
+exports.encodeFileNameWithTimestampToContainerKey = encodeFileNameWithTimestampToContainerKey;
+exports.exportOperationsCompleted = exportOperationsCompleted;
+exports.exportOperationsProcessing = exportOperationsProcessing;
+exports.extractErrorDescriptionFromValidationMessage = extractErrorDescriptionFromValidationMessage;
+exports.fetchExportOperations = fetchExportOperations;
+exports.fetchImportContainerByKey = fetchImportContainerByKey;
+exports.fetchImportContainerDetails = fetchImportContainerDetails;
+exports.fetchImportContainers = fetchImportContainers;
+exports.fetchImportOperations = fetchImportOperations;
+exports.fetchImportSummaries = fetchImportSummaries;
+exports.fetchImportSummary = fetchImportSummary;
+exports.fetchUsingXhr = fetchUsingXhr;
+exports.fetcher = fetcher;
+exports.fileUploadImportContainerKey = fileUploadImportContainerKey;
+exports.fileUploadMissingKeysResponse = fileUploadMissingKeysResponse;
+exports.formatErrorCode = formatErrorCode;
+exports.formatKeys = formatKeys;
+exports.formatQueryString = formatQueryString;
+exports.getCreateImportContainerURL = getCreateImportContainerURL;
+exports.getDeleteImportContainerURL = getDeleteImportContainerURL;
+exports.getExportOperationsURL = getExportOperationsURL;
+exports.getFileImportJob = getFileImportJob;
+exports.getFileImportJobByIdURL = getFileImportJobByIdURL;
+exports.getFileImportJobDeleteURL = getFileImportJobDeleteURL;
+exports.getFileImportJobFileType = getFileImportJobFileType;
+exports.getFileImportJobProcessURL = getFileImportJobProcessURL;
+exports.getFileImportJobRecords = getFileImportJobRecords;
+exports.getFileImportJobRecordsURL = getFileImportJobRecordsURL;
+exports.getFileImportJobsListURL = getFileImportJobsListURL;
+exports.getFileImportJobsURL = getFileImportJobsURL;
+exports.getFileUploadErrorsCount = getFileUploadErrorsCount;
+exports.getFileUploadURL = getFileUploadURL;
+exports.getImportContainerByKeyURL = getImportContainerByKeyURL;
+exports.getImportContainerTasksURL = getImportContainerTasksURL;
+exports.getImportContainersURL = getImportContainersURL;
+exports.getImportOperationsURL = getImportOperationsURL;
+exports.getImportState = getImportState;
+exports.getImportSummaryURL = getImportSummaryURL;
+exports.getMissingRequiredFields = getMissingRequiredFields;
+exports.getProccessFileURL = getProccessFileURL;
+exports.getRowCount = getRowCount;
+exports.getValidatedColumns = getValidatedColumns;
+exports.hasOwnProperty = hasOwnProperty;
+exports.hasRequiredFields = hasRequiredFields;
+exports.hasSingleKeyColumn = hasSingleKeyColumn;
+exports.importContainers = importContainers;
+exports.importStatesMap = importStatesMap;
+exports.importsSummaries = importsSummaries;
+exports.invalidFileImportJobRecordsResponse = invalidFileImportJobRecordsResponse;
+exports.invalidFileImportJobValidated = invalidFileImportJobValidated;
+exports.invalidFileUploadResponse = invalidFileUploadResponse;
+exports.isAbortError = isAbortError;
+exports.isError = isError;
+exports.isImportJobInitializing = isImportJobInitializing;
+exports.isImportJobProcessing = isImportJobProcessing;
+exports.isImportJobQueued = isImportJobQueued;
+exports.isImportJobReady = isImportJobReady;
+exports.isImportJobRejected = isImportJobRejected;
+exports.isImportJobTerminal = isImportJobTerminal;
+exports.isImportJobValidated = isImportJobValidated;
+exports.isResourceType = isResourceType;
+exports.listFileImportJobs = listFileImportJobs;
+exports.manualImports = manualImports;
+exports.mapFileUploadErrorsToUploadFileErrorRows = mapFileUploadErrorsToUploadFileErrorRows;
+exports.mapFormikErrors = mapFormikErrors;
+exports.mapUploadFileErrorsResponseToUploadFileErrorRows = mapUploadFileErrorsResponseToUploadFileErrorRows;
+exports.pollJobUntilValidated = pollJobUntilValidated;
+exports.processFileImportJob = processFileImportJob;
+exports.processFileImportJobResponse = processFileImportJobResponse;
+exports.processUploadedFile = processUploadedFile;
+exports.shouldContinuePollingForImportValidation = shouldContinuePollingForImportValidation;
+exports.successfulAutomatedImportOperations = successfulAutomatedImportOperations;
+exports.successfulAutomatedImportOperationsResponse = successfulAutomatedImportOperationsResponse;
+exports.successfulFileUploadImportOperations = successfulFileUploadImportOperations;
+exports.successfulFileUploadImportOperationsResponse = successfulFileUploadImportOperationsResponse;
+exports.toBytes = toBytes;
+exports.toImportApiResourceType = toImportApiResourceType;
+exports.uploadFileForImport = uploadFileForImport;
+exports.useFetchExportOperations = useFetchExportOperations;
+exports.useFetchFileImportJob = useFetchFileImportJob;
+exports.useFetchImportContainerDetails = useFetchImportContainerDetails;
+exports.useFetchImportOperations = useFetchImportOperations;
+exports.useFetchImportSummaries = useFetchImportSummaries;
+exports.useFileImportJobUpload = useFileImportJobUpload;
+exports.useFileUpload = useFileUpload;
+exports.useImportContainerUpload = useImportContainerUpload;
+exports.validFileImportJobProcessing = validFileImportJobProcessing;
+exports.validFileImportJobQueued = validFileImportJobQueued;
+exports.validFileImportJobRecordsResponse = validFileImportJobRecordsResponse;
+exports.validFileImportJobValidated = validFileImportJobValidated;
+exports.validFileUploadResponse = validFileUploadResponse;
+exports.validProcessFileResponse = validProcessFileResponse;
+exports.validateDelimiter = validateDelimiter;