@openeo/js-client 2.6.0 → 2.8.0

package/openeo.js

@@ -1,270 +1,270 @@
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
-		module.exports = factory(require("Oidc"), require("axios"));
+		module.exports = factory(require("axios"), require("Oidc"));
 	else if(typeof define === 'function' && define.amd)
-		define(["Oidc", "axios"], factory);
+		define(["axios", "Oidc"], factory);
 	else {
-		var a = typeof exports === 'object' ? factory(require("Oidc"), require("axios")) : factory(root["Oidc"], root["axios"]);
+		var a = typeof exports === 'object' ? factory(require("axios"), require("Oidc")) : factory(root["axios"], root["Oidc"]);
 		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
 	}
-})(self, (__WEBPACK_EXTERNAL_MODULE__117__, __WEBPACK_EXTERNAL_MODULE__742__) => {
+})(self, (__WEBPACK_EXTERNAL_MODULE__742__, __WEBPACK_EXTERNAL_MODULE__117__) => {
 return /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
 /***/ 659:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const Utils = __webpack_require__(768);
-
-/**
- * Central registry for processes.
- * 
- * @class
- */
-class ProcessRegistry {
-
-	/**
-	 * Creates a new registry of all processes.
-	 * 
-	 * @param {Array.<object>|ProcessRegistry} [processes=[]] - Optionally, a list of predefined processes.
-	 * @param {boolean} [addNamespace=false] - Add a namespace property to processes if set to `true`.
-	 */
-	constructor(processes = [], addNamespace = false) {
-		/**
-		 * List of listeners for change events.
-		 * @public
-		 */
-		this.listeners = [];
-		/**
-		 * Object of namespaces and processes.
-		 * @protected
-		 * @type {object.<string,object.<string,object>>}
-		 */
-		this.processes = {};
-		/**
-		 * Add a namespace property to processes if set to `true`.
-		 * @protected
-		 * @type {boolean}
-		 */
-		this.addNamespace = addNamespace;
-
-		// Fill process list
-		if (processes instanceof ProcessRegistry) {
-			for(let namespace in processes.processes) {
-				this.addAll(processes.processes[namespace]);
-			}
-		}
-		else {
-			this.addAll(processes);
-		}
-	}
-
-	/**
-	 * Event that is fired on changes, notifies listeners.
-	 * 
-	 * @param {string} event - One of 'add', 'addAll' or 'remove'.
-	 * @param {*} data 
-	 * @param {string} namespace 
-	 */
-	onChange(event, data, namespace) {
-		for(let listener of this.listeners) {
-			listener(event, data, namespace);
-		}
-	}
-
-	/**
-	 * Adds a list of processes for a given namespace.
-	 * 
-	 * Replaces an existing process in the given namespace if it exists.
-	 * 
-	 * Fires 'addAll' event.
-	 * 
-	 * @param {Array.<object>} processes Optionally, a list of processes
-	 * @param {string} [namespace="backend"] The namespace for the processes (defaults to 'backend', i.e. pre-defined processes)
-	 */
-	addAll(processes, namespace = 'backend') {
-		for(var i in processes) {
-			this.add(processes[i], namespace, false);
-		}
-		this.onChange('addAll', processes, namespace);
-	}
-
-	/**
-	 * Adds a single process to a given namespace.
-	 * 
-	 * Replaces an existing process in the given namespace if it exists.
-	 * 
-	 * Fires 'add' event.
-	 * 
-	 * @param {object} processes A process definition
-	 * @param {string} [namespace="backend"] The namespace for the process (defaults to 'backend', i.e. pre-defined processes)
-	 */
-	add(process, namespace = 'backend', fireEvent = true) {
-		if (!Utils.isObject(process)) {
-			throw new Error("Invalid process; not an object.");
-		}
-		if (typeof process.id !== 'string') {
-			throw new Error("Invalid process; no id specified.");
-		}
-		if (typeof namespace !== 'string') {
-			throw new Error("Invalid namespace; not a string.");
-		}
-
-		if (!this.processes[namespace]) {
-			this.processes[namespace] = {};
-		}
-		process = Object.assign(this.addNamespace ? {namespace} : {}, process);
-		this.processes[namespace][process.id] = process;
-		if (fireEvent) {
-			this.onChange('add', process, namespace);
-		}
-	}
-
-	/**
-	 * Returns the count of all processes independant of the namespaces.
-	 * 
-	 * @returns {number} 
-	 */
-	count() {
-		return Utils.size(this.all());
-	}
-
-	/**
-	 * Returns all processes as a list, independant of the namespaces.
-	 * 
-	 * @returns {Array.<object>} 
-	 */
-	all() {
-		let processes = [];
-		for(let ns in this.processes) {
-			processes = processes.concat(Object.values(this.processes[ns]));
-		}
-		return processes;
-	}
-
-	/**
-	 * Checks whether a namespace exists (i.e. at least one process for the namespace exists)
-	 * 
-	 * @param {string} namespace The namespace
-	 * @returns {boolean}
-	 */
-	hasNamespace(namespace) {
-		if(typeof namespace !== 'string') {
-			return false;
-		}
-		return Boolean(this.processes[namespace]);
-	}
-
-	/**
-	 * Returns a (sorted) list of all available namespaces.
-	 * 
-	 * @returns {Array.<string>} 
-	 */
-	namespaces() {
-		return Object.keys(this.processes).sort();
-	}
-
-	/**
-	 * Returns all processes from a specific namespace.
-	 * 
-	 * Returns an empty list if the namespace is not defined.
-	 * 
-	 * @param {string} namespace The namespace of the processes to return (e.g. 'backend' for pre-defined processes)
-	 * @returns {Array.<object>} 
-	 */
-	namespace(namespace) {
-		if(typeof namespace !== 'string') {
-			return [];
-		}
-		let processes = this.processes[namespace];
-		return processes ? Object.values(processes) : [];
-	}
-
-	/**
-	 * Checks whether a process with the given ID exists in the given namespace.
-	 * 
-	 * If the namespace is set to `null` (default) then it checks both user processes and backend processes.
-	 * The default namespace for pre-defined processes is `backend`.
-	 * 
-	 * @param {string} id The process identifier
-	 * @param {?string} [namespace=null] The namespace of the process
-	 * @returns {boolean} 
-	 */
-	has(id, namespace = null) {
-		return Boolean(this.get(id, namespace));
-	}
-	
-	/**
-	 * Retrieve the process with the given ID fron the given namespace.
-	 * 
-	 * If the namespace is set to `null` (default) then it retrieces from both (1) `user` processes and (2) `backend` processes
-	 * with preference to user processes on conflict. The default namespace for pre-defined processes is `backend`.
-	 * 
-	 * @param {string} id The process identifier
-	 * @param {?string} [namespace=null] The namespace of the process
-	 * @returns {object} 
-	 */
-	get(id, namespace = null) {
-		if (typeof id !== 'string') {
-			return null;
-		}
-
-		// If no namespace is set, prefer the user namespace over backend namespace
-		if (namespace === null) {
-			return this.get(id, 'user') || this.get(id, 'backend');
-		}
-
-		if (this.processes[namespace]) {
-			return this.processes[namespace][id] || null;
-		}
-		return null;
-	}
-
-	/**
-	 * Removes a single process or a complete namespace from the registry.
-	 * 
-	 * If nothing is given, removes the namespace 'user'.
-	 * If only a namespace is given, removes the whole namespace.
-	 * If only a process is given, removes a process from the namespace `user`.
-	 * If both parameters are given, removes a process from the given namespace.
-	 * 
-	 * Returns `true` on succes, `false` on failure.
-	 * 
-	 * Fires 'remove' event.
-	 * 
-	 * @param {?string} [id=null] The process identifier
-	 * @param {?string} [namespace="user"] The namespace, defaults to `user`
-	 * @returns {boolean}
-	 */
-	remove(id = null, namespace = 'user') {
-		if (typeof namespace !== 'string') {
-			return false;
-		}
-
-		if (this.processes[namespace]) {
-			if (typeof id === 'string') {
-				if (this.processes[namespace][id]) {
-					let process = this.processes[namespace][id];
-					delete this.processes[namespace][id];
-					if (Utils.size(this.processes[namespace]) === 0) {
-						delete this.processes[namespace];
-					}
-					this.onChange('remove', process, namespace);
-					return true;
-				}
-			}
-			else {
-				delete this.processes[namespace];
-				this.onChange('remove', null, namespace);
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-}
-
+const Utils = __webpack_require__(768);
+
+/**
+ * Central registry for processes.
+ * 
+ * @class
+ */
+class ProcessRegistry {
+
+	/**
+	 * Creates a new registry of all processes.
+	 * 
+	 * @param {Array.<object>|ProcessRegistry} [processes=[]] - Optionally, a list of predefined processes.
+	 * @param {boolean} [addNamespace=false] - Add a namespace property to processes if set to `true`.
+	 */
+	constructor(processes = [], addNamespace = false) {
+		/**
+		 * List of listeners for change events.
+		 * @public
+		 */
+		this.listeners = [];
+		/**
+		 * Object of namespaces and processes.
+		 * @protected
+		 * @type {object.<string,object.<string,object>>}
+		 */
+		this.processes = {};
+		/**
+		 * Add a namespace property to processes if set to `true`.
+		 * @protected
+		 * @type {boolean}
+		 */
+		this.addNamespace = addNamespace;
+
+		// Fill process list
+		if (processes instanceof ProcessRegistry) {
+			for(let namespace in processes.processes) {
+				this.addAll(processes.processes[namespace]);
+			}
+		}
+		else {
+			this.addAll(processes);
+		}
+	}
+
+	/**
+	 * Event that is fired on changes, notifies listeners.
+	 * 
+	 * @param {string} event - One of 'add', 'addAll' or 'remove'.
+	 * @param {*} data 
+	 * @param {string} namespace 
+	 */
+	onChange(event, data, namespace) {
+		for(let listener of this.listeners) {
+			listener(event, data, namespace);
+		}
+	}
+
+	/**
+	 * Adds a list of processes for a given namespace.
+	 * 
+	 * Replaces an existing process in the given namespace if it exists.
+	 * 
+	 * Fires 'addAll' event.
+	 * 
+	 * @param {Array.<object>} processes Optionally, a list of processes
+	 * @param {string} [namespace="backend"] The namespace for the processes (defaults to 'backend', i.e. pre-defined processes)
+	 */
+	addAll(processes, namespace = 'backend') {
+		for(var i in processes) {
+			this.add(processes[i], namespace, false);
+		}
+		this.onChange('addAll', processes, namespace);
+	}
+
+	/**
+	 * Adds a single process to a given namespace.
+	 * 
+	 * Replaces an existing process in the given namespace if it exists.
+	 * 
+	 * Fires 'add' event.
+	 * 
+	 * @param {object} processes A process definition
+	 * @param {string} [namespace="backend"] The namespace for the process (defaults to 'backend', i.e. pre-defined processes)
+	 */
+	add(process, namespace = 'backend', fireEvent = true) {
+		if (!Utils.isObject(process)) {
+			throw new Error("Invalid process; not an object.");
+		}
+		if (typeof process.id !== 'string') {
+			throw new Error("Invalid process; no id specified.");
+		}
+		if (typeof namespace !== 'string') {
+			throw new Error("Invalid namespace; not a string.");
+		}
+
+		if (!this.processes[namespace]) {
+			this.processes[namespace] = {};
+		}
+		process = Object.assign(this.addNamespace ? {namespace} : {}, process);
+		this.processes[namespace][process.id] = process;
+		if (fireEvent) {
+			this.onChange('add', process, namespace);
+		}
+	}
+
+	/**
+	 * Returns the count of all processes independant of the namespaces.
+	 * 
+	 * @returns {number} 
+	 */
+	count() {
+		return Utils.size(this.all());
+	}
+
+	/**
+	 * Returns all processes as a list, independant of the namespaces.
+	 * 
+	 * @returns {Array.<object>} 
+	 */
+	all() {
+		let processes = [];
+		for(let ns in this.processes) {
+			processes = processes.concat(Object.values(this.processes[ns]));
+		}
+		return processes;
+	}
+
+	/**
+	 * Checks whether a namespace exists (i.e. at least one process for the namespace exists)
+	 * 
+	 * @param {string} namespace The namespace
+	 * @returns {boolean}
+	 */
+	hasNamespace(namespace) {
+		if(typeof namespace !== 'string') {
+			return false;
+		}
+		return Boolean(this.processes[namespace]);
+	}
+
+	/**
+	 * Returns a (sorted) list of all available namespaces.
+	 * 
+	 * @returns {Array.<string>} 
+	 */
+	namespaces() {
+		return Object.keys(this.processes).sort();
+	}
+
+	/**
+	 * Returns all processes from a specific namespace.
+	 * 
+	 * Returns an empty list if the namespace is not defined.
+	 * 
+	 * @param {string} namespace The namespace of the processes to return (e.g. 'backend' for pre-defined processes)
+	 * @returns {Array.<object>} 
+	 */
+	namespace(namespace) {
+		if(typeof namespace !== 'string') {
+			return [];
+		}
+		let processes = this.processes[namespace];
+		return processes ? Object.values(processes) : [];
+	}
+
+	/**
+	 * Checks whether a process with the given ID exists in the given namespace.
+	 * 
+	 * If the namespace is set to `null` (default) then it checks both user processes and backend processes.
+	 * The default namespace for pre-defined processes is `backend`.
+	 * 
+	 * @param {string} id The process identifier
+	 * @param {?string} [namespace=null] The namespace of the process
+	 * @returns {boolean} 
+	 */
+	has(id, namespace = null) {
+		return Boolean(this.get(id, namespace));
+	}
+	
+	/**
+	 * Retrieve the process with the given ID fron the given namespace.
+	 * 
+	 * If the namespace is set to `null` (default) then it retrieces from both (1) `user` processes and (2) `backend` processes
+	 * with preference to user processes on conflict. The default namespace for pre-defined processes is `backend`.
+	 * 
+	 * @param {string} id The process identifier
+	 * @param {?string} [namespace=null] The namespace of the process
+	 * @returns {object} 
+	 */
+	get(id, namespace = null) {
+		if (typeof id !== 'string') {
+			return null;
+		}
+
+		// If no namespace is set, prefer the user namespace over backend namespace
+		if (namespace === null) {
+			return this.get(id, 'user') || this.get(id, 'backend');
+		}
+
+		if (this.processes[namespace]) {
+			return this.processes[namespace][id] || null;
+		}
+		return null;
+	}
+
+	/**
+	 * Removes a single process or a complete namespace from the registry.
+	 * 
+	 * If nothing is given, removes the namespace 'user'.
+	 * If only a namespace is given, removes the whole namespace.
+	 * If only a process is given, removes a process from the namespace `user`.
+	 * If both parameters are given, removes a process from the given namespace.
+	 * 
+	 * Returns `true` on succes, `false` on failure.
+	 * 
+	 * Fires 'remove' event.
+	 * 
+	 * @param {?string} [id=null] The process identifier
+	 * @param {?string} [namespace="user"] The namespace, defaults to `user`
+	 * @returns {boolean}
+	 */
+	remove(id = null, namespace = 'user') {
+		if (typeof namespace !== 'string') {
+			return false;
+		}
+
+		if (this.processes[namespace]) {
+			if (typeof id === 'string') {
+				if (this.processes[namespace][id]) {
+					let process = this.processes[namespace][id];
+					delete this.processes[namespace][id];
+					if (Utils.size(this.processes[namespace]) === 0) {
+						delete this.processes[namespace];
+					}
+					this.onChange('remove', process, namespace);
+					return true;
+				}
+			}
+			else {
+				delete this.processes[namespace];
+				this.onChange('remove', null, namespace);
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+}
+
 module.exports = ProcessRegistry;
 
 /***/ }),
@@ -272,206 +272,206 @@ module.exports = ProcessRegistry;
 /***/ 779:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const Utils = __webpack_require__(768);
-
-/**
- * Utilities to parse process specs and JSON schemas.
- * 
- * @class
- */
-class ProcessUtils {
-
-	/**
-	 * From a "complex" JSON Schema with allOf/anyOf/oneOf, make separate schemas.
-	 * 
-	 * So afterwards each schema has it's own array entry.
-	 * It merges allOf, resolves anyOf/oneOf into separate schemas.
-	 * May also split the JSON Schema type arrays into separate entries by setting `splitTypes` to `true`.
-	 * 
-	 * @param {object|array} schemas - The JSON Schema(s) to convert
-	 * @returns {array}
-	 */
-	static normalizeJsonSchema(schemas, splitTypes = false) {
-		// Make schemas always an array
-		if (Utils.isObject(schemas)) {
-			schemas = [schemas];
-		}
-		else if (Array.isArray(schemas)) {
-			schemas = schemas;
-		}
-		else {
-			schemas = [];
-		}
-
-		// Merge allOf, resolve anyOf/oneOf into separate schemas
-		let normalized = [];
-		for(let schema of schemas) {
-			if (Array.isArray(schema.allOf)) {
-				normalized.push(Object.assign({}, ...schema.allOf));
-			}
-			else if (Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf)) {
-				let copy = Utils.omitFromObject(schema, ['oneOf', 'anyOf']);
-				let subSchemas = schema.oneOf || schema.anyOf;
-				for(let subSchema of subSchemas) {
-					normalized.push(Object.assign({}, copy, subSchema));
-				}
-			}
-			else {
-				normalized.push(schema);
-			}
-		}
-
-		if (!splitTypes) {
-			return normalized;
-		}
-
-		// Split type field into separate schemas
-		schemas = [];
-		for(let schema of normalized) {
-			if (Array.isArray(schema.type)) {
-				/* jshint ignore:start */
-				schemas = schemas.concat(schema.type.map(type => Object.assign({}, schema, {type: type})));
-				/* jshint ignore:end */
-			}
-			else {
-				schemas.push(schema);
-			}
-		}
-
-		return schemas;
-	}
-
-	/**
-	 * Returns the callback parameters for a given process parameter.
-	 * 
-	 * @param {object} processParameter - The process parameter spec to parse.
-	 * @returns {array}
-	 * @throws {Error}
-	 */
-	static getCallbackParameters(processParameter, keyPath = []) {
-		if (!Utils.isObject(processParameter) || !processParameter.schema) {
-			return [];
-		}
-
-		let schemas = ProcessUtils.normalizeJsonSchema(processParameter.schema);
-		let key;
-		while(key = keyPath.shift()) { // jshint ignore:line
-			schemas = schemas.map(schema => ProcessUtils.normalizeJsonSchema(ProcessUtils.getElementJsonSchema(schema, key))); // jshint ignore:line
-			schemas = schemas.concat(...schemas);
-		}
-
-
-		let cbParams = [];
-		for(let schema of schemas) {
-			let params = null;
-			if (Array.isArray(schema.parameters)) { // For "normal" callbacks
-				params = schema.parameters;
-			}
-			else if (Utils.isObject(schema.additionalProperties) && Array.isArray(schema.additionalProperties.parameters)) {
-				params = schema.additionalProperties.parameters; // Used for metadata-filter
-			}
-			if (Array.isArray(params)) {
-				if (cbParams.length > 0 && !Utils.equals(cbParams, params)) {
-					throw new Error("Multiple schemas with different callback parameters found.");
-				}
-				cbParams = params;
-			}
-		}
-
-		return cbParams;
-	}
-
-	/**
-	 * Returns the callback parameters for a given process parameter from a full process spec.
-	 * 
-	 * @param {object} process - The process to parse.
-	 * @param {string} parameterName - The name of the parameter to get the callback parameters for.
-	 * @returns {array}
-	 * @throws {Error}
-	 */
-	static getCallbackParametersForProcess(process, parameterName, path = []) {
-		if (!Utils.isObject(process) || !Array.isArray(process.parameters)) {
-			return [];
-		}
-
-		let param = process.parameters.find(p => p.name === parameterName);
-		return ProcessUtils.getCallbackParameters(param, path);
-	}
-
-	/**
-	 * Returns *all* the native JSON data types allowed for the schema.
-	 * 
-	 * @param {object} schema 
-	 * @param {boolean} anyIsEmpty
-	 * @returns {array}
-	 */
-	static getNativeTypesForJsonSchema(schema, anyIsEmpty = false) {
-		if (Utils.isObject(schema) && Array.isArray(schema.type)) {
-			// Remove duplicate and invalid types
-			let validTypes = Utils.unique(schema.type).filter(type => ProcessUtils.JSON_SCHEMA_TYPES.includes(type));
-			if (validTypes.length > 0 && validTypes.length < ProcessUtils.JSON_SCHEMA_TYPES.length) {
-				return validTypes;
-			}
-			else {
-				return anyIsEmpty ? [] : ProcessUtils.JSON_SCHEMA_TYPES;
-			}
-		}
-		else if (Utils.isObject(schema) && typeof schema.type === 'string' && ProcessUtils.JSON_SCHEMA_TYPES.includes(schema.type)) {
-			return [schema.type];
-		}
-		else {
-			return anyIsEmpty ? [] : ProcessUtils.JSON_SCHEMA_TYPES;
-		}
-	}
-
-	/**
-	 * Returns the schema for a property of an object or an element of an array.
-	 * 
-	 * If you want to retrieve the schema for a specific key, use the parameter `key`.
-	 * 
-	 * @param {object} schema - The JSON schema to parse.
-	 * @param {string|integer|null} key - If you want to retrieve the schema for a specific key, otherwise null.
-	 * @returns {object} - JSON Schema
-	 */
-	static getElementJsonSchema(schema, key = null) {
-		let types = ProcessUtils.getNativeTypesForJsonSchema(schema);
-		if (Utils.isObject(schema) && types.includes('array') && typeof key !== 'string') {
-			if (Utils.isObject(schema.items)) {
-				// Array with one schema for all items: https://json-schema.org/understanding-json-schema/reference/array.html#id5
-				return schema.items;
-			}
-			else if (Array.isArray(schema.items)) {
-				// Tuple validation: https://json-schema.org/understanding-json-schema/reference/array.html#id6
-				if (key !== null && Utils.isObject(schema.items[key])) {
-					return schema.items[key];
-				}
-				else if (Utils.isObject(schema.additionalItems)) {
-					return schema.additionalItems;
-				}
-			}
-		}
-		if (Utils.isObject(schema) && types.includes('object')) {
-			if (key !== null && Utils.isObject(schema.properties) && Utils.isObject(schema.properties[key])) {
-				return schema.properties[key];
-			}
-			else if (Utils.isObject(schema.additionalProperties)) {
-				return schema.additionalProperties;
-			}
-			// ToDo: No support for patternProperties yet
-		}
-
-		return {};
-	}
-
-}
-
-/**
- * A list of all allowed JSON Schema type values.
- * 
- * @type {array}
- */
-ProcessUtils.JSON_SCHEMA_TYPES = ['string', 'number', 'integer', 'boolean', 'array', 'object', 'null'];
-
+const Utils = __webpack_require__(768);
+
+/**
+ * Utilities to parse process specs and JSON schemas.
+ * 
+ * @class
+ */
+class ProcessUtils {
+
+	/**
+	 * From a "complex" JSON Schema with allOf/anyOf/oneOf, make separate schemas.
+	 * 
+	 * So afterwards each schema has it's own array entry.
+	 * It merges allOf, resolves anyOf/oneOf into separate schemas.
+	 * May also split the JSON Schema type arrays into separate entries by setting `splitTypes` to `true`.
+	 * 
+	 * @param {object|array} schemas - The JSON Schema(s) to convert
+	 * @returns {array}
+	 */
+	static normalizeJsonSchema(schemas, splitTypes = false) {
+		// Make schemas always an array
+		if (Utils.isObject(schemas)) {
+			schemas = [schemas];
+		}
+		else if (Array.isArray(schemas)) {
+			schemas = schemas;
+		}
+		else {
+			schemas = [];
+		}
+
+		// Merge allOf, resolve anyOf/oneOf into separate schemas
+		let normalized = [];
+		for(let schema of schemas) {
+			if (Array.isArray(schema.allOf)) {
+				normalized.push(Object.assign({}, ...schema.allOf));
+			}
+			else if (Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf)) {
+				let copy = Utils.omitFromObject(schema, ['oneOf', 'anyOf']);
+				let subSchemas = schema.oneOf || schema.anyOf;
+				for(let subSchema of subSchemas) {
+					normalized.push(Object.assign({}, copy, subSchema));
+				}
+			}
+			else {
+				normalized.push(schema);
+			}
+		}
+
+		if (!splitTypes) {
+			return normalized;
+		}
+
+		// Split type field into separate schemas
+		schemas = [];
+		for(let schema of normalized) {
+			if (Array.isArray(schema.type)) {
+				/* jshint ignore:start */
+				schemas = schemas.concat(schema.type.map(type => Object.assign({}, schema, {type: type})));
+				/* jshint ignore:end */
+			}
+			else {
+				schemas.push(schema);
+			}
+		}
+
+		return schemas;
+	}
+
+	/**
+	 * Returns the callback parameters for a given process parameter.
+	 * 
+	 * @param {object} processParameter - The process parameter spec to parse.
+	 * @returns {array}
+	 * @throws {Error}
+	 */
+	static getCallbackParameters(processParameter, keyPath = []) {
+		if (!Utils.isObject(processParameter) || !processParameter.schema) {
+			return [];
+		}
+
+		let schemas = ProcessUtils.normalizeJsonSchema(processParameter.schema);
+		let key;
+		while(key = keyPath.shift()) { // jshint ignore:line
+			schemas = schemas.map(schema => ProcessUtils.normalizeJsonSchema(ProcessUtils.getElementJsonSchema(schema, key))); // jshint ignore:line
+			schemas = schemas.concat(...schemas);
+		}
+
+
+		let cbParams = [];
+		for(let schema of schemas) {
+			let params = null;
+			if (Array.isArray(schema.parameters)) { // For "normal" callbacks
+				params = schema.parameters;
+			}
+			else if (Utils.isObject(schema.additionalProperties) && Array.isArray(schema.additionalProperties.parameters)) {
+				params = schema.additionalProperties.parameters; // Used for metadata-filter
+			}
+			if (Array.isArray(params)) {
+				if (cbParams.length > 0 && !Utils.equals(cbParams, params)) {
+					throw new Error("Multiple schemas with different callback parameters found.");
+				}
+				cbParams = params;
+			}
+		}
+
+		return cbParams;
+	}
+
+	/**
+	 * Returns the callback parameters for a given process parameter from a full process spec.
+	 * 
+	 * @param {object} process - The process to parse.
+	 * @param {string} parameterName - The name of the parameter to get the callback parameters for.
+	 * @returns {array}
+	 * @throws {Error}
+	 */
+	static getCallbackParametersForProcess(process, parameterName, path = []) {
+		if (!Utils.isObject(process) || !Array.isArray(process.parameters)) {
+			return [];
+		}
+
+		let param = process.parameters.find(p => p.name === parameterName);
+		return ProcessUtils.getCallbackParameters(param, path);
+	}
+
+	/**
+	 * Returns *all* the native JSON data types allowed for the schema.
+	 * 
+	 * @param {object} schema 
+	 * @param {boolean} anyIsEmpty
+	 * @returns {array}
+	 */
+	static getNativeTypesForJsonSchema(schema, anyIsEmpty = false) {
+		if (Utils.isObject(schema) && Array.isArray(schema.type)) {
+			// Remove duplicate and invalid types
+			let validTypes = Utils.unique(schema.type).filter(type => ProcessUtils.JSON_SCHEMA_TYPES.includes(type));
+			if (validTypes.length > 0 && validTypes.length < ProcessUtils.JSON_SCHEMA_TYPES.length) {
+				return validTypes;
+			}
+			else {
+				return anyIsEmpty ? [] : ProcessUtils.JSON_SCHEMA_TYPES;
+			}
+		}
+		else if (Utils.isObject(schema) && typeof schema.type === 'string' && ProcessUtils.JSON_SCHEMA_TYPES.includes(schema.type)) {
+			return [schema.type];
+		}
+		else {
+			return anyIsEmpty ? [] : ProcessUtils.JSON_SCHEMA_TYPES;
+		}
+	}
+
+	/**
+	 * Returns the schema for a property of an object or an element of an array.
+	 * 
+	 * If you want to retrieve the schema for a specific key, use the parameter `key`.
+	 * 
+	 * @param {object} schema - The JSON schema to parse.
+	 * @param {string|integer|null} key - If you want to retrieve the schema for a specific key, otherwise null.
+	 * @returns {object} - JSON Schema
+	 */
+	static getElementJsonSchema(schema, key = null) {
+		let types = ProcessUtils.getNativeTypesForJsonSchema(schema);
+		if (Utils.isObject(schema) && types.includes('array') && typeof key !== 'string') {
+			if (Utils.isObject(schema.items)) {
+				// Array with one schema for all items: https://json-schema.org/understanding-json-schema/reference/array.html#id5
+				return schema.items;
+			}
+			else if (Array.isArray(schema.items)) {
+				// Tuple validation: https://json-schema.org/understanding-json-schema/reference/array.html#id6
+				if (key !== null && Utils.isObject(schema.items[key])) {
+					return schema.items[key];
+				}
+				else if (Utils.isObject(schema.additionalItems)) {
+					return schema.additionalItems;
+				}
+			}
+		}
+		if (Utils.isObject(schema) && types.includes('object')) {
+			if (key !== null && Utils.isObject(schema.properties) && Utils.isObject(schema.properties[key])) {
+				return schema.properties[key];
+			}
+			else if (Utils.isObject(schema.additionalProperties)) {
+				return schema.additionalProperties;
+			}
+			// ToDo: No support for patternProperties yet
+		}
+
+		return {};
+	}
+
+}
+
+/**
+ * A list of all allowed JSON Schema type values.
+ * 
+ * @type {array}
+ */
+ProcessUtils.JSON_SCHEMA_TYPES = ['string', 'number', 'integer', 'boolean', 'array', 'object', 'null'];
+
 module.exports = ProcessUtils;
 
 /***/ }),
@@ -479,327 +479,327 @@ module.exports = ProcessUtils;
 /***/ 768:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var equal = __webpack_require__(252);
-
-/**
- * General utilities
- * 
- * @class
- */
-class Utils {
-
-	/**
-	 * Checks whether a variable is a real object or not.
-	 * 
-	 * This is a more strict version of `typeof x === 'object'` as this example would also succeeds for arrays and `null`.
-	 * This function only returns `true` for real objects and not for arrays, `null` or any other data types.
-	 * 
-	 * @param {*} obj - A variable to check.
-	 * @returns {boolean} - `true` is the given variable is an object, `false` otherwise.
-	 */
-	static isObject(obj) {
-		return (typeof obj === 'object' && obj === Object(obj) && !Array.isArray(obj));
-	}
-
-	/**
-	 * Checks whether a variable is a string and contains at least one character.
-	 * 
-	 * @param {*} string - A variable to check.
-	 * @returns {boolean} - `true` is the given variable is an string with length > 0, `false` otherwise.
-	 */
-	static hasText(string) {
-		return (typeof string === 'string' && string.length > 0);
-	}
-
-	/**
-	 * Performs a deep comparison between two values to determine if they are equivalent.
-	 * 
-	 * @param {*} x - The value to compare.
-	 * @param {*} y - The other value to compare.
-	 * @returns {boolean} - Returns true if the values are equivalent, else false.
-	 */
-	static equals(x, y) {
-		return equal(x, y);
-	}
-
-	/**
-	 * Creates an object composed of the picked object properties.
-	 * 
-	 * Returns a shallow copy!
-	 * 
-	 * @param {object} obj - The source object.
-	 * @param {string|array} toPick - The properties to pick.
-	 * @returns {object}
-	 */
-	static pickFromObject(obj, toPick) {
-		obj = Object(obj);
-		if (typeof toPick === 'string') {
-			toPick = [toPick];
-		}
-		const copy = {};
-		toPick.forEach(key => copy[key] = obj[key]);
-		return copy;
-	}
-
-	/**
-	 * This method creates an object composed of the own and inherited enumerable property paths of object that are not omitted.
-	 * 
-	 * Returns a shallow copy!
-	 * 
-	 * @param {object} obj - The source object.
-	 * @param {string|array} toOmit - The properties to omit.
-	 * @returns {object}
-	 */
-	static omitFromObject(obj, toOmit) {
-		obj = Object(obj);
-		if (typeof toOmit === 'string') {
-			toOmit = [toOmit];
-		}
-		var copy = Object.assign({}, obj);
-		for(let key of toOmit) {
-			delete copy[key];
-		}
-		return copy;
-	}
-
-	/**
-	 *  Creates an array of values by running each property of `object` thru function.
-	 * 
-	 * The function is invoked with three arguments: (value, key, object).
-	 * 
-	 * @param {object} obj 
-	 * @param {function} func 
-	 * @returns {object}
-	 */
-	static mapObject(obj, func) {
-		// Taken from lodash, see https://github.com/lodash/lodash/blob/master/mapObject.js
-		const props = Object.keys(obj);
-		const result = new Array(props.length);
-		props.forEach((key, index) => {
-			result[index] = func(obj[key], key, obj);
-		});
-		return result;
-	}
-
-	/**
-	 * Creates an object with the same keys as object and values generated by running each own enumerable string keyed property of object thru the function.
-	 * 
-	 * The function is invoked with three arguments: (value, key, object).
-	 * 
-	 * @param {object} obj 
-	 * @param {function} func 
-	 * @returns {object}
-	 */
-	static mapObjectValues(obj, func) {
-		// Taken from lodash, see https://github.com/lodash/lodash/blob/master/mapValue.js
-		obj = Object(obj);
-		const result = {};
-		Object.keys(obj).forEach((key) => {
-			result[key] = func(obj[key], key, obj);
-		});
-		return result;
-	}
-
-	/**
-	 * Creates a duplicate-free version of an array.
-	 * 
-	 * If useEquals is set to true, uses the `Utils.equals` function for comparison instead of 
-	 * the JS === operator. Thus, if the array contains objects, you likely want to set 
-	 * `useEquals` to `true`.
-	 * 
-	 * @param {array} array
-	 * @param {boolean} useEquals
-	 * @returns {array}
-	 */
-	static unique(array, useEquals = false) {
-		if (useEquals) {
-			return array.filter((s1, pos, arr) => arr.findIndex(s2 => Utils.equals(s1, s2)) === pos);
-		}
-		else {
-			return [...new Set(array)];
-		}
-	}
-	
-	/**
-	 * Computes the size of an array (number of array elements) or object (number of key-value-pairs).
-	 * 
-	 * Returns 0 for all other data types.
-	 * 
-	 * @param {*} obj 
-	 * @returns {integer}
-	 */
-	static size(obj) {
-		if (typeof obj === 'object' && obj !== null) {
-			if (Array.isArray(obj)) {
-				return obj.length;
-			}
-			else {
-				return Object.keys(obj).length;
-			}
-		}
-		return 0;
-	}
-
-	/**
-	 * Checks whether a variable is numeric.
-	 * 
-	 * Numeric is every string with numeric data or a number, excluding NaN and finite numbers.
-	 * 
-	 * @param {*} n - A variable to check.
-	 * @returns {boolean} - `true` is the given variable is numeric, `false` otherwise.
-	 */
-	static isNumeric(n) {
-		return !isNaN(parseFloat(n)) && isFinite(n);
-    }
-    
-    /**
-     * Deep clone for JSON-compatible data.
-     * 
-     * @param {*} x - The data to clone.
-     * @returns {*} - The cloned data.
-     */
-    static deepClone(x) {
-		return JSON.parse(JSON.stringify(x));
-    }
-
-	/**
-	 * Normalize a URL (mostly handling leading and trailing slashes).
-	 * 
-	 * @static
-	 * @param {string} baseUrl - The URL to normalize
-	 * @param {string} path - An optional path to add to the URL
-	 * @returns {string} Normalized URL.
-	 */
-	static normalizeUrl(baseUrl, path = null) {
-		let url = baseUrl.replace(/\/$/, ""); // Remove trailing slash from base URL
-		if (typeof path === 'string') {
-			if (path.substr(0, 1) !== '/') {
-				path = '/' + path; // Add leading slash to path
-			}
-			url = url + path.replace(/\/$/, ""); // Remove trailing slash from path
-		}
-		return url;
-	}
-
-	/**
-	 * Replaces placeholders in this format: `{var}`.
-	 * 
-	 * This can be used for the placeholders/variables in the openEO API's errors.json file.
-	 * 
-	 * @param {string} message - The string to replace the placeholders in.
-	 * @param {object} variables - A map with the placeholder names as keys and the replacement value as value.
-	 */
-	static replacePlaceholders(message, variables = {}) {
-		if (typeof message === 'string' && Utils.isObject(variables)) {
-			for(var placeholder in variables) {
-				let vars = variables[placeholder];
-				message = message.replace('{' + placeholder + '}', Array.isArray(vars) ? vars.join("; ") : vars);
-			}
-		}
-		return message;
-	}
-
-	/**
-	 * Compares two strings case-insensitive, including natural ordering for numbers.
-	 * 
-	 * @param {string} a 
-	 * @param {string} b 
-	 * @returns {integer} Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
-	 */
-    static compareStringCaseInsensitive(a, b) {
-        if (typeof a !== 'string') {
-            a = String(a);
-        }
-        if (typeof b !== 'string') {
-            b = String(b);
-        }
-        return a.localeCompare(b, undefined, {numeric: true, sensitivity: 'base'});
-    }
-
-	/**
-	 * Tries to make a string more readable by capitalizing it.
-	 * Only applies to words with more than two characters.
-	 * 
-	 * Supports converting from:
-	 * - Snake Case (abc_def => Abc Def)
-	 * - Kebab Case (abc-def => Abc Def)
-	 * - Camel Case (abcDef => Abc Def)
-	 * 
-	 * Doesn't capitalize if the words are not in any of the casing formats above.
-	 * 
-	 * @param {*} strings - String(s) to make readable
-	 * @param {string} arraySep - String to separate array elements with
-	 * @returns {string}
-	 */
-    static prettifyString(strings, arraySep = '; ') {
-		if (!Array.isArray(strings)) {
-			strings = [String(strings)];
-		}
-		strings = strings.map(str => {
-			if (str.length >= 3) {
-				const replacer = (_,a,b) => a + ' ' + b.toUpperCase();
-				if (str.includes('_')) {
-					// Snake case converter
-					str = str.replace(/([a-zA-Z\d])_([a-zA-Z\d])/g, replacer);
-				}
-				else if (str.includes('-')) {
-					// Kebab case converter
-					str = str.replace(/([a-zA-Z\d])-([a-zA-Z\d])/g, replacer);
-				}
-				else {
-					// Camelcase converter
-					str = str.replace(/([a-z])([A-Z])/g, replacer);
-				}
-				// Uppercase the first letter in the first word, too.
-				return str.charAt(0).toUpperCase() + str.substr(1);
-			}
-			return str;
-		});
-		return strings.join(arraySep);	
-    }
-
-	/**
-	 * Makes link lists from the openEO API more user-friendly.
-	 * 
-	 * Supports:
-	 * - Set a reasonable title, if not available. Make title more readable.
-	 * - Sorting by title (see `sort` parameter)
-	 * - Removing given relation types (`rel` property, see `ignoreRel` parameter)
-	 * 
-	 * @param {array} linkList - List of links
-	 * @param {boolean} sort - Enable/Disable sorting by title. Enabled (true) by default.
-	 * @param {array} ignoreRel - A list of rel types to remove. By default, removes the self links (rel type = `self`).
-	 * @returns {array}
-	 */
-    static friendlyLinks(linkList, sort = true, ignoreRel = ['self']) {
-        let links = [];
-        if (!Array.isArray(linkList)) {
-            return links;
-        }
-
-        for(let link of linkList) {
-            link = Object.assign({}, link); // Make sure to work on a copy
-            if (typeof link.rel === 'string' && ignoreRel.includes(link.rel.toLowerCase())) {
-                continue;
-            }
-            if (typeof link.title !== 'string' || link.title.length === 0) {
-                if (typeof link.rel === 'string' && link.rel.length > 1) {
-                    link.title = Utils.prettifyString(link.rel);
-                }
-                else {
-                    link.title = link.href.replace(/^https?:\/\/(www.)?/i, '').replace(/\/$/i, '');
-                }
-            }
-            links.push(link);
-        }
-        if (sort) {
-            links.sort((a, b) => Utils.compareStringCaseInsensitive(a.title, b.title));
-        }
-        return links;
-    }
-
-}
-
+var equal = __webpack_require__(252);
+
+/**
+ * General utilities
+ * 
+ * @class
+ */
+class Utils {
+
+	/**
+	 * Checks whether a variable is a real object or not.
+	 * 
+	 * This is a more strict version of `typeof x === 'object'` as this example would also succeeds for arrays and `null`.
+	 * This function only returns `true` for real objects and not for arrays, `null` or any other data types.
+	 * 
+	 * @param {*} obj - A variable to check.
+	 * @returns {boolean} - `true` is the given variable is an object, `false` otherwise.
+	 */
+	static isObject(obj) {
+		return (typeof obj === 'object' && obj === Object(obj) && !Array.isArray(obj));
+	}
+
+	/**
+	 * Checks whether a variable is a string and contains at least one character.
+	 * 
+	 * @param {*} string - A variable to check.
+	 * @returns {boolean} - `true` is the given variable is an string with length > 0, `false` otherwise.
+	 */
+	static hasText(string) {
+		return (typeof string === 'string' && string.length > 0);
+	}
+
+	/**
+	 * Performs a deep comparison between two values to determine if they are equivalent.
+	 * 
+	 * @param {*} x - The value to compare.
+	 * @param {*} y - The other value to compare.
+	 * @returns {boolean} - Returns true if the values are equivalent, else false.
+	 */
+	static equals(x, y) {
+		return equal(x, y);
+	}
+
+	/**
+	 * Creates an object composed of the picked object properties.
+	 * 
+	 * Returns a shallow copy!
+	 * 
+	 * @param {object} obj - The source object.
+	 * @param {string|array} toPick - The properties to pick.
+	 * @returns {object}
+	 */
+	static pickFromObject(obj, toPick) {
+		obj = Object(obj);
+		if (typeof toPick === 'string') {
+			toPick = [toPick];
+		}
+		const copy = {};
+		toPick.forEach(key => copy[key] = obj[key]);
+		return copy;
+	}
+
+	/**
+	 * This method creates an object composed of the own and inherited enumerable property paths of object that are not omitted.
+	 * 
+	 * Returns a shallow copy!
+	 * 
+	 * @param {object} obj - The source object.
+	 * @param {string|array} toOmit - The properties to omit.
+	 * @returns {object}
+	 */
+	static omitFromObject(obj, toOmit) {
+		obj = Object(obj);
+		if (typeof toOmit === 'string') {
+			toOmit = [toOmit];
+		}
+		var copy = Object.assign({}, obj);
+		for(let key of toOmit) {
+			delete copy[key];
+		}
+		return copy;
+	}
+
+	/**
+	 *  Creates an array of values by running each property of `object` thru function.
+	 * 
+	 * The function is invoked with three arguments: (value, key, object).
+	 * 
+	 * @param {object} obj 
+	 * @param {function} func 
+	 * @returns {object}
+	 */
+	static mapObject(obj, func) {
+		// Taken from lodash, see https://github.com/lodash/lodash/blob/master/mapObject.js
+		const props = Object.keys(obj);
+		const result = new Array(props.length);
+		props.forEach((key, index) => {
+			result[index] = func(obj[key], key, obj);
+		});
+		return result;
+	}
+
+	/**
+	 * Creates an object with the same keys as object and values generated by running each own enumerable string keyed property of object thru the function.
+	 * 
+	 * The function is invoked with three arguments: (value, key, object).
+	 * 
+	 * @param {object} obj 
+	 * @param {function} func 
+	 * @returns {object}
+	 */
+	static mapObjectValues(obj, func) {
+		// Taken from lodash, see https://github.com/lodash/lodash/blob/master/mapValue.js
+		obj = Object(obj);
+		const result = {};
+		Object.keys(obj).forEach((key) => {
+			result[key] = func(obj[key], key, obj);
+		});
+		return result;
+	}
+
+	/**
+	 * Creates a duplicate-free version of an array.
+	 * 
+	 * If useEquals is set to true, uses the `Utils.equals` function for comparison instead of 
+	 * the JS === operator. Thus, if the array contains objects, you likely want to set 
+	 * `useEquals` to `true`.
+	 * 
+	 * @param {array} array
+	 * @param {boolean} useEquals
+	 * @returns {array}
+	 */
+	static unique(array, useEquals = false) {
+		if (useEquals) {
+			return array.filter((s1, pos, arr) => arr.findIndex(s2 => Utils.equals(s1, s2)) === pos);
+		}
+		else {
+			return [...new Set(array)];
+		}
+	}
+	
+	/**
+	 * Computes the size of an array (number of array elements) or object (number of key-value-pairs).
+	 * 
+	 * Returns 0 for all other data types.
+	 * 
+	 * @param {*} obj 
+	 * @returns {integer}
+	 */
+	static size(obj) {
+		if (typeof obj === 'object' && obj !== null) {
+			if (Array.isArray(obj)) {
+				return obj.length;
+			}
+			else {
+				return Object.keys(obj).length;
+			}
+		}
+		return 0;
+	}
+
+	/**
+	 * Checks whether a variable is numeric.
+	 * 
+	 * Numeric is every string with numeric data or a number, excluding NaN and finite numbers.
+	 * 
+	 * @param {*} n - A variable to check.
+	 * @returns {boolean} - `true` is the given variable is numeric, `false` otherwise.
+	 */
+	static isNumeric(n) {
+		return !isNaN(parseFloat(n)) && isFinite(n);
+    }
+    
+    /**
+     * Deep clone for JSON-compatible data.
+     * 
+     * @param {*} x - The data to clone.
+     * @returns {*} - The cloned data.
+     */
+    static deepClone(x) {
+		return JSON.parse(JSON.stringify(x));
+    }
+
+	/**
+	 * Normalize a URL (mostly handling leading and trailing slashes).
+	 * 
+	 * @static
+	 * @param {string} baseUrl - The URL to normalize
+	 * @param {string} path - An optional path to add to the URL
+	 * @returns {string} Normalized URL.
+	 */
+	static normalizeUrl(baseUrl, path = null) {
+		let url = baseUrl.replace(/\/$/, ""); // Remove trailing slash from base URL
+		if (typeof path === 'string') {
+			if (path.substr(0, 1) !== '/') {
+				path = '/' + path; // Add leading slash to path
+			}
+			url = url + path.replace(/\/$/, ""); // Remove trailing slash from path
+		}
+		return url;
+	}
+
+	/**
+	 * Replaces placeholders in this format: `{var}`.
+	 * 
+	 * This can be used for the placeholders/variables in the openEO API's errors.json file.
+	 * 
+	 * @param {string} message - The string to replace the placeholders in.
+	 * @param {object} variables - A map with the placeholder names as keys and the replacement value as value.
+	 */
+	static replacePlaceholders(message, variables = {}) {
+		if (typeof message === 'string' && Utils.isObject(variables)) {
+			for(var placeholder in variables) {
+				let vars = variables[placeholder];
+				message = message.replace('{' + placeholder + '}', Array.isArray(vars) ? vars.join("; ") : vars);
+			}
+		}
+		return message;
+	}
+
+	/**
+	 * Compares two strings case-insensitive, including natural ordering for numbers.
+	 * 
+	 * @param {string} a 
+	 * @param {string} b 
+	 * @returns {integer} Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+	 */
+    static compareStringCaseInsensitive(a, b) {
+        if (typeof a !== 'string') {
+            a = String(a);
+        }
+        if (typeof b !== 'string') {
+            b = String(b);
+        }
+        return a.localeCompare(b, undefined, {numeric: true, sensitivity: 'base'});
+    }
+
+	/**
+	 * Tries to make a string more readable by capitalizing it.
+	 * Only applies to words with more than two characters.
+	 * 
+	 * Supports converting from:
+	 * - Snake Case (abc_def => Abc Def)
+	 * - Kebab Case (abc-def => Abc Def)
+	 * - Camel Case (abcDef => Abc Def)
+	 * 
+	 * Doesn't capitalize if the words are not in any of the casing formats above.
+	 * 
+	 * @param {*} strings - String(s) to make readable
+	 * @param {string} arraySep - String to separate array elements with
+	 * @returns {string}
+	 */
+    static prettifyString(strings, arraySep = '; ') {
+		if (!Array.isArray(strings)) {
+			strings = [String(strings)];
+		}
+		strings = strings.map(str => {
+			if (str.length >= 3) {
+				const replacer = (_,a,b) => a + ' ' + b.toUpperCase();
+				if (str.includes('_')) {
+					// Snake case converter
+					str = str.replace(/([a-zA-Z\d])_([a-zA-Z\d])/g, replacer);
+				}
+				else if (str.includes('-')) {
+					// Kebab case converter
+					str = str.replace(/([a-zA-Z\d])-([a-zA-Z\d])/g, replacer);
+				}
+				else {
+					// Camelcase converter
+					str = str.replace(/([a-z])([A-Z])/g, replacer);
+				}
+				// Uppercase the first letter in the first word, too.
+				return str.charAt(0).toUpperCase() + str.substr(1);
+			}
+			return str;
+		});
+		return strings.join(arraySep);	
+    }
+
+	/**
+	 * Makes link lists from the openEO API more user-friendly.
+	 * 
+	 * Supports:
+	 * - Set a reasonable title, if not available. Make title more readable.
+	 * - Sorting by title (see `sort` parameter)
+	 * - Removing given relation types (`rel` property, see `ignoreRel` parameter)
+	 * 
+	 * @param {array} linkList - List of links
+	 * @param {boolean} sort - Enable/Disable sorting by title. Enabled (true) by default.
+	 * @param {array} ignoreRel - A list of rel types to remove. By default, removes the self links (rel type = `self`).
+	 * @returns {array}
+	 */
+    static friendlyLinks(linkList, sort = true, ignoreRel = ['self']) {
+        let links = [];
+        if (!Array.isArray(linkList)) {
+            return links;
+        }
+
+        for(let link of linkList) {
+            link = Object.assign({}, link); // Make sure to work on a copy
+            if (typeof link.rel === 'string' && ignoreRel.includes(link.rel.toLowerCase())) {
+                continue;
+            }
+            if (typeof link.title !== 'string' || link.title.length === 0) {
+                if (typeof link.rel === 'string' && link.rel.length > 1) {
+                    link.title = Utils.prettifyString(link.rel);
+                }
+                else {
+                    link.title = link.href.replace(/^https?:\/\/(www.)?/i, '').replace(/\/$/i, '');
+                }
+            }
+            links.push(link);
+        }
+        if (sort) {
+            links.sort((a, b) => Utils.compareStringCaseInsensitive(a.title, b.title));
+        }
+        return links;
+    }
+
+}
+
 module.exports = Utils;
 
 /***/ }),
@@ -807,115 +807,115 @@ module.exports = Utils;
 /***/ 304:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const VersionCompare = __webpack_require__(246);
-
-/** Version Number related methods */
-class Versions {
-
-  /**
-   * Compare [semver](https://semver.org/) version strings.
-   * 
-   * @param {string} firstVersion First version to compare
-   * @param {string} secondVersion Second version to compare
-   * @param {string|null} operator Optional; Arithmetic operator to use (>, >=, =, <=, <, !=). Defaults to `null`.
-   * @returns {boolean|integer} If operator is not `null`: true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise. If operator is `null`: Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
-   * ```
-   */
-    static compare(v1, v2, operator = null) {
-		if (operator !== null) {
-			return VersionCompare.compare(v1, v2, operator);
-		}
-		else {
-			return VersionCompare(v1, v2);
-		}
-	}
-
-  /**
-   * Validate [semver](https://semver.org/) version strings.
-   * 
-   * @param {*} version - Version number to validate
-   * @returns - `true` if the version number is a valid semver version number, `false` otherwise.
-   */
-	static validate(version) {
-		return VersionCompare.validate(version);
-	}
-
-	/**
-	 * Tries to determine the most suitable version from a well-known discovery document that software is compatible to.
-	 * 
-	 * @static
-	 * @param {array} wkVersions - A well-known discovery document compliant to the API specification.
-	 * @param {boolean} preferProduction - Set to `false` to make no difference between production and non-production versions.
-	 * @param {string|null} minVersion - The minimum version that should be returned.
-	 * @param {string|null} maxVersion - The maximum version that should be returned.
-	 * @returns {object[]} - Gives a list that lists all compatible versions (as still API compliant objects) ordered from the most suitable to the least suitable.
-	 */
-	static findCompatible(wkVersions, preferProduction = true, minVersion = null, maxVersion = null) {
-		if (!Array.isArray(wkVersions) || wkVersions.length === 0) {
-			return [];
-		}
-
-		let compatible = wkVersions.filter(c => {
-			if (typeof c.url === 'string' && Versions.validate(c.api_version)) {
-				let hasMinVer = Versions.validate(minVersion);
-				let hasMaxVer = Versions.validate(maxVersion);
-				if (hasMinVer && hasMaxVer) {
-					return Versions.compare(c.api_version, minVersion, ">=") && Versions.compare(c.api_version, maxVersion, "<=");
-				}
-				else if (hasMinVer) {
-					return Versions.compare(c.api_version, minVersion, ">=");
-				}
-				else if (hasMaxVer) {
-					return Versions.compare(c.api_version, maxVersion, "<=");
-				}
-				else {
-					return true;
-				}
-			}
-			return false;
-		 });
-		if (compatible.length === 0) {
-			return [];
-		}
-
-		return compatible.sort((c1, c2) => {
-			let p1 = c1.production === true;
-			let p2 = c2.production === true;
-			if (!preferProduction || p1 === p2) {
-				return Versions.compare(c1.api_version, c2.api_version) * -1; // `* -1` to sort in descending order.
-			}
-			else if (p1) {
-				return -1;
-			}
-			else {
-				return 1;
-			}
-		});
-	}
-
-	/**
-	 * Find the latest version from well-known discovery that applies to the specified rules.
-	 * 
-	 * This is basically the same as calling `findCompatible` and using the first element from the result.
-	 * 
-	 * @param {array} wkVersions - A well-known discovery document compliant to the API specification.
-	 * @param {boolean} preferProduction - Set to `false` to make no difference between production and non-production versions.
-	 * @param {string|null} minVersion - The minimum version that should be returned.
-	 * @param {string|null} maxVersion - The maximum version that should be returned.
-	 * @returns {object|null}
-	 */
-	static findLatest(wkVersions, preferProduction = true, minVersion = null, maxVersion = null) {
-		let versions = Versions.findCompatible(wkVersions, preferProduction, minVersion, maxVersion);
-		if (versions.length > 0) {
-			return versions[0];
-		}
-		else {
-			return null;
-		}
-	}
-	
-}
-
+const { compare, compareVersions, validate } = __webpack_require__(385);
+
+/** Version Number related methods */
+class Versions {
+
+	/**
+	 * Compare [semver](https://semver.org/) version strings.
+	 * 
+	 * @param {string} firstVersion First version to compare
+	 * @param {string} secondVersion Second version to compare
+	 * @param {string|null} operator Optional; Arithmetic operator to use (>, >=, =, <=, <, !=). Defaults to `null`.
+	 * @returns {boolean|integer} If operator is not `null`: true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise. If operator is `null`: Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+	 * ```
+	 */
+	static compare(v1, v2, operator = null) {
+		if (operator !== null) {
+			return compare(v1, v2, operator);
+		}
+		else {
+			return compareVersions(v1, v2);
+		}
+	}
+
+	/**
+	 * Validate [semver](https://semver.org/) version strings.
+	 * 
+	 * @param {*} version - Version number to validate
+	 * @returns - `true` if the version number is a valid semver version number, `false` otherwise.
+	 */
+	static validate(version) {
+		return validate(version);
+	}
+
+	/**
+	 * Tries to determine the most suitable version from a well-known discovery document that software is compatible to.
+	 * 
+	 * @static
+	 * @param {array} wkVersions - A well-known discovery document compliant to the API specification.
+	 * @param {boolean} preferProduction - Set to `false` to make no difference between production and non-production versions.
+	 * @param {string|null} minVersion - The minimum version that should be returned.
+	 * @param {string|null} maxVersion - The maximum version that should be returned.
+	 * @returns {object[]} - Gives a list that lists all compatible versions (as still API compliant objects) ordered from the most suitable to the least suitable.
+	 */
+	static findCompatible(wkVersions, preferProduction = true, minVersion = null, maxVersion = null) {
+		if (!Array.isArray(wkVersions) || wkVersions.length === 0) {
+			return [];
+		}
+
+		let compatible = wkVersions.filter(c => {
+			if (typeof c.url === 'string' && Versions.validate(c.api_version)) {
+				let hasMinVer = Versions.validate(minVersion);
+				let hasMaxVer = Versions.validate(maxVersion);
+				if (hasMinVer && hasMaxVer) {
+					return Versions.compare(c.api_version, minVersion, ">=") && Versions.compare(c.api_version, maxVersion, "<=");
+				}
+				else if (hasMinVer) {
+					return Versions.compare(c.api_version, minVersion, ">=");
+				}
+				else if (hasMaxVer) {
+					return Versions.compare(c.api_version, maxVersion, "<=");
+				}
+				else {
+					return true;
+				}
+			}
+			return false;
+		 });
+		if (compatible.length === 0) {
+			return [];
+		}
+
+		return compatible.sort((c1, c2) => {
+			let p1 = c1.production === true;
+			let p2 = c2.production === true;
+			if (!preferProduction || p1 === p2) {
+				return Versions.compare(c1.api_version, c2.api_version) * -1; // `* -1` to sort in descending order.
+			}
+			else if (p1) {
+				return -1;
+			}
+			else {
+				return 1;
+			}
+		});
+	}
+
+	/**
+	 * Find the latest version from well-known discovery that applies to the specified rules.
+	 * 
+	 * This is basically the same as calling `findCompatible` and using the first element from the result.
+	 * 
+	 * @param {array} wkVersions - A well-known discovery document compliant to the API specification.
+	 * @param {boolean} preferProduction - Set to `false` to make no difference between production and non-production versions.
+	 * @param {string|null} minVersion - The minimum version that should be returned.
+	 * @param {string|null} maxVersion - The maximum version that should be returned.
+	 * @returns {object|null}
+	 */
+	static findLatest(wkVersions, preferProduction = true, minVersion = null, maxVersion = null) {
+		let versions = Versions.findCompatible(wkVersions, preferProduction, minVersion, maxVersion);
+		if (versions.length > 0) {
+			return versions[0];
+		}
+		else {
+			return null;
+		}
+	}
+	
+}
+
 module.exports = Versions;
 
 /***/ }),
@@ -927,7 +927,7 @@ module.exports = Versions;
 // see https://github.com/stac-utils/pystac/tree/v0.5.4/pystac/serialization/migrate.py
 // and https://github.com/Open-EO/openeo-js-commons/tree/v1.2.0/src/migrate/collections.js
 
-var compareVersions = __webpack_require__(246);
+var compareVersions = __webpack_require__(139);
 
 const LATEST_VERSION = '1.0.0';
 const DONE = true; // This is used to verify in code coverage whether something has been used or not
@@ -1899,34 +1899,155 @@ module.exports = Migrate;
 
 /***/ }),
 
-/***/ 147:
-/***/ ((module) => {
+/***/ 139:
+/***/ (function(module, exports) {
 
-/**
- * The base class for authentication providers such as Basic and OpenID Connect.
- * 
- * @abstract
- */
-class AuthProvider {
-  /**
-   * Creates a new OidcProvider instance to authenticate using OpenID Connect.
-   * 
-   * @param {string} type - The type of the authentication procedure as specified by the API, e.g. `oidc` or `basic`.
-   * @param {Connection} connection - A Connection object representing an established connection to an openEO back-end.
-   * @param {AuthProviderMeta} options - Options
-   */
-  constructor(type, connection, options) {
-    this.id = options.id || null;
-    this.title = options.title || "";
-    this.description = options.description || "";
-    this.type = type;
-    /**
-     * @protected
-     * @type {Connection}
-     */
-    this.connection = connection;
-    this.token = null;
-  }
+var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* global define */
+(function (root, factory) {
+  /* istanbul ignore next */
+  if (true) {
+    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
+		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+  } else {}
+}(this, function () {
+
+  var semver = /^v?(?:\d+)(\.(?:[x*]|\d+)(\.(?:[x*]|\d+)(\.(?:[x*]|\d+))?(?:-[\da-z\-]+(?:\.[\da-z\-]+)*)?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+
+  function indexOrEnd(str, q) {
+    return str.indexOf(q) === -1 ? str.length : str.indexOf(q);
+  }
+
+  function split(v) {
+    var c = v.replace(/^v/, '').replace(/\+.*$/, '');
+    var patchIndex = indexOrEnd(c, '-');
+    var arr = c.substring(0, patchIndex).split('.');
+    arr.push(c.substring(patchIndex + 1));
+    return arr;
+  }
+
+  function tryParse(v) {
+    return isNaN(Number(v)) ? v : Number(v);
+  }
+
+  function validate(version) {
+    if (typeof version !== 'string') {
+      throw new TypeError('Invalid argument expected string');
+    }
+    if (!semver.test(version)) {
+      throw new Error('Invalid argument not valid semver (\''+version+'\' received)');
+    }
+  }
+
+  function compareVersions(v1, v2) {
+    [v1, v2].forEach(validate);
+
+    var s1 = split(v1);
+    var s2 = split(v2);
+
+    for (var i = 0; i < Math.max(s1.length - 1, s2.length - 1); i++) {
+      var n1 = parseInt(s1[i] || 0, 10);
+      var n2 = parseInt(s2[i] || 0, 10);
+
+      if (n1 > n2) return 1;
+      if (n2 > n1) return -1;
+    }
+
+    var sp1 = s1[s1.length - 1];
+    var sp2 = s2[s2.length - 1];
+
+    if (sp1 && sp2) {
+      var p1 = sp1.split('.').map(tryParse);
+      var p2 = sp2.split('.').map(tryParse);
+
+      for (i = 0; i < Math.max(p1.length, p2.length); i++) {
+        if (p1[i] === undefined || typeof p2[i] === 'string' && typeof p1[i] === 'number') return -1;
+        if (p2[i] === undefined || typeof p1[i] === 'string' && typeof p2[i] === 'number') return 1;
+
+        if (p1[i] > p2[i]) return 1;
+        if (p2[i] > p1[i]) return -1;
+      }
+    } else if (sp1 || sp2) {
+      return sp1 ? -1 : 1;
+    }
+
+    return 0;
+  };
+
+  var allowedOperators = [
+    '>',
+    '>=',
+    '=',
+    '<',
+    '<='
+  ];
+
+  var operatorResMap = {
+    '>': [1],
+    '>=': [0, 1],
+    '=': [0],
+    '<=': [-1, 0],
+    '<': [-1]
+  };
+
+  function validateOperator(op) {
+    if (typeof op !== 'string') {
+      throw new TypeError('Invalid operator type, expected string but got ' + typeof op);
+    }
+    if (allowedOperators.indexOf(op) === -1) {
+      throw new TypeError('Invalid operator, expected one of ' + allowedOperators.join('|'));
+    }
+  }
+
+  compareVersions.validate = function(version) {
+    return typeof version === 'string' && semver.test(version);
+  }
+
+  compareVersions.compare = function (v1, v2, operator) {
+    // Validate operator
+    validateOperator(operator);
+
+    // since result of compareVersions can only be -1 or 0 or 1
+    // a simple map can be used to replace switch
+    var res = compareVersions(v1, v2);
+    return operatorResMap[operator].indexOf(res) > -1;
+  }
+
+  return compareVersions;
+}));
+
+
+/***/ }),
+
+/***/ 147:
+/***/ ((module) => {
+
+/**
+ * The base class for authentication providers such as Basic and OpenID Connect.
+ * 
+ * @abstract
+ */
+class AuthProvider {
+  /**
+   * Creates a new OidcProvider instance to authenticate using OpenID Connect.
+   * 
+   * @param {string} type - The type of the authentication procedure as specified by the API, e.g. `oidc` or `basic`.
+   * @param {Connection} connection - A Connection object representing an established connection to an openEO back-end.
+   * @param {AuthProviderMeta} options - Options
+   */
+  constructor(type, connection, options) {
+    this.id = options.id || null;
+    this.title = options.title || "";
+    this.description = options.description || "";
+    this.type = type;
+    /**
+     * @protected
+     * @type {Connection}
+     */
+    this.connection = connection;
+    this.token = null;
+  }
 
   /**
    * Get an identifier for the auth provider (combination of the type + provider identifier).
@@ -4101,6 +4222,52 @@ class Capabilities {
     return Array.isArray(this.data.links) ? this.data.links : [];
   }
 
+  /**
+   * Returns list of backends in the federation.
+   * 
+   * @returns {Array.<FederationBackend>} Array of backends
+   */
+  listFederation() {
+    let federation = [];
+    if (Utils.isObject(this.data.federation)) {
+      // convert to array and add keys as `id` property
+      for (const [key, backend] of Object.entries(this.data.federation)) {
+        // fresh object to avoid `id` showing up in this.data.federation
+        federation.push({
+          id: key,
+          ...backend
+        });
+      }
+    }
+    return federation;
+  }
+
+  /**
+   * Given just the string ID of a backend within the federation, returns that backend's full details as a FederationBackend object.
+   * 
+   * @param {string} backendId - The ID of a backend within the federation
+   * @returns {FederationBackend} The full details of the backend
+   */
+  getFederationBackend(backendId) {
+    // Add `id` property to make it a proper FederationBackend object
+    // If backendId doesn't exist in this.data.federation, will contain just the `id` field (intended behaviour)
+    return {
+      id: backendId,
+      ...this.data.federation[backendId]
+    };
+  }
+
+  /**
+   * Given a list of string IDs of backends within the federation, returns those backends' full details as FederationBackend objects.
+   * 
+   * @param {Array<string>} backendIds - The IDs of backends within the federation
+   * @returns {Array<FederationBackend>} An array in the same order as the input, containing for each position the full details of the backend
+   */
+  getFederationBackends(backendIds) {
+    // Let 'single case' function do the work, but pass `this` so that `this.data.federation` can be accessed in the callback context
+    return backendIds.map(this.getFederationBackend, this);
+  }
+
   /**
    * Lists all supported features.
    * 
@@ -4193,6 +4360,14 @@ const UserProcess = __webpack_require__(806);
 const Service = __webpack_require__(497);
 const Builder = __webpack_require__(425);
 const BuilderNode = __webpack_require__(804);
+const {
+  CollectionPages,
+  ItemPages,
+  JobPages,
+  ProcessPages,
+  ServicePages,
+  UserFilePages
+} = __webpack_require__(226);
 const CONFORMANCE_RELS = ['conformance', 'http://www.opengis.net/def/rel/ogc/1.0/conformance'];
 
 /**
@@ -4277,13 +4452,13 @@ class Connection {
    * @throws {Error}
    */
   async init() {
-    let response = await this._get('/');
-    let data = Object.assign({}, response.data);
+    const response = await this._get('/');
+    const data = Object.assign({}, response.data);
     data.links = this.makeLinksAbsolute(data.links, response);
     if (!Array.isArray(data.conformsTo) && Array.isArray(data.links)) {
-      let conformanceLink = this._getLinkHref(data.links, CONFORMANCE_RELS);
+      const conformanceLink = this._getLinkHref(data.links, CONFORMANCE_RELS);
       if (conformanceLink) {
-        let response2 = await this._get(conformanceLink);
+        const response2 = await this._get(conformanceLink);
         if (Utils.isObject(response2.data) && Array.isArray(response2.data.conformsTo)) {
           data.conformsTo = response2.data.conformsTo;
         }
@@ -4304,10 +4479,10 @@ class Connection {
     if (this.processes.count() === 0) {
       return;
     }
-    let promises = this.processes.namespaces().map(namespace => {
+    const promises = this.processes.namespaces().map(namespace => {
       let fn = () => Promise.resolve();
       if (namespace === 'user') {
-        let userProcesses = this.processes.namespace('user');
+        const userProcesses = this.processes.namespace('user');
         if (!this.isAuthenticated()) {
           fn = () => this.processes.remove(null, 'user') ? Promise.resolve() : Promise.reject(new Error("Can't clear user processes"));
         } else if (this.capabilities().hasFeature('listUserProcesses')) {
@@ -4356,7 +4531,7 @@ class Connection {
    * @throws {Error}
    */
   async listFileTypes() {
-    let response = await this._get('/file_formats');
+    const response = await this._get('/file_formats');
     return new FileTypes(response.data);
   }
 
@@ -4368,7 +4543,7 @@ class Connection {
    * @throws {Error}
    */
   async listServiceTypes() {
-    let response = await this._get('/service_types');
+    const response = await this._get('/service_types');
     return response.data;
   }
 
@@ -4380,7 +4555,7 @@ class Connection {
    * @throws {Error}
    */
   async listUdfRuntimes() {
-    let response = await this._get('/udf_runtimes');
+    const response = await this._get('/udf_runtimes');
     return response.data;
   }
 
@@ -4388,22 +4563,27 @@ class Connection {
    * List all collections available on the back-end.
    * 
    * The collections returned always comply to the latest STAC version (currently 1.0.0). 
+   * This function adds a self link to the response if not present.
    * 
    * @async
    * @returns {Promise<Collections>} A response compatible to the API specification.
    * @throws {Error}
    */
   async listCollections() {
-    let response = await this._get('/collections');
-    if (Utils.isObject(response.data) && Array.isArray(response.data.collections)) {
-      response.data.collections = response.data.collections.map(collection => {
-        if (collection.stac_version) {
-          return StacMigrate.collection(collection);
-        }
-        return collection;
-      });
-    }
-    return response.data;
+    const pages = this.paginateCollections(null);
+    return await pages.nextPage([], false);
+  }
+
+  /**
+   * Paginate through the collections available on the back-end.
+   * 
+   * The collections returned always comply to the latest STAC version (currently 1.0.0).
+   * 
+   * @param {?number} [limit=50] - The number of collections per request/page as integer. If `null`, requests all collections.
+   * @returns {CollectionPages} A paged list of collections.
+   */
+  paginateCollections(limit = 50) {
+    return new CollectionPages(this, limit);
   }
 
   /**
@@ -4417,7 +4597,7 @@ class Connection {
    * @throws {Error}
    */
   async describeCollection(collectionId) {
-    let response = await this._get('/collections/' + collectionId);
+    const response = await this._get('/collections/' + collectionId);
     if (response.data.stac_version) {
       return StacMigrate.collection(response.data);
     } else {
@@ -4426,13 +4606,12 @@ class Connection {
   }
 
   /**
-   * Loads items for a specific image collection.
+   * Paginate through items for a specific collection.
+   * 
    * May not be available for all collections.
    * 
    * The items returned always comply to the latest STAC version (currently 1.0.0). 
    * 
-   * This is an experimental API and is subject to change.
-   * 
    * @async
    * @param {string} collectionId - Collection ID to request items for.
    * @param {?Array.<number>} [spatialExtent=null] - Limits the items to the given bounding box in WGS84:
@@ -4445,46 +4624,28 @@ class Connection {
    * each must be either an RFC 3339 compatible string or a Date object.
    * Also supports open intervals by setting one of the boundaries to `null`, but never both.
    * @param {?number} [limit=null] - The amount of items per request/page as integer. If `null` (default), the back-end decides.
-   * @yields {Promise<ItemCollection>} A response compatible to the API specification.
+   * @returns {Promise<ItemPages>} A response compatible to the API specification.
    * @throws {Error}
    */
-  async *listCollectionItems(collectionId, spatialExtent = null, temporalExtent = null, limit = null) {
-    let page = 1;
-    let nextUrl = '/collections/' + collectionId + '/items';
-    while (nextUrl) {
-      let params = {};
-      if (page === 1) {
-        if (Array.isArray(spatialExtent)) {
-          params.bbox = spatialExtent.join(',');
-        }
-        if (Array.isArray(temporalExtent)) {
-          params.datetime = temporalExtent.map(e => {
-            if (e instanceof Date) {
-              return e.toISOString();
-            } else if (typeof e === 'string') {
-              return e;
-            }
-            return '..'; // Open date range
-          }).join('/');
+  listCollectionItems(collectionId, spatialExtent = null, temporalExtent = null, limit = null) {
+    let params = {};
+    if (Array.isArray(spatialExtent)) {
+      params.bbox = spatialExtent.join(',');
+    }
+    if (Array.isArray(temporalExtent)) {
+      params.datetime = temporalExtent.map(e => {
+        if (e instanceof Date) {
+          return e.toISOString();
+        } else if (typeof e === 'string') {
+          return e;
         }
-        if (limit > 0) {
-          params.limit = limit;
-        }
-      }
-      let response = await this._get(nextUrl, params);
-      if (Utils.isObject(response.data) && Array.isArray(response.data.features)) {
-        response.data.features = response.data.features.map(item => {
-          if (item.stac_version) {
-            return StacMigrate.item(item);
-          }
-          return item;
-        });
-      }
-      yield response.data;
-      page++;
-      let links = this.makeLinksAbsolute(response.data.links);
-      nextUrl = this._getLinkHref(links, 'next');
+        return '..'; // Open date range
+      }).join('/');
+    }
+    if (limit > 0) {
+      params.limit = limit;
     }
+    return new ItemPages(this, collectionId, params, limit);
   }
 
   /**
@@ -4507,7 +4668,7 @@ class Connection {
   }
 
   /**
-   * List processes available on the back-end.
+   * List all processes available on the back-end.
    * 
    * Requests pre-defined processes by default.
    * Set the namespace parameter to request processes from a specific namespace.
@@ -4515,27 +4676,33 @@ class Connection {
    * Note: The list of namespaces can be retrieved by calling `listProcesses` without a namespace given.
    * The namespaces are then listed in the property `namespaces`.
    * 
+   * This function adds a self link to the response if not present.
+   * 
    * @async
    * @param {?string} [namespace=null] - Namespace of the processes (default to `null`, i.e. pre-defined processes). EXPERIMENTAL!
    * @returns {Promise<Processes>} - A response compatible to the API specification.
    * @throws {Error}
    */
   async listProcesses(namespace = null) {
-    if (!namespace) {
-      namespace = 'backend';
-    }
-    let path = namespace === 'backend' ? '/processes' : `/processes/${this.normalizeNamespace(namespace)}`;
-    let response = await this._get(path);
-    if (!Utils.isObject(response.data) || !Array.isArray(response.data.processes)) {
-      throw new Error('Invalid response received for processes');
-    }
+    const pages = this.paginateProcesses(namespace);
+    return await pages.nextPage([], false);
+  }
 
-    // Store processes in cache
-    this.processes.remove(null, namespace);
-    this.processes.addAll(response.data.processes, namespace);
-    return Object.assign(response.data, {
-      processes: this.processes.namespace(namespace)
-    });
+  /**
+   * Paginate through the processes available on the back-end.
+   * 
+   * Requests pre-defined processes by default.
+   * Set the namespace parameter to request processes from a specific namespace.
+   * 
+   * Note: The list of namespaces can be retrieved by calling `listProcesses` without a namespace given.
+   * The namespaces are then listed in the property `namespaces`.
+   * 
+   * @param {?string} [namespace=null] - Namespace of the processes (default to `null`, i.e. pre-defined processes). EXPERIMENTAL!
+   * @param {?number} [limit=50] - The number of processes per request/page as integer. If `null`, requests all processes.
+   * @returns {ProcessPages} A paged list of processes.
+   */
+  paginateProcesses(namespace = null, limit = 50) {
+    return new ProcessPages(this, limit, namespace);
   }
 
   /**
@@ -4555,7 +4722,7 @@ class Connection {
     if (namespace === 'backend') {
       await this.listProcesses();
     } else {
-      let response = await this._get(`/processes/${this.normalizeNamespace(namespace)}/${processId}`);
+      const response = await this._get(`/processes/${this.normalizeNamespace(namespace)}/${processId}`);
       if (!Utils.isObject(response.data) || typeof response.data.id !== 'string') {
         throw new Error('Invalid response received for process');
       }
@@ -4591,15 +4758,15 @@ class Connection {
       return this.authProviderList;
     }
     this.authProviderList = [];
-    let cap = this.capabilities();
+    const cap = this.capabilities();
 
     // Add OIDC providers
     if (cap.hasFeature('authenticateOIDC')) {
-      let res = await this._get('/credentials/oidc');
-      let oidcFactory = this.getOidcProviderFactory();
+      const res = await this._get('/credentials/oidc');
+      const oidcFactory = this.getOidcProviderFactory();
       if (Utils.isObject(res.data) && Array.isArray(res.data.providers) && typeof oidcFactory === 'function') {
         for (let i in res.data.providers) {
-          let obj = oidcFactory(res.data.providers[i]);
+          const obj = oidcFactory(res.data.providers[i]);
           if (obj instanceof AuthProvider) {
             this.authProviderList.push(obj);
           }
@@ -4677,7 +4844,7 @@ class Connection {
    * @see Connection#listAuthProviders
    */
   async authenticateBasic(username, password) {
-    let basic = new BasicProvider(this);
+    const basic = new BasicProvider(this);
     await basic.login(username, password);
   }
 
@@ -4770,7 +4937,7 @@ class Connection {
    * @returns {AuthProvider}
    */
   setAuthToken(type, providerId, token) {
-    let provider = new AuthProvider(type, this, {
+    const provider = new AuthProvider(type, this, {
       id: providerId,
       title: "Custom",
       description: ""
@@ -4790,21 +4957,30 @@ class Connection {
    * @throws {Error}
    */
   async describeAccount() {
-    let response = await this._get('/me');
+    const response = await this._get('/me');
     return response.data;
   }
 
   /**
-   * Lists all files from the user workspace. 
+   * List all files from the user workspace. 
    * 
    * @async
    * @returns {Promise<ResponseArray.<UserFile>>} A list of files.
    * @throws {Error}
    */
   async listFiles() {
-    let response = await this._get('/files');
-    let files = response.data.files.map(f => new UserFile(this, f.path).setAll(f));
-    return this._toResponseArray(files, response.data);
+    const pages = this.paginateFiles(null);
+    return await pages.nextPage();
+  }
+
+  /**
+   * Paginate through the files from the user workspace. 
+   * 
+   * @param {?number} [limit=50] - The number of files per request/page as integer. If `null`, requests all files.
+   * @returns {ServicePages} A paged list of files.
+   */
+  paginateFiles(limit = 50) {
+    return new UserFilePages(this, limit);
   }
 
   /**
@@ -4835,7 +5011,7 @@ class Connection {
     if (targetPath === null) {
       targetPath = Environment.fileNameForUpload(source);
     }
-    let file = await this.getFile(targetPath);
+    const file = await this.getFile(targetPath);
     return await file.uploadFile(source, statusCallback, abortController);
   }
 
@@ -4881,20 +5057,22 @@ class Connection {
    * 
    * @async
    * @param {Process} process - User-defined process to validate.
-   * @returns {Promise<Array.<ApiError>>} errors - A list of API compatible error objects. A valid process returns an empty list.
+   * @returns {Promise<ValidationResult>} errors - A list of API compatible error objects. A valid process returns an empty list.
    * @throws {Error}
    */
   async validateProcess(process) {
-    let response = await this._post('/validation', this._normalizeUserProcess(process).process);
+    const response = await this._post('/validation', this._normalizeUserProcess(process).process);
     if (Array.isArray(response.data.errors)) {
-      return response.data.errors;
+      const errors = response.data.errors;
+      errors['federation:backends'] = Array.isArray(response.data['federation:missing']) ? response.data['federation:missing'] : [];
+      return errors;
     } else {
       throw new Error("Invalid validation response received.");
     }
   }
 
   /**
-   * Lists all user-defined processes of the authenticated user.
+   * List all user-defined processes of the authenticated user.
    * 
    * @async
    * @param {Array.<UserProcess>} [oldProcesses=[]] - A list of existing user-defined processes to update.
@@ -4902,27 +5080,18 @@ class Connection {
    * @throws {Error}
    */
   async listUserProcesses(oldProcesses = []) {
-    let response = await this._get('/process_graphs');
-    if (!Utils.isObject(response.data) || !Array.isArray(response.data.processes)) {
-      throw new Error('Invalid response received for processes');
-    }
-
-    // Remove existing processes from cache
-    this.processes.remove(null, 'user');
-
-    // Update existing processes if needed
-    let newProcesses = response.data.processes.map(newProcess => {
-      let process = oldProcesses.find(oldProcess => oldProcess.id === newProcess.id);
-      if (!process) {
-        process = new UserProcess(this, newProcess.id);
-      }
-      return process.setAll(newProcess);
-    });
+    const pages = this.paginateUserProcesses(null);
+    return await pages.nextPage(oldProcesses);
+  }
 
-    // Store plain JS variant (i.e. no Job objects involved) of processes in cache
-    let jsonProcesses = oldProcesses.length > 0 ? newProcesses.map(p => p.toJSON()) : response.data.processes;
-    this.processes.addAll(jsonProcesses, 'user');
-    return this._toResponseArray(newProcesses, response.data);
+  /**
+   * Paginates through the user-defined processes of the authenticated user.
+   * 
+   * @param {?number} [limit=50] - The number of processes per request/page as integer. If `null`, requests all processes.
+   * @returns {ProcessPages} A paged list of user-defined processes.
+   */
+  paginateUserProcesses(limit = 50) {
+    return this.paginateProcesses('user', limit);
   }
 
   /**
@@ -4935,7 +5104,7 @@ class Connection {
    * @throws {Error}
    */
   async setUserProcess(id, process) {
-    let pg = new UserProcess(this, id);
+    const pg = new UserProcess(this, id);
     return await pg.replaceUserProcess(process);
   }
 
@@ -4948,7 +5117,7 @@ class Connection {
    * @throws {Error}
    */
   async getUserProcess(id) {
-    let pg = new UserProcess(this, id);
+    const pg = new UserProcess(this, id);
     return await pg.describeUserProcess();
   }
 
@@ -4966,12 +5135,12 @@ class Connection {
    * @returns {Promise<SyncResult>} - An object with the data and some metadata.
    */
   async computeResult(process, plan = null, budget = null, abortController = null, additional = {}) {
-    let requestBody = this._normalizeUserProcess(process, Object.assign({}, additional, {
+    const requestBody = this._normalizeUserProcess(process, Object.assign({}, additional, {
       plan: plan,
       budget: budget
     }));
-    let response = await this._post('/result', requestBody, Environment.getResponseType(), abortController);
-    let syncResult = {
+    const response = await this._post('/result', requestBody, Environment.getResponseType(), abortController);
+    const syncResult = {
       data: response.data,
       costs: null,
       type: null,
@@ -4983,15 +5152,15 @@ class Connection {
     if (typeof response.headers['content-type'] === 'string') {
       syncResult.type = response.headers['content-type'];
     }
-    let links = Array.isArray(response.headers.link) ? response.headers.link : [response.headers.link];
+    const links = Array.isArray(response.headers.link) ? response.headers.link : [response.headers.link];
     for (let link of links) {
       if (typeof link !== 'string') {
         continue;
       }
-      let logs = link.match(/^<([^>]+)>;\s?rel="monitor"/i);
+      const logs = link.match(/^<([^>]+)>;\s?rel="monitor"/i);
       if (Array.isArray(logs) && logs.length > 1) {
         try {
-          let logsResponse = await this._get(logs[1]);
+          const logsResponse = await this._get(logs[1]);
           if (Utils.isObject(logsResponse.data) && Array.isArray(logsResponse.data.logs)) {
             syncResult.logs = logsResponse.data.logs;
           }
@@ -5021,13 +5190,13 @@ class Connection {
    * @throws {Error}
    */
   async downloadResult(process, targetPath, plan = null, budget = null, abortController = null) {
-    let response = await this.computeResult(process, plan, budget, abortController);
+    const response = await this.computeResult(process, plan, budget, abortController);
     // @ts-ignore
     await Environment.saveToFile(response.data, targetPath);
   }
 
   /**
-   * Lists all batch jobs of the authenticated user.
+   * List all batch jobs of the authenticated user.
    * 
    * @async
    * @param {Array.<Job>} [oldJobs=[]] - A list of existing jobs to update.
@@ -5035,15 +5204,19 @@ class Connection {
    * @throws {Error}
    */
   async listJobs(oldJobs = []) {
-    let response = await this._get('/jobs');
-    let newJobs = response.data.jobs.map(newJob => {
-      let job = oldJobs.find(oldJob => oldJob.id === newJob.id);
-      if (!job) {
-        job = new Job(this, newJob.id);
-      }
-      return job.setAll(newJob);
-    });
-    return this._toResponseArray(newJobs, response.data);
+    const pages = this.paginateJobs(null);
+    const firstPage = await pages.nextPage(oldJobs);
+    return firstPage;
+  }
+
+  /**
+   * Paginate through the batch jobs of the authenticated user.
+   * 
+   * @param {?number} [limit=50] - The number of jobs per request/page as integer. If `null`, requests all jobs.
+   * @returns {JobPages} A paged list of jobs.
+   */
+  paginateJobs(limit = 50) {
+    return new JobPages(this, limit);
   }
 
   /**
@@ -5066,12 +5239,12 @@ class Connection {
       plan: plan,
       budget: budget
     });
-    let requestBody = this._normalizeUserProcess(process, additional);
-    let response = await this._post('/jobs', requestBody);
+    const requestBody = this._normalizeUserProcess(process, additional);
+    const response = await this._post('/jobs', requestBody);
     if (typeof response.headers['openeo-identifier'] !== 'string') {
       throw new Error("Response did not contain a Job ID. Job has likely been created, but may not show up yet.");
     }
-    let job = new Job(this, response.headers['openeo-identifier']).setAll(requestBody);
+    const job = new Job(this, response.headers['openeo-identifier']).setAll(requestBody);
     if (this.capabilities().hasFeature('describeJob')) {
       return await job.describeJob();
     } else {
@@ -5088,12 +5261,12 @@ class Connection {
    * @throws {Error}
    */
   async getJob(id) {
-    let job = new Job(this, id);
+    const job = new Job(this, id);
     return await job.describeJob();
   }
 
   /**
-   * Lists all secondary web services of the authenticated user.
+   * List all secondary web services of the authenticated user.
    * 
    * @async
    * @param {Array.<Service>} [oldServices=[]] - A list of existing services to update.
@@ -5101,15 +5274,18 @@ class Connection {
    * @throws {Error}
    */
   async listServices(oldServices = []) {
-    let response = await this._get('/services');
-    let newServices = response.data.services.map(newService => {
-      let service = oldServices.find(oldService => oldService.id === newService.id);
-      if (!service) {
-        service = new Service(this, newService.id);
-      }
-      return service.setAll(newService);
-    });
-    return this._toResponseArray(newServices, response.data);
+    const pages = this.paginateServices(null);
+    return await pages.nextPage(oldServices);
+  }
+
+  /**
+   * Paginate through the secondary web services of the authenticated user.
+   * 
+   * @param {?number} [limit=50] - The number of services per request/page as integer. If `null` (default), requests all services.
+   * @returns {ServicePages} A paged list of services.
+   */
+  paginateServices(limit = 50) {
+    return new ServicePages(this, limit);
   }
 
   /**
@@ -5129,7 +5305,7 @@ class Connection {
    * @throws {Error}
    */
   async createService(process, type, title = null, description = null, enabled = true, configuration = {}, plan = null, budget = null, additional = {}) {
-    let requestBody = this._normalizeUserProcess(process, Object.assign({
+    const requestBody = this._normalizeUserProcess(process, Object.assign({
       title: title,
       description: description,
       type: type,
@@ -5138,11 +5314,11 @@ class Connection {
       plan: plan,
       budget: budget
     }, additional));
-    let response = await this._post('/services', requestBody);
+    const response = await this._post('/services', requestBody);
     if (typeof response.headers['openeo-identifier'] !== 'string') {
       throw new Error("Response did not contain a Service ID. Service has likely been created, but may not show up yet.");
     }
-    let service = new Service(this, response.headers['openeo-identifier']).setAll(requestBody);
+    const service = new Service(this, response.headers['openeo-identifier']).setAll(requestBody);
     if (this.capabilities().hasFeature('describeService')) {
       return service.describeService();
     } else {
@@ -5159,26 +5335,10 @@ class Connection {
    * @throws {Error}
    */
   async getService(id) {
-    let service = new Service(this, id);
+    const service = new Service(this, id);
     return await service.describeService();
   }
 
-  /**
-   * Adds additional response details to the array.
-   * 
-   * Adds links and federation:missing.
-   * 
-   * @protected
-   * @param {Array.<*>} arr 
-   * @param {object.<string, *>} response 
-   * @returns {ResponseArray}
-   */
-  _toResponseArray(arr, response) {
-    arr.links = Array.isArray(response.links) ? response.links : [];
-    arr['federation:missing'] = Array.isArray(response['federation:missing']) ? response['federation:missing'] : [];
-    return arr;
-  }
-
   /**
    * Get the a link with the given rel type.
    * 
@@ -5193,7 +5353,7 @@ class Connection {
       rel = [rel];
     }
     if (Array.isArray(links)) {
-      let link = links.find(l => Utils.isObject(l) && rel.includes(l.rel) && typeof l.href === 'string');
+      const link = links.find(l => Utils.isObject(l) && rel.includes(l.rel) && typeof l.href === 'string');
       if (link) {
         return link.href;
       }
@@ -5229,7 +5389,7 @@ class Connection {
         return link;
       }
       try {
-        let url = new URL(link.href, baseUrl);
+        const url = new URL(link.href, baseUrl);
         return Object.assign({}, link, {
           href: url.toString()
         });
@@ -5278,7 +5438,7 @@ class Connection {
    * @see https://github.com/axios/axios#request-config
    */
   async _post(path, body, responseType, abortController = null) {
-    let options = {
+    const options = {
       method: 'post',
       responseType: responseType,
       url: path,
@@ -5350,7 +5510,7 @@ class Connection {
    * @throws {Error}
    */
   async download(url, authorize) {
-    let result = await this._send({
+    const result = await this._send({
       method: 'get',
       responseType: Environment.getResponseType(),
       url: url,
@@ -5409,7 +5569,7 @@ class Connection {
     }
     try {
       let response = await axios(options);
-      let capabilities = this.capabilities();
+      const capabilities = this.capabilities();
       if (capabilities) {
         response = capabilities.migrate(response);
       }
@@ -5433,7 +5593,7 @@ class Connection {
         // See: https://github.com/axios/axios/issues/815
         if (options.responseType === Environment.getResponseType()) {
           try {
-            let errorResponse = await Environment.handleErrorResponse(error);
+            const errorResponse = await Environment.handleErrorResponse(error);
             throw enrichError(error, errorResponse);
           } catch (error2) {
             console.error(error2);
@@ -5909,9 +6069,26 @@ class Logs {
      * @type {Connection}
      */
     this.connection = connection;
+    /**
+     * @protected
+     * @type {string}
+     */
     this.endpoint = endpoint;
+    /**
+     * @protected
+     * @type {string}
+     */
     this.lastId = "";
+    /**
+     * @protected
+     * @type {?string}
+     */
     this.level = level;
+    /**
+     * @protected
+     * @type {Set<string>}
+     */
+    this.missing = new Set();
   }
 
   /**
@@ -5928,6 +6105,19 @@ class Logs {
     return Array.isArray(response.logs) ? response.logs : [];
   }
 
+  /**
+   * Retrieves the backend identifiers that are (partially) missing in the logs.
+   * 
+   * This is only filled after the first request using `nextLogs` or `next`.
+   * 
+   * @returns {Array.<string>}
+   * @see {Logs#nextLogs}
+   * @see {Logs#next}
+   */
+  getMissingBackends() {
+    return Array.from(this.missing);
+  }
+
   /**
    * Retrieves the next log entries since the last request.
    * 
@@ -5955,6 +6145,9 @@ class Logs {
       response.data.logs = [];
     }
     response.data.links = Array.isArray(response.data.links) ? response.data.links : [];
+    if (Array.isArray(response.data["federation:missing"])) {
+      response.data["federation:missing"].forEach(backend => this.missing.add(backend));
+    }
     return response.data;
   }
 }
@@ -6452,7 +6645,7 @@ class OpenEO {
    * @returns {string} Version number (according to SemVer).
    */
   static clientVersion() {
-    return "2.6.0";
+    return "2.8.0";
   }
 }
 OpenEO.Environment = __webpack_require__(458);
@@ -6478,6 +6671,369 @@ module.exports = {
 
 /***/ }),
 
+/***/ 226:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+/* eslint-disable max-classes-per-file */
+
+const Job = __webpack_require__(293);
+const Service = __webpack_require__(497);
+const UserFile = __webpack_require__(649);
+const UserProcess = __webpack_require__(806);
+const Utils = __webpack_require__(768);
+const StacMigrate = __webpack_require__(321);
+const FED_MISSING = 'federation:missing';
+
+/**
+ * A class to handle pagination of resources.
+ * 
+ * @abstract
+ */
+class Pages {
+  /**
+   * Creates an instance of Pages.
+   *
+   * @param {Connection} connection
+   * @param {string} endpoint
+   * @param {string} key
+   * @param {Constructor} cls - Class
+   * @param {object} [params={}]
+   * @param {string} primaryKey
+   */
+  constructor(connection, endpoint, key, cls, params = {}, primaryKey = "id") {
+    this.connection = connection;
+    this.nextUrl = endpoint;
+    this.key = key;
+    this.primaryKey = primaryKey;
+    this.cls = cls;
+    if (!(params.limit > 0)) {
+      delete params.limit;
+    }
+    this.params = params;
+  }
+
+  /**
+   * Returns true if there are more pages to fetch.
+   *
+   * @returns {boolean}
+   */
+  hasNextPage() {
+    return this.nextUrl !== null;
+  }
+
+  /**
+   * Returns the next page of resources.
+   * 
+   * @async
+   * @param {Array.<object>} oldObjects - Existing objects to update, if any.
+   * @param {boolean} [toArray=true] - Whether to return the objects as a simplified array or as an object with all information.
+   * @returns {Array.<object>}
+   * @throws {Error}
+   */
+  async nextPage(oldObjects = [], toArray = true) {
+    // Request data from server
+    const response = await this.connection._get(this.nextUrl, this.params);
+    let data = response.data;
+    // Check response
+    if (!Utils.isObject(data)) {
+      throw new Error(`Response is invalid, is not an object`);
+    }
+    if (!Array.isArray(data[this.key])) {
+      throw new Error(`Response is invalid, '${this.key}' property is not an array`);
+    }
+
+    // Update existing objects if needed
+    let newObjects = data[this.key].map(updated => {
+      let resource = oldObjects.find(old => old[this.primaryKey] === updated[this.primaryKey]);
+      if (resource) {
+        resource.setAll(updated);
+      } else {
+        resource = this._createObject(updated);
+      }
+      return resource;
+    });
+
+    // Store objects in cache if needed
+    newObjects = this._cache(newObjects);
+
+    // Add self link if missing
+    data.links = this._ensureArray(data.links);
+    const selfLink = this.connection._getLinkHref(data.links, 'self');
+    if (!selfLink) {
+      data.links.push({
+        rel: 'self',
+        href: this.nextUrl
+      });
+    }
+
+    // Check whether a next page is available
+    this.nextUrl = this._getNextLink(response);
+    // Don't append initial params to the next URL
+    this.params = null;
+
+    // Either return as ResponseArray or full API response body
+    if (toArray) {
+      newObjects.links = data.links;
+      newObjects[FED_MISSING] = this._ensureArray(data[FED_MISSING]);
+      return newObjects;
+    } else {
+      data[this.key] = newObjects;
+      return data;
+    }
+  }
+
+  /**
+   * Ensures a variable is an array.
+   * 
+   * @protected
+   * @param {*} x 
+   * @returns {Array}
+   */
+  _ensureArray(x) {
+    return Array.isArray(x) ? x : [];
+  }
+
+  /**
+   * Creates a facade for the object, if needed.
+   *
+   * @protected
+   * @param {object} obj 
+   * @returns {object}
+   */
+  _createObject(obj) {
+    if (this.cls) {
+      const cls = this.cls;
+      const newObj = new cls(this.connection, obj[this.primaryKey]);
+      newObj.setAll(obj);
+      return newObj;
+    } else {
+      return obj;
+    }
+  }
+
+  /**
+   * Caches the plain objects if needed.
+   * 
+   * @param {Array.<object>} objects
+   * @returns {Array.<object>}
+   */
+  _cache(objects) {
+    return objects;
+  }
+
+  /**
+   * Get the URL of the next page from a response.
+   * 
+   * @protected
+   * @param {AxiosResponse} response 
+   * @returns {string | null}
+   */
+  _getNextLink(response) {
+    const links = this.connection.makeLinksAbsolute(response.data.links, response);
+    return this.connection._getLinkHref(links, 'next');
+  }
+
+  /**
+   * Makes this class asynchronously iterable.
+   *
+   * @returns {AsyncIterator}
+   */
+  [Symbol.asyncIterator]() {
+    return {
+      self: this,
+      /**
+       * Get the next page of resources.
+       *
+       * @async
+       * @returns {{done: boolean, value: Array.<object>}}
+       */
+      async next() {
+        const done = !this.self.hasNextPage();
+        let value;
+        if (!done) {
+          value = await this.self.nextPage();
+        }
+        return {
+          done,
+          value
+        };
+      }
+    };
+  }
+}
+
+/**
+ * Paginate through jobs.
+ */
+class JobPages extends Pages {
+  /**
+   * Paginate through jobs.
+   *
+   * @param {Connection} connection
+   * @param {?number} limit
+   */
+  constructor(connection, limit = null) {
+    super(connection, "/jobs", "jobs", Job, {
+      limit
+    });
+  }
+}
+
+/**
+ * Paginate through services.
+ */
+class ServicePages extends Pages {
+  /**
+   * Paginate through services.
+   *
+   * @param {Connection} connection
+   * @param {?number} limit
+   */
+  constructor(connection, limit = null) {
+    super(connection, "/services", "services", Service, {
+      limit
+    });
+  }
+}
+
+/**
+ * Paginate through user files.
+ */
+class UserFilePages extends Pages {
+  /**
+   * Paginate through user files.
+   *
+   * @param {Connection} connection
+   * @param {?number} limit
+   */
+  constructor(connection, limit = null) {
+    super(connection, "/files", "files", UserFile, {
+      limit
+    }, "path");
+  }
+}
+
+/**
+ * Paginate through processes.
+ */
+class ProcessPages extends Pages {
+  /**
+   * Paginate through processes.
+   *
+   * @param {Connection} connection
+   * @param {?number} limit
+   * @param {?string} namespace
+   */
+  constructor(connection, limit = null, namespace = null) {
+    if (!namespace) {
+      namespace = 'backend';
+    }
+    let endpoint;
+    let cls = null;
+    if (namespace === 'user') {
+      endpoint = '/process_graphs';
+      cls = UserProcess;
+    } else {
+      endpoint = '/processes';
+      if (namespace !== 'backend') {
+        const normalized = connection.normalizeNamespace(namespace);
+        endpoint += `/${normalized}`;
+      }
+    }
+    super(connection, endpoint, "processes", cls, {
+      limit
+    });
+    this.namespace = namespace;
+  }
+
+  /**
+   * Caches the objects to the ProcessRegistry.
+   * 
+   * @param {Array.<object>} objects
+   * @returns {Array.<object>}
+   */
+  _cache(objects) {
+    const plainObjects = objects.map(p => typeof p.toJSON === 'function' ? p.toJSON() : p);
+    this.connection.processes.addAll(plainObjects, this.namespace);
+    if (!this.cls) {
+      for (let i in objects) {
+        objects[i] = this.connection.processes.get(objects[i].id, this.namespace);
+      }
+    }
+    return objects;
+  }
+}
+
+/**
+ * Paginate through collections.
+ */
+class CollectionPages extends Pages {
+  /**
+   * Paginate through collections.
+   *
+   * @param {Connection} connection
+   * @param {?number} limit
+   */
+  constructor(connection, limit = null) {
+    super(connection, "/collections", "collections", null, {
+      limit
+    });
+  }
+
+  /**
+   * Migrates the STAC collection to the latest version.
+   * 
+   * @param {object} obj 
+   * @returns {Collection}
+   */
+  _createObject(obj) {
+    if (obj.stac_version) {
+      return StacMigrate.collection(obj);
+    }
+    return obj;
+  }
+}
+
+/**
+ * Paginate through collection items.
+ */
+class ItemPages extends Pages {
+  /**
+   * Paginate through collection items.
+   *
+   * @param {Connection} connection
+   * @param {string} collectionId
+   * @param {object} params
+   */
+  constructor(connection, collectionId, params) {
+    super(connection, `/collections/${collectionId}/items`, "features", null, params);
+  }
+
+  /**
+   * Migrates the STAC item to the latest version.
+   * 
+   * @param {object} obj 
+   * @returns {Item}
+   */
+  _createObject(obj) {
+    if (obj.stac_version) {
+      return StacMigrate.item(obj);
+    }
+    return obj;
+  }
+}
+module.exports = {
+  Pages,
+  CollectionPages,
+  ItemPages,
+  JobPages,
+  ProcessPages,
+  ServicePages,
+  UserFilePages
+};
+
+/***/ }),
+
 /***/ 497:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
@@ -6989,124 +7545,240 @@ module.exports = UserProcess;
 
 /***/ }),
 
-/***/ 246:
-/***/ (function(module, exports) {
-
-var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* global define */
-(function (root, factory) {
-  /* istanbul ignore next */
-  if (true) {
-    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
-		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
-		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
-		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-  } else {}
-}(this, function () {
-
-  var semver = /^v?(?:\d+)(\.(?:[x*]|\d+)(\.(?:[x*]|\d+)(\.(?:[x*]|\d+))?(?:-[\da-z\-]+(?:\.[\da-z\-]+)*)?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
-
-  function indexOrEnd(str, q) {
-    return str.indexOf(q) === -1 ? str.length : str.indexOf(q);
-  }
-
-  function split(v) {
-    var c = v.replace(/^v/, '').replace(/\+.*$/, '');
-    var patchIndex = indexOrEnd(c, '-');
-    var arr = c.substring(0, patchIndex).split('.');
-    arr.push(c.substring(patchIndex + 1));
-    return arr;
-  }
-
-  function tryParse(v) {
-    return isNaN(Number(v)) ? v : Number(v);
-  }
+/***/ 385:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-  function validate(version) {
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  compare: () => (/* reexport */ compare),
+  compareVersions: () => (/* reexport */ compareVersions),
+  satisfies: () => (/* reexport */ satisfies),
+  validate: () => (/* reexport */ validate),
+  validateStrict: () => (/* reexport */ validateStrict)
+});
+
+;// ./node_modules/compare-versions/lib/esm/utils.js
+const semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+const validateAndParse = (version) => {
     if (typeof version !== 'string') {
-      throw new TypeError('Invalid argument expected string');
+        throw new TypeError('Invalid argument expected string');
     }
-    if (!semver.test(version)) {
-      throw new Error('Invalid argument not valid semver (\''+version+'\' received)');
+    const match = version.match(semver);
+    if (!match) {
+        throw new Error(`Invalid argument not valid semver ('${version}' received)`);
     }
-  }
-
-  function compareVersions(v1, v2) {
-    [v1, v2].forEach(validate);
-
-    var s1 = split(v1);
-    var s2 = split(v2);
-
-    for (var i = 0; i < Math.max(s1.length - 1, s2.length - 1); i++) {
-      var n1 = parseInt(s1[i] || 0, 10);
-      var n2 = parseInt(s2[i] || 0, 10);
-
-      if (n1 > n2) return 1;
-      if (n2 > n1) return -1;
+    match.shift();
+    return match;
+};
+const isWildcard = (s) => s === '*' || s === 'x' || s === 'X';
+const tryParse = (v) => {
+    const n = parseInt(v, 10);
+    return isNaN(n) ? v : n;
+};
+const forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];
+const compareStrings = (a, b) => {
+    if (isWildcard(a) || isWildcard(b))
+        return 0;
+    const [ap, bp] = forceType(tryParse(a), tryParse(b));
+    if (ap > bp)
+        return 1;
+    if (ap < bp)
+        return -1;
+    return 0;
+};
+const compareSegments = (a, b) => {
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const r = compareStrings(a[i] || '0', b[i] || '0');
+        if (r !== 0)
+            return r;
     }
+    return 0;
+};
+//# sourceMappingURL=utils.js.map
+;// ./node_modules/compare-versions/lib/esm/compareVersions.js
 
-    var sp1 = s1[s1.length - 1];
-    var sp2 = s2[s2.length - 1];
-
-    if (sp1 && sp2) {
-      var p1 = sp1.split('.').map(tryParse);
-      var p2 = sp2.split('.').map(tryParse);
-
-      for (i = 0; i < Math.max(p1.length, p2.length); i++) {
-        if (p1[i] === undefined || typeof p2[i] === 'string' && typeof p1[i] === 'number') return -1;
-        if (p2[i] === undefined || typeof p1[i] === 'string' && typeof p2[i] === 'number') return 1;
-
-        if (p1[i] > p2[i]) return 1;
-        if (p2[i] > p1[i]) return -1;
-      }
-    } else if (sp1 || sp2) {
-      return sp1 ? -1 : 1;
+/**
+ * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.
+ * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.
+ * @param v1 - First version to compare
+ * @param v2 - Second version to compare
+ * @returns Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+ */
+const compareVersions = (v1, v2) => {
+    // validate input and split into segments
+    const n1 = validateAndParse(v1);
+    const n2 = validateAndParse(v2);
+    // pop off the patch
+    const p1 = n1.pop();
+    const p2 = n2.pop();
+    // validate numbers
+    const r = compareSegments(n1, n2);
+    if (r !== 0)
+        return r;
+    // validate pre-release
+    if (p1 && p2) {
+        return compareSegments(p1.split('.'), p2.split('.'));
+    }
+    else if (p1 || p2) {
+        return p1 ? -1 : 1;
     }
-
     return 0;
-  };
-
-  var allowedOperators = [
-    '>',
-    '>=',
-    '=',
-    '<',
-    '<='
-  ];
+};
+//# sourceMappingURL=compareVersions.js.map
+;// ./node_modules/compare-versions/lib/esm/compare.js
 
-  var operatorResMap = {
+/**
+ * Compare [semver](https://semver.org/) version strings using the specified operator.
+ *
+ * @param v1 First version to compare
+ * @param v2 Second version to compare
+ * @param operator Allowed arithmetic operator to use
+ * @returns `true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise.
+ *
+ * @example
+ * ```
+ * compare('10.1.8', '10.0.4', '>'); // return true
+ * compare('10.0.1', '10.0.1', '='); // return true
+ * compare('10.1.1', '10.2.2', '<'); // return true
+ * compare('10.1.1', '10.2.2', '<='); // return true
+ * compare('10.1.1', '10.2.2', '>='); // return false
+ * ```
+ */
+const compare = (v1, v2, operator) => {
+    // validate input operator
+    assertValidOperator(operator);
+    // since result of compareVersions can only be -1 or 0 or 1
+    // a simple map can be used to replace switch
+    const res = compareVersions(v1, v2);
+    return operatorResMap[operator].includes(res);
+};
+const operatorResMap = {
     '>': [1],
     '>=': [0, 1],
     '=': [0],
     '<=': [-1, 0],
-    '<': [-1]
-  };
-
-  function validateOperator(op) {
+    '<': [-1],
+    '!=': [-1, 1],
+};
+const allowedOperators = Object.keys(operatorResMap);
+const assertValidOperator = (op) => {
     if (typeof op !== 'string') {
-      throw new TypeError('Invalid operator type, expected string but got ' + typeof op);
+        throw new TypeError(`Invalid operator type, expected string but got ${typeof op}`);
     }
     if (allowedOperators.indexOf(op) === -1) {
-      throw new TypeError('Invalid operator, expected one of ' + allowedOperators.join('|'));
+        throw new Error(`Invalid operator, expected one of ${allowedOperators.join('|')}`);
     }
-  }
+};
+//# sourceMappingURL=compare.js.map
+;// ./node_modules/compare-versions/lib/esm/satisfies.js
 
-  compareVersions.validate = function(version) {
-    return typeof version === 'string' && semver.test(version);
-  }
 
-  compareVersions.compare = function (v1, v2, operator) {
-    // Validate operator
-    validateOperator(operator);
+/**
+ * Match [npm semver](https://docs.npmjs.com/cli/v6/using-npm/semver) version range.
+ *
+ * @param version Version number to match
+ * @param range Range pattern for version
+ * @returns `true` if the version number is within the range, `false` otherwise.
+ *
+ * @example
+ * ```
+ * satisfies('1.1.0', '^1.0.0'); // return true
+ * satisfies('1.1.0', '~1.0.0'); // return false
+ * ```
+ */
+const satisfies = (version, range) => {
+    // clean input
+    range = range.replace(/([><=]+)\s+/g, '$1');
+    // handle multiple comparators
+    if (range.includes('||')) {
+        return range.split('||').some((r) => satisfies(version, r));
+    }
+    else if (range.includes(' - ')) {
+        const [a, b] = range.split(' - ', 2);
+        return satisfies(version, `>=${a} <=${b}`);
+    }
+    else if (range.includes(' ')) {
+        return range
+            .trim()
+            .replace(/\s{2,}/g, ' ')
+            .split(' ')
+            .every((r) => satisfies(version, r));
+    }
+    // if no range operator then "="
+    const m = range.match(/^([<>=~^]+)/);
+    const op = m ? m[1] : '=';
+    // if gt/lt/eq then operator compare
+    if (op !== '^' && op !== '~')
+        return compare(version, range, op);
+    // else range of either "~" or "^" is assumed
+    const [v1, v2, v3, , vp] = validateAndParse(version);
+    const [r1, r2, r3, , rp] = validateAndParse(range);
+    const v = [v1, v2, v3];
+    const r = [r1, r2 !== null && r2 !== void 0 ? r2 : 'x', r3 !== null && r3 !== void 0 ? r3 : 'x'];
+    // validate pre-release
+    if (rp) {
+        if (!vp)
+            return false;
+        if (compareSegments(v, r) !== 0)
+            return false;
+        if (compareSegments(vp.split('.'), rp.split('.')) === -1)
+            return false;
+    }
+    // first non-zero number
+    const nonZero = r.findIndex((v) => v !== '0') + 1;
+    // pointer to where segments can be >=
+    const i = op === '~' ? 2 : nonZero > 1 ? nonZero : 1;
+    // before pointer must be equal
+    if (compareSegments(v.slice(0, i), r.slice(0, i)) !== 0)
+        return false;
+    // after pointer must be >=
+    if (compareSegments(v.slice(i), r.slice(i)) === -1)
+        return false;
+    return true;
+};
+//# sourceMappingURL=satisfies.js.map
+;// ./node_modules/compare-versions/lib/esm/validate.js
+
+/**
+ * Validate [semver](https://semver.org/) version strings.
+ *
+ * @param version Version number to validate
+ * @returns `true` if the version number is a valid semver version number, `false` otherwise.
+ *
+ * @example
+ * ```
+ * validate('1.0.0-rc.1'); // return true
+ * validate('1.0-rc.1'); // return false
+ * validate('foo'); // return false
+ * ```
+ */
+const validate = (version) => typeof version === 'string' && /^[v\d]/.test(version) && semver.test(version);
+/**
+ * Validate [semver](https://semver.org/) version strings strictly. Will not accept wildcards and version ranges.
+ *
+ * @param version Version number to validate
+ * @returns `true` if the version number is a valid semver version number `false` otherwise
+ *
+ * @example
+ * ```
+ * validate('1.0.0-rc.1'); // return true
+ * validate('1.0-rc.1'); // return false
+ * validate('foo'); // return false
+ * ```
+ */
+const validateStrict = (version) => typeof version === 'string' &&
+    /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(version);
+//# sourceMappingURL=validate.js.map
+;// ./node_modules/compare-versions/lib/esm/index.js
+
 
-    // since result of compareVersions can only be -1 or 0 or 1
-    // a simple map can be used to replace switch
-    var res = compareVersions(v1, v2);
-    return operatorResMap[operator].indexOf(res) > -1;
-  }
 
-  return compareVersions;
-}));
 
+//# sourceMappingURL=index.js.map
 
 /***/ }),
 
@@ -7233,6 +7905,35 @@ module.exports = __WEBPACK_EXTERNAL_MODULE__742__;
 /******/ 	}
 /******/ 	
 /************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
 /******/ 	
 /******/ 	// startup
 /******/ 	// Load entry module and return exports