contentful-management 9.1.0 → 9.2.0

package/dist/contentful-management.browser.js

@@ -3255,365 +3255,358 @@ function errorHandler(errorResponse) {
 /***/ (function(module, exports, __webpack_require__) {
 
 /* WEBPACK VAR INJECTION */(function(global) {(function (global, factory) {
-   true ? module.exports = factory() :
-  undefined;
-}(this, (function () { 'use strict';
-
-  var toStringFunction = Function.prototype.toString;
-  var create = Object.create, defineProperty = Object.defineProperty, getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols, getPrototypeOf = Object.getPrototypeOf;
-  var _a = Object.prototype, hasOwnProperty = _a.hasOwnProperty, propertyIsEnumerable = _a.propertyIsEnumerable;
-  /**
-   * @enum
-   *
-   * @const {Object} SUPPORTS
-   *
-   * @property {boolean} SYMBOL_PROPERTIES are symbol properties supported
-   * @property {boolean} WEAKMAP is WeakMap supported
-   */
-  var SUPPORTS = {
-      SYMBOL_PROPERTIES: typeof getOwnPropertySymbols === 'function',
-      WEAKMAP: typeof WeakMap === 'function',
-  };
-  /**
-   * @function createCache
-   *
-   * @description
-   * get a new cache object to prevent circular references
-   *
-   * @returns the new cache object
-   */
-  var createCache = function () {
-      if (SUPPORTS.WEAKMAP) {
-          return new WeakMap();
-      }
-      // tiny implementation of WeakMap
-      var object = create({
-          has: function (key) { return !!~object._keys.indexOf(key); },
-          set: function (key, value) {
-              object._keys.push(key);
-              object._values.push(value);
-          },
-          get: function (key) { return object._values[object._keys.indexOf(key)]; },
-      });
-      object._keys = [];
-      object._values = [];
-      return object;
-  };
-  /**
-   * @function getCleanClone
-   *
-   * @description
-   * get an empty version of the object with the same prototype it has
-   *
-   * @param object the object to build a clean clone from
-   * @param realm the realm the object resides in
-   * @returns the empty cloned object
-   */
-  var getCleanClone = function (object, realm) {
-      if (!object.constructor) {
-          return create(null);
-      }
-      var Constructor = object.constructor;
-      var prototype = object.__proto__ || getPrototypeOf(object);
-      if (Constructor === realm.Object) {
-          return prototype === realm.Object.prototype ? {} : create(prototype);
-      }
-      if (~toStringFunction.call(Constructor).indexOf('[native code]')) {
-          try {
-              return new Constructor();
-          }
-          catch (_a) { }
-      }
-      return create(prototype);
-  };
-  /**
-   * @function getObjectCloneLoose
-   *
-   * @description
-   * get a copy of the object based on loose rules, meaning all enumerable keys
-   * and symbols are copied, but property descriptors are not considered
-   *
-   * @param object the object to clone
-   * @param realm the realm the object resides in
-   * @param handleCopy the function that handles copying the object
-   * @returns the copied object
-   */
-  var getObjectCloneLoose = function (object, realm, handleCopy, cache) {
-      var clone = getCleanClone(object, realm);
-      // set in the cache immediately to be able to reuse the object recursively
-      cache.set(object, clone);
-      for (var key in object) {
-          if (hasOwnProperty.call(object, key)) {
-              clone[key] = handleCopy(object[key], cache);
-          }
-      }
-      if (SUPPORTS.SYMBOL_PROPERTIES) {
-          var symbols = getOwnPropertySymbols(object);
-          var length_1 = symbols.length;
-          if (length_1) {
-              for (var index = 0, symbol = void 0; index < length_1; index++) {
-                  symbol = symbols[index];
-                  if (propertyIsEnumerable.call(object, symbol)) {
-                      clone[symbol] = handleCopy(object[symbol], cache);
-                  }
-              }
-          }
-      }
-      return clone;
-  };
-  /**
-   * @function getObjectCloneStrict
-   *
-   * @description
-   * get a copy of the object based on strict rules, meaning all keys and symbols
-   * are copied based on the original property descriptors
-   *
-   * @param object the object to clone
-   * @param realm the realm the object resides in
-   * @param handleCopy the function that handles copying the object
-   * @returns the copied object
-   */
-  var getObjectCloneStrict = function (object, realm, handleCopy, cache) {
-      var clone = getCleanClone(object, realm);
-      // set in the cache immediately to be able to reuse the object recursively
-      cache.set(object, clone);
-      var properties = SUPPORTS.SYMBOL_PROPERTIES
-          ? getOwnPropertyNames(object).concat(getOwnPropertySymbols(object))
-          : getOwnPropertyNames(object);
-      var length = properties.length;
-      if (length) {
-          for (var index = 0, property = void 0, descriptor = void 0; index < length; index++) {
-              property = properties[index];
-              if (property !== 'callee' && property !== 'caller') {
-                  descriptor = getOwnPropertyDescriptor(object, property);
-                  if (descriptor) {
-                      // Only clone the value if actually a value, not a getter / setter.
-                      if (!descriptor.get && !descriptor.set) {
-                          descriptor.value = handleCopy(object[property], cache);
-                      }
-                      try {
-                          defineProperty(clone, property, descriptor);
-                      }
-                      catch (error) {
-                          // Tee above can fail on node in edge cases, so fall back to the loose assignment.
-                          clone[property] = descriptor.value;
-                      }
-                  }
-                  else {
-                      // In extra edge cases where the property descriptor cannot be retrived, fall back to
-                      // the loose assignment.
-                      clone[property] = handleCopy(object[property], cache);
-                  }
-              }
-          }
-      }
-      return clone;
-  };
-  /**
-   * @function getRegExpFlags
-   *
-   * @description
-   * get the flags to apply to the copied regexp
-   *
-   * @param regExp the regexp to get the flags of
-   * @returns the flags for the regexp
-   */
-  var getRegExpFlags = function (regExp) {
-      var flags = '';
-      if (regExp.global) {
-          flags += 'g';
-      }
-      if (regExp.ignoreCase) {
-          flags += 'i';
-      }
-      if (regExp.multiline) {
-          flags += 'm';
-      }
-      if (regExp.unicode) {
-          flags += 'u';
-      }
-      if (regExp.sticky) {
-          flags += 'y';
-      }
-      return flags;
-  };
+     true ? module.exports = factory() :
+    undefined;
+})(this, (function () { 'use strict';
+
+    var toStringFunction = Function.prototype.toString;
+    var create = Object.create, defineProperty = Object.defineProperty, getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols, getPrototypeOf$1 = Object.getPrototypeOf;
+    var _a = Object.prototype, hasOwnProperty = _a.hasOwnProperty, propertyIsEnumerable = _a.propertyIsEnumerable;
+    var SYMBOL_PROPERTIES = typeof getOwnPropertySymbols === 'function';
+    var WEAK_MAP = typeof WeakMap === 'function';
+    /**
+     * @function createCache
+     *
+     * @description
+     * get a new cache object to prevent circular references
+     *
+     * @returns the new cache object
+     */
+    var createCache = (function () {
+        if (WEAK_MAP) {
+            return function () { return new WeakMap(); };
+        }
+        var Cache = /** @class */ (function () {
+            function Cache() {
+                this._keys = [];
+                this._values = [];
+            }
+            Cache.prototype.has = function (key) {
+                return !!~this._keys.indexOf(key);
+            };
+            Cache.prototype.get = function (key) {
+                return this._values[this._keys.indexOf(key)];
+            };
+            Cache.prototype.set = function (key, value) {
+                this._keys.push(key);
+                this._values.push(value);
+            };
+            return Cache;
+        }());
+        return function () { return new Cache(); };
+    })();
+    /**
+     * @function getCleanClone
+     *
+     * @description
+     * get an empty version of the object with the same prototype it has
+     *
+     * @param object the object to build a clean clone from
+     * @param realm the realm the object resides in
+     * @returns the empty cloned object
+     */
+    var getCleanClone = function (object, realm) {
+        var prototype = object.__proto__ || getPrototypeOf$1(object);
+        if (!prototype) {
+            return create(null);
+        }
+        var Constructor = prototype.constructor;
+        if (Constructor === realm.Object) {
+            return prototype === realm.Object.prototype ? {} : create(prototype);
+        }
+        if (~toStringFunction.call(Constructor).indexOf('[native code]')) {
+            try {
+                return new Constructor();
+            }
+            catch (_a) { }
+        }
+        return create(prototype);
+    };
+    /**
+     * @function getObjectCloneLoose
+     *
+     * @description
+     * get a copy of the object based on loose rules, meaning all enumerable keys
+     * and symbols are copied, but property descriptors are not considered
+     *
+     * @param object the object to clone
+     * @param realm the realm the object resides in
+     * @param handleCopy the function that handles copying the object
+     * @returns the copied object
+     */
+    var getObjectCloneLoose = function (object, realm, handleCopy, cache) {
+        var clone = getCleanClone(object, realm);
+        // set in the cache immediately to be able to reuse the object recursively
+        cache.set(object, clone);
+        for (var key in object) {
+            if (hasOwnProperty.call(object, key)) {
+                clone[key] = handleCopy(object[key], cache);
+            }
+        }
+        if (SYMBOL_PROPERTIES) {
+            var symbols = getOwnPropertySymbols(object);
+            for (var index = 0, length_1 = symbols.length, symbol = void 0; index < length_1; ++index) {
+                symbol = symbols[index];
+                if (propertyIsEnumerable.call(object, symbol)) {
+                    clone[symbol] = handleCopy(object[symbol], cache);
+                }
+            }
+        }
+        return clone;
+    };
+    /**
+     * @function getObjectCloneStrict
+     *
+     * @description
+     * get a copy of the object based on strict rules, meaning all keys and symbols
+     * are copied based on the original property descriptors
+     *
+     * @param object the object to clone
+     * @param realm the realm the object resides in
+     * @param handleCopy the function that handles copying the object
+     * @returns the copied object
+     */
+    var getObjectCloneStrict = function (object, realm, handleCopy, cache) {
+        var clone = getCleanClone(object, realm);
+        // set in the cache immediately to be able to reuse the object recursively
+        cache.set(object, clone);
+        var properties = SYMBOL_PROPERTIES
+            ? getOwnPropertyNames(object).concat(getOwnPropertySymbols(object))
+            : getOwnPropertyNames(object);
+        for (var index = 0, length_2 = properties.length, property = void 0, descriptor = void 0; index < length_2; ++index) {
+            property = properties[index];
+            if (property !== 'callee' && property !== 'caller') {
+                descriptor = getOwnPropertyDescriptor(object, property);
+                if (descriptor) {
+                    // Only clone the value if actually a value, not a getter / setter.
+                    if (!descriptor.get && !descriptor.set) {
+                        descriptor.value = handleCopy(object[property], cache);
+                    }
+                    try {
+                        defineProperty(clone, property, descriptor);
+                    }
+                    catch (error) {
+                        // Tee above can fail on node in edge cases, so fall back to the loose assignment.
+                        clone[property] = descriptor.value;
+                    }
+                }
+                else {
+                    // In extra edge cases where the property descriptor cannot be retrived, fall back to
+                    // the loose assignment.
+                    clone[property] = handleCopy(object[property], cache);
+                }
+            }
+        }
+        return clone;
+    };
+    /**
+     * @function getRegExpFlags
+     *
+     * @description
+     * get the flags to apply to the copied regexp
+     *
+     * @param regExp the regexp to get the flags of
+     * @returns the flags for the regexp
+     */
+    var getRegExpFlags = function (regExp) {
+        var flags = '';
+        if (regExp.global) {
+            flags += 'g';
+        }
+        if (regExp.ignoreCase) {
+            flags += 'i';
+        }
+        if (regExp.multiline) {
+            flags += 'm';
+        }
+        if (regExp.unicode) {
+            flags += 'u';
+        }
+        if (regExp.sticky) {
+            flags += 'y';
+        }
+        return flags;
+    };
 
-  // utils
-  var isArray = Array.isArray;
-  var GLOBAL_THIS = (function () {
-      if (typeof self !== 'undefined') {
-          return self;
-      }
-      if (typeof window !== 'undefined') {
-          return window;
-      }
-      if (typeof global !== 'undefined') {
-          return global;
-      }
-      if (console && console.error) {
-          console.error('Unable to locate global object, returning "this".');
-      }
-  })();
-  /**
-   * @function copy
-   *
-   * @description
-   * copy an object deeply as much as possible
-   *
-   * If `strict` is applied, then all properties (including non-enumerable ones)
-   * are copied with their original property descriptors on both objects and arrays.
-   *
-   * The object is compared to the global constructors in the `realm` provided,
-   * and the native constructor is always used to ensure that extensions of native
-   * objects (allows in ES2015+) are maintained.
-   *
-   * @param object the object to copy
-   * @param [options] the options for copying with
-   * @param [options.isStrict] should the copy be strict
-   * @param [options.realm] the realm (this) object the object is copied from
-   * @returns the copied object
-   */
-  function copy(object, options) {
-      // manually coalesced instead of default parameters for performance
-      var isStrict = !!(options && options.isStrict);
-      var realm = (options && options.realm) || GLOBAL_THIS;
-      var getObjectClone = isStrict
-          ? getObjectCloneStrict
-          : getObjectCloneLoose;
-      /**
-       * @function handleCopy
-       *
-       * @description
-       * copy the object recursively based on its type
-       *
-       * @param object the object to copy
-       * @returns the copied object
-       */
-      var handleCopy = function (object, cache) {
-          if (!object || typeof object !== 'object') {
-              return object;
-          }
-          if (cache.has(object)) {
-              return cache.get(object);
-          }
-          var Constructor = object.constructor;
-          // plain objects
-          if (Constructor === realm.Object) {
-              return getObjectClone(object, realm, handleCopy, cache);
-          }
-          var clone;
-          // arrays
-          if (isArray(object)) {
-              // if strict, include non-standard properties
-              if (isStrict) {
-                  return getObjectCloneStrict(object, realm, handleCopy, cache);
-              }
-              var length_1 = object.length;
-              clone = new Constructor();
-              cache.set(object, clone);
-              for (var index = 0; index < length_1; index++) {
-                  clone[index] = handleCopy(object[index], cache);
-              }
-              return clone;
-          }
-          // dates
-          if (object instanceof realm.Date) {
-              return new Constructor(object.getTime());
-          }
-          // regexps
-          if (object instanceof realm.RegExp) {
-              clone = new Constructor(object.source, object.flags || getRegExpFlags(object));
-              clone.lastIndex = object.lastIndex;
-              return clone;
-          }
-          // maps
-          if (realm.Map && object instanceof realm.Map) {
-              clone = new Constructor();
-              cache.set(object, clone);
-              object.forEach(function (value, key) {
-                  clone.set(key, handleCopy(value, cache));
-              });
-              return clone;
-          }
-          // sets
-          if (realm.Set && object instanceof realm.Set) {
-              clone = new Constructor();
-              cache.set(object, clone);
-              object.forEach(function (value) {
-                  clone.add(handleCopy(value, cache));
-              });
-              return clone;
-          }
-          // blobs
-          if (realm.Blob && object instanceof realm.Blob) {
-              return object.slice(0, object.size, object.type);
-          }
-          // buffers (node-only)
-          if (realm.Buffer && realm.Buffer.isBuffer(object)) {
-              clone = realm.Buffer.allocUnsafe
-                  ? realm.Buffer.allocUnsafe(object.length)
-                  : new Constructor(object.length);
-              cache.set(object, clone);
-              object.copy(clone);
-              return clone;
-          }
-          // arraybuffers / dataviews
-          if (realm.ArrayBuffer) {
-              // dataviews
-              if (realm.ArrayBuffer.isView(object)) {
-                  clone = new Constructor(object.buffer.slice(0));
-                  cache.set(object, clone);
-                  return clone;
-              }
-              // arraybuffers
-              if (object instanceof realm.ArrayBuffer) {
-                  clone = object.slice(0);
-                  cache.set(object, clone);
-                  return clone;
-              }
-          }
-          // if the object cannot / should not be cloned, don't
-          if (
-          // promise-like
-          typeof object.then === 'function' ||
-              // errors
-              object instanceof Error ||
-              // weakmaps
-              (realm.WeakMap && object instanceof realm.WeakMap) ||
-              // weaksets
-              (realm.WeakSet && object instanceof realm.WeakSet)) {
-              return object;
-          }
-          // assume anything left is a custom constructor
-          return getObjectClone(object, realm, handleCopy, cache);
-      };
-      return handleCopy(object, createCache());
-  }
-  // Adding reference to allow usage in CommonJS libraries compiled using TSC, which
-  // expects there to be a default property on the exported object. See
-  // [#37](https://github.com/planttheidea/fast-copy/issues/37) for details.
-  copy.default = copy;
-  /**
-   * @function strictCopy
-   *
-   * @description
-   * copy the object with `strict` option pre-applied
-   *
-   * @param object the object to copy
-   * @param [options] the options for copying with
-   * @param [options.realm] the realm (this) object the object is copied from
-   * @returns the copied object
-   */
-  copy.strict = function strictCopy(object, options) {
-      return copy(object, {
-          isStrict: true,
-          realm: options ? options.realm : void 0,
-      });
-  };
+    // utils
+    var isArray = Array.isArray;
+    var getPrototypeOf = Object.getPrototypeOf;
+    var GLOBAL_THIS = (function () {
+        if (typeof globalThis !== 'undefined') {
+            return globalThis;
+        }
+        if (typeof self !== 'undefined') {
+            return self;
+        }
+        if (typeof window !== 'undefined') {
+            return window;
+        }
+        if (typeof global !== 'undefined') {
+            return global;
+        }
+        if (console && console.error) {
+            console.error('Unable to locate global object, returning "this".');
+        }
+        return this;
+    })();
+    /**
+     * @function copy
+     *
+     * @description
+     * copy an value deeply as much as possible
+     *
+     * If `strict` is applied, then all properties (including non-enumerable ones)
+     * are copied with their original property descriptors on both objects and arrays.
+     *
+     * The value is compared to the global constructors in the `realm` provided,
+     * and the native constructor is always used to ensure that extensions of native
+     * objects (allows in ES2015+) are maintained.
+     *
+     * @param value the value to copy
+     * @param [options] the options for copying with
+     * @param [options.isStrict] should the copy be strict
+     * @param [options.realm] the realm (this) value the value is copied from
+     * @returns the copied value
+     */
+    function copy(value, options) {
+        // manually coalesced instead of default parameters for performance
+        var isStrict = !!(options && options.isStrict);
+        var realm = (options && options.realm) || GLOBAL_THIS;
+        var getObjectClone = isStrict ? getObjectCloneStrict : getObjectCloneLoose;
+        /**
+         * @function handleCopy
+         *
+         * @description
+         * copy the value recursively based on its type
+         *
+         * @param value the value to copy
+         * @returns the copied value
+         */
+        var handleCopy = function (value, cache) {
+            if (!value || typeof value !== 'object') {
+                return value;
+            }
+            if (cache.has(value)) {
+                return cache.get(value);
+            }
+            var prototype = value.__proto__ || getPrototypeOf(value);
+            var Constructor = prototype && prototype.constructor;
+            // plain objects
+            if (!Constructor || Constructor === realm.Object) {
+                return getObjectClone(value, realm, handleCopy, cache);
+            }
+            var clone;
+            // arrays
+            if (isArray(value)) {
+                // if strict, include non-standard properties
+                if (isStrict) {
+                    return getObjectCloneStrict(value, realm, handleCopy, cache);
+                }
+                clone = new Constructor();
+                cache.set(value, clone);
+                for (var index = 0, length_1 = value.length; index < length_1; ++index) {
+                    clone[index] = handleCopy(value[index], cache);
+                }
+                return clone;
+            }
+            // dates
+            if (value instanceof realm.Date) {
+                return new Constructor(value.getTime());
+            }
+            // regexps
+            if (value instanceof realm.RegExp) {
+                clone = new Constructor(value.source, value.flags || getRegExpFlags(value));
+                clone.lastIndex = value.lastIndex;
+                return clone;
+            }
+            // maps
+            if (realm.Map && value instanceof realm.Map) {
+                clone = new Constructor();
+                cache.set(value, clone);
+                value.forEach(function (value, key) {
+                    clone.set(key, handleCopy(value, cache));
+                });
+                return clone;
+            }
+            // sets
+            if (realm.Set && value instanceof realm.Set) {
+                clone = new Constructor();
+                cache.set(value, clone);
+                value.forEach(function (value) {
+                    clone.add(handleCopy(value, cache));
+                });
+                return clone;
+            }
+            // blobs
+            if (realm.Blob && value instanceof realm.Blob) {
+                return value.slice(0, value.size, value.type);
+            }
+            // buffers (node-only)
+            if (realm.Buffer && realm.Buffer.isBuffer(value)) {
+                clone = realm.Buffer.allocUnsafe
+                    ? realm.Buffer.allocUnsafe(value.length)
+                    : new Constructor(value.length);
+                cache.set(value, clone);
+                value.copy(clone);
+                return clone;
+            }
+            // arraybuffers / dataviews
+            if (realm.ArrayBuffer) {
+                // dataviews
+                if (realm.ArrayBuffer.isView(value)) {
+                    clone = new Constructor(value.buffer.slice(0));
+                    cache.set(value, clone);
+                    return clone;
+                }
+                // arraybuffers
+                if (value instanceof realm.ArrayBuffer) {
+                    clone = value.slice(0);
+                    cache.set(value, clone);
+                    return clone;
+                }
+            }
+            // if the value cannot / should not be cloned, don't
+            if (
+            // promise-like
+            typeof value.then === 'function' ||
+                // errors
+                value instanceof Error ||
+                // weakmaps
+                (realm.WeakMap && value instanceof realm.WeakMap) ||
+                // weaksets
+                (realm.WeakSet && value instanceof realm.WeakSet)) {
+                return value;
+            }
+            // assume anything left is a custom constructor
+            return getObjectClone(value, realm, handleCopy, cache);
+        };
+        return handleCopy(value, createCache());
+    }
+    // Adding reference to allow usage in CommonJS libraries compiled using TSC, which
+    // expects there to be a default property on the exported value. See
+    // [#37](https://github.com/planttheidea/fast-copy/issues/37) for details.
+    copy.default = copy;
+    /**
+     * @function strictCopy
+     *
+     * @description
+     * copy the value with `strict` option pre-applied
+     *
+     * @param value the value to copy
+     * @param [options] the options for copying with
+     * @param [options.realm] the realm (this) value the value is copied from
+     * @returns the copied value
+     */
+    copy.strict = function strictCopy(value, options) {
+        return copy(value, {
+            isStrict: true,
+            realm: options ? options.realm : void 0,
+        });
+    };
 
-  return copy;
+    return copy;
 
-})));
+}));
 //# sourceMappingURL=fast-copy.js.map
 
 /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "../node_modules/webpack/buildin/global.js")))
@@ -8225,7 +8218,7 @@ var queryForRelease = function queryForRelease(http, params) {
 /*!********************************************!*\
   !*** ./adapters/REST/endpoints/release.ts ***!
   \********************************************/
-/*! exports provided: get, query, create, update, del, publish, unpublish, validate */
+/*! exports provided: get, query, create, update, del, publish, unpublish, validate, archive, unarchive */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -8238,6 +8231,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "publish", function() { return publish; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "unpublish", function() { return unpublish; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validate", function() { return validate; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "archive", function() { return archive; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "unarchive", function() { return unarchive; });
 /* harmony import */ var _raw__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./raw */ "./adapters/REST/endpoints/raw.ts");
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
@@ -8245,7 +8240,6 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
 
 var get = function get(http, params) {
   return _raw__WEBPACK_IMPORTED_MODULE_0__["get"](http, "/spaces/".concat(params.spaceId, "/environments/").concat(params.environmentId, "/releases/").concat(params.releaseId));
@@ -8285,6 +8279,20 @@ var unpublish = function unpublish(http, params, headers) {
 var validate = function validate(http, params, payload) {
   return _raw__WEBPACK_IMPORTED_MODULE_0__["post"](http, "/spaces/".concat(params.spaceId, "/environments/").concat(params.environmentId, "/releases/").concat(params.releaseId, "/validate"), payload);
 };
+var archive = function archive(http, params) {
+  return _raw__WEBPACK_IMPORTED_MODULE_0__["put"](http, "/spaces/".concat(params.spaceId, "/environments/").concat(params.environmentId, "/releases/").concat(params.releaseId, "/archived"), null, {
+    headers: {
+      'X-Contentful-Version': params.version
+    }
+  });
+};
+var unarchive = function unarchive(http, params) {
+  return _raw__WEBPACK_IMPORTED_MODULE_0__["del"](http, "/spaces/".concat(params.spaceId, "/environments/").concat(params.environmentId, "/releases/").concat(params.releaseId, "/archived"), {
+    headers: {
+      'X-Contentful-Version': params.version
+    }
+  });
+};
 
 /***/ }),
 
@@ -10174,7 +10182,7 @@ function createClient(params) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var sdkMain = opts.type === 'plain' ? 'contentful-management-plain.js' : 'contentful-management.js';
   var userAgent = Object(contentful_sdk_core__WEBPACK_IMPORTED_MODULE_0__["getUserAgentHeader"])( // @ts-expect-error
-  "".concat(sdkMain, "/").concat("9.1.0"), params.application, params.integration, params.feature);
+  "".concat(sdkMain, "/").concat("9.2.0"), params.application, params.integration, params.feature);
   var adapter = Object(_create_adapter__WEBPACK_IMPORTED_MODULE_1__["createAdapter"])(params); // Parameters<?> and ReturnType<?> only return the types of the last overload
   // https://github.com/microsoft/TypeScript/issues/26591
   // @ts-expect-error
@@ -13506,6 +13514,80 @@ function createEnvironmentApi(makeRequest) {
       });
     },
 
+    /**
+     * Archives a Release and prevents new operations (publishing, unpublishing adding new entities etc).
+     * @param options.releaseId the ID of the release
+     * @param options.version the version of the release that is to be archived
+     * @returns Promise containing a wrapped Release, that has helper methods within.
+     *
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment-id>'))
+     * .then((environment) => environment.archiveRelease({ releaseId: '<release_id>', version: 1 }))
+     * .catch(console.error)
+     * ```
+     */
+    archiveRelease: function archiveRelease(_ref6) {
+      var releaseId = _ref6.releaseId,
+          version = _ref6.version;
+      var raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Release',
+        action: 'archive',
+        params: {
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id,
+          releaseId: releaseId,
+          version: version
+        }
+      }).then(function (data) {
+        return Object(_entities_release__WEBPACK_IMPORTED_MODULE_3__["wrapRelease"])(makeRequest, data);
+      });
+    },
+
+    /**
+     * Unarchives a previously archived Release - this enables the release to be published, unpublished etc.
+     * @param options.releaseId the ID of the release
+     * @param options.version the version of the release that is to be unarchived
+     * @returns Promise containing a wrapped Release, that has helper methods within.
+     *
+     * @example ```javascript
+     * const contentful = require('contentful-management')
+     *
+     * const client = contentful.createClient({
+     *   accessToken: '<content_management_api_key>'
+     * })
+     *
+     * client.getSpace('<space_id>')
+     * .then((space) => space.getEnvironment('<environment-id>'))
+     * .then((environment) => environment.unarchiveRelease({ releaseId: '<release_id>', version: 1 }))
+     * .catch(console.error)
+     * ```
+     */
+    unarchiveRelease: function unarchiveRelease(_ref7) {
+      var releaseId = _ref7.releaseId,
+          version = _ref7.version;
+      var raw = this.toPlainObject();
+      return makeRequest({
+        entityType: 'Release',
+        action: 'unarchive',
+        params: {
+          spaceId: raw.sys.space.sys.id,
+          environmentId: raw.sys.id,
+          releaseId: releaseId,
+          version: version
+        }
+      }).then(function (data) {
+        return Object(_entities_release__WEBPACK_IMPORTED_MODULE_3__["wrapRelease"])(makeRequest, data);
+      });
+    },
+
     /**
      * Retrieves a ReleaseAction by ID
      * @param params.releaseId The ID of a Release
@@ -13525,9 +13607,9 @@ function createEnvironmentApi(makeRequest) {
      * .catch(console.error)
      * ```
      */
-    getReleaseAction: function getReleaseAction(_ref6) {
-      var actionId = _ref6.actionId,
-          releaseId = _ref6.releaseId;
+    getReleaseAction: function getReleaseAction(_ref8) {
+      var actionId = _ref8.actionId,
+          releaseId = _ref8.releaseId;
       var raw = this.toPlainObject();
       return makeRequest({
         entityType: 'ReleaseAction',
@@ -13563,9 +13645,9 @@ function createEnvironmentApi(makeRequest) {
      * .catch(console.error)
      * ```
      */
-    getReleaseActions: function getReleaseActions(_ref7) {
-      var releaseId = _ref7.releaseId,
-          query = _ref7.query;
+    getReleaseActions: function getReleaseActions(_ref9) {
+      var releaseId = _ref9.releaseId,
+          query = _ref9.query;
       var raw = this.toPlainObject();
       return makeRequest({
         entityType: 'ReleaseAction',
@@ -18348,7 +18430,7 @@ function createReleaseApi(makeRequest) {
   };
 
   return {
-    update: function update(payload) {
+    archive: function archive() {
       var _this = this;
 
       return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
@@ -18360,9 +18442,8 @@ function createReleaseApi(makeRequest) {
                 params = getParams(_this);
                 return _context.abrupt("return", makeRequest({
                   entityType: 'Release',
-                  action: 'update',
-                  params: params,
-                  payload: payload
+                  action: 'archive',
+                  params: params
                 }).then(function (release) {
                   return wrapRelease(makeRequest, release);
                 }));
@@ -18375,7 +18456,7 @@ function createReleaseApi(makeRequest) {
         }, _callee);
       }))();
     },
-    delete: function _delete() {
+    unarchive: function unarchive() {
       var _this2 = this;
 
       return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
@@ -18385,14 +18466,15 @@ function createReleaseApi(makeRequest) {
             switch (_context2.prev = _context2.next) {
               case 0:
                 params = getParams(_this2);
-                _context2.next = 3;
-                return makeRequest({
+                return _context2.abrupt("return", makeRequest({
                   entityType: 'Release',
-                  action: 'delete',
+                  action: 'unarchive',
                   params: params
-                });
+                }).then(function (release) {
+                  return wrapRelease(makeRequest, release);
+                }));
 
-              case 3:
+              case 2:
               case "end":
                 return _context2.stop();
             }
@@ -18400,7 +18482,7 @@ function createReleaseApi(makeRequest) {
         }, _callee2);
       }))();
     },
-    publish: function publish(options) {
+    update: function update(payload) {
       var _this3 = this;
 
       return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3() {
@@ -18412,12 +18494,11 @@ function createReleaseApi(makeRequest) {
                 params = getParams(_this3);
                 return _context3.abrupt("return", makeRequest({
                   entityType: 'Release',
-                  action: 'publish',
-                  params: params
-                }).then(function (data) {
-                  return Object(_release_action__WEBPACK_IMPORTED_MODULE_4__["wrapReleaseAction"])(makeRequest, data);
-                }).then(function (action) {
-                  return action.waitProcessing(options);
+                  action: 'update',
+                  params: params,
+                  payload: payload
+                }).then(function (release) {
+                  return wrapRelease(makeRequest, release);
                 }));
 
               case 2:
@@ -18428,7 +18509,7 @@ function createReleaseApi(makeRequest) {
         }, _callee3);
       }))();
     },
-    unpublish: function unpublish(options) {
+    delete: function _delete() {
       var _this4 = this;
 
       return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4() {
@@ -18438,17 +18519,14 @@ function createReleaseApi(makeRequest) {
             switch (_context4.prev = _context4.next) {
               case 0:
                 params = getParams(_this4);
-                return _context4.abrupt("return", makeRequest({
+                _context4.next = 3;
+                return makeRequest({
                   entityType: 'Release',
-                  action: 'unpublish',
+                  action: 'delete',
                   params: params
-                }).then(function (data) {
-                  return Object(_release_action__WEBPACK_IMPORTED_MODULE_4__["wrapReleaseAction"])(makeRequest, data);
-                }).then(function (action) {
-                  return action.waitProcessing(options);
-                }));
+                });
 
-              case 2:
+              case 3:
               case "end":
                 return _context4.stop();
             }
@@ -18456,7 +18534,7 @@ function createReleaseApi(makeRequest) {
         }, _callee4);
       }))();
     },
-    validate: function validate(options) {
+    publish: function publish(options) {
       var _this5 = this;
 
       return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5() {
@@ -18467,6 +18545,62 @@ function createReleaseApi(makeRequest) {
               case 0:
                 params = getParams(_this5);
                 return _context5.abrupt("return", makeRequest({
+                  entityType: 'Release',
+                  action: 'publish',
+                  params: params
+                }).then(function (data) {
+                  return Object(_release_action__WEBPACK_IMPORTED_MODULE_4__["wrapReleaseAction"])(makeRequest, data);
+                }).then(function (action) {
+                  return action.waitProcessing(options);
+                }));
+
+              case 2:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5);
+      }))();
+    },
+    unpublish: function unpublish(options) {
+      var _this6 = this;
+
+      return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee6() {
+        var params;
+        return regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                params = getParams(_this6);
+                return _context6.abrupt("return", makeRequest({
+                  entityType: 'Release',
+                  action: 'unpublish',
+                  params: params
+                }).then(function (data) {
+                  return Object(_release_action__WEBPACK_IMPORTED_MODULE_4__["wrapReleaseAction"])(makeRequest, data);
+                }).then(function (action) {
+                  return action.waitProcessing(options);
+                }));
+
+              case 2:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6);
+      }))();
+    },
+    validate: function validate(options) {
+      var _this7 = this;
+
+      return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee7() {
+        var params;
+        return regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                params = getParams(_this7);
+                return _context7.abrupt("return", makeRequest({
                   entityType: 'Release',
                   action: 'validate',
                   params: params,
@@ -18479,10 +18613,10 @@ function createReleaseApi(makeRequest) {
 
               case 2:
               case "end":
-                return _context5.stop();
+                return _context7.stop();
             }
           }
-        }, _callee5);
+        }, _callee7);
       }))();
     }
   };
@@ -20445,12 +20579,14 @@ var createPlainClient = function createPlainClient(makeRequest, defaults, alphaF
       getManyForOrganization: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Usage', 'getManyForOrganization')
     },
     release: {
+      archive: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Release', 'archive'),
       get: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Release', 'get'),
       query: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Release', 'query'),
       create: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Release', 'create'),
       update: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Release', 'update'),
       delete: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Release', 'delete'),
       publish: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Release', 'publish'),
+      unarchive: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Release', 'unarchive'),
       unpublish: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Release', 'unpublish'),
       validate: Object(_wrappers_wrap__WEBPACK_IMPORTED_MODULE_2__["wrap"])(wrapParams, 'Release', 'validate')
     },