transformApiJson = function (oChainObject) {
		// Function is a copy from: LibraryInfo.js => LibraryInfo.prototype._getActualComponent => "match" inline method
		function matchComponent(sModuleName, sPattern) {
			sModuleName = sModuleName.toLowerCase();
			sPattern = sPattern.toLowerCase();
			return (
				sModuleName === sPattern
				|| sPattern.match(/\*$/) && sModuleName.indexOf(sPattern.slice(0,-1)) === 0 // simple prefix match
				|| sPattern.match(/\.\*$/) && sModuleName === sPattern.slice(0,-2) // directory pattern also matches directory itself
			);
		}

		/**
		 * Pre-processes the symbols list - creating virtual namespace records and attaching children list to namespace
		 * records.
		 * @param {object} symbols list
		 */
		function preProcessSymbols(symbols) {
			// Create treeName and modify module names
			symbols.forEach((oSymbol) => {
				const sModuleClearName = oSymbol.name.replace(/^module:/, "");
				oSymbol.displayName = sModuleClearName;
				oSymbol.treeName = normalizeToUI5GlobalNotation(sModuleClearName);
			});

			// Create missing - virtual namespaces
			symbols.forEach((oSymbol) => {
				oSymbol.treeName.split(".").forEach((sPart, i, a) => {
					const sName = a.slice(0, (i + 1)).join(".");

					if (!symbols.find((o) => o.treeName === sName)) {
						symbols.push({
							name: sName,
							displayName: sName,
							treeName: sName,
							lib: oSymbol.lib,
							kind: "namespace"
						});
					}
				});
			});

			// Discover parents
			symbols.forEach((oSymbol) => {
				const aParent = oSymbol.treeName.split(".");

				// Extract parent name
				aParent.pop();
				const sParent = aParent.join(".");

				// Mark parent
				if (symbols.find(({treeName}) => treeName === sParent)) {
					oSymbol.parent = sParent;
				}
			});

			// Attach children info
			symbols.forEach((oSymbol) => {
				if (oSymbol.parent) {
					const oParent = symbols.find(({treeName}) => treeName === oSymbol.parent);

					if (!oParent.nodes) {oParent.nodes = [];}

					const oNode = {
						name: oSymbol.displayName,
						description: formatters._preProcessLinksInTextBlock(
							extractFirstSentence(oSymbol.description)
						),
						href: "api/" + encodeURIComponent(oSymbol.name)
					};

					if (oSymbol.deprecated) {
						oNode.deprecated = true;
					}

					oParent.nodes.push(oNode);
				}
			});

			// Clean list - keep file size down
			symbols.forEach((o) => {
				delete o.treeName;
				delete o.parent;
			});
		}

		// Transform to object
		const oData = oChainObject.fileData;

		// Attach default component for the library if available
		if (oChainObject.defaultComponent) {
			oData.defaultComponent = oChainObject.defaultComponent;
		}

		formatters._oOwnLibrary = oData;

		// Pre process symbols
		preProcessSymbols(oData.symbols);

		// Apply formatter's and modify data as needed
		oData.symbols.forEach((oSymbol) => {

			// when the module name starts with the library name, then we apply the default component
			if (normalizeToUI5GlobalNotation(oSymbol.displayName).startsWith(oData.library)) {
				oSymbol.component = oChainObject.defaultComponent;
			}

			// Attach symbol specific component if available (special cases)
			// Note: Last hit wins as there may be a more specific component pattern
			if (oChainObject.customSymbolComponents) {
				Object.keys(oChainObject.customSymbolComponents).forEach((sComponent) => {
					if (matchComponent(normalizeToUI5GlobalNotation(oSymbol.displayName), sComponent)) {
						oSymbol.component = oChainObject.customSymbolComponents[sComponent];
					}
				});
			}

			// Attach symbol sample flag if available
			if (oChainObject.entitiesWithSamples) {
				oSymbol.hasSample = oChainObject.entitiesWithSamples.indexOf(oSymbol.name) >= 0;
			}

			// Apply settings to formatter object - needed until formatter's are rewritten
			formatters._sTopicId = oSymbol.name;
			formatters._oTopicData = oSymbol;

			// Format Page Title
			oSymbol.title = (oSymbol.abstract ? "abstract " : "") + oSymbol.kind + " " + oSymbol.displayName;
			oSymbol.subTitle = formatters.formatSubtitle(oSymbol.deprecated);

			// Constructor
			if (oSymbol.constructor) {
				const oConstructor = resolveTypeParameters(oSymbol.constructor);

				// Description
				if (oConstructor.description) {
					oConstructor.description = formatters.formatDescription(oConstructor.description);
				}

				// References
				formatters.modifyReferences(oSymbol, true);

				// Examples
				if (oConstructor.examples) {
					oConstructor.examples.forEach((oExample) => {
						oExample.data = formatters.formatExample(oExample.caption, oExample.text);

						// Keep file size in check
						if (oExample.caption) {
							delete oExample.caption;
						}
						if (oExample.text) {
							delete oExample.text;
						}
					});
				}

				// Code Example string
				oConstructor.codeExample = formatters.formatConstructor(oSymbol.name, oConstructor.parameters);

				// Parameters
				if (oConstructor.parameters) {
					oConstructor.parameters = methods.buildConstructorParameters(oConstructor.parameters);

					const aParameters = oConstructor.parameters;
					aParameters.forEach((oParameter) => {

						// Types
						oParameter.types = [];
						if (oParameter.type) {
							oParameter.typeInfo = parseUI5Types(oParameter.type);
							// Keep file size in check
							delete oParameter.type;
						}

						// Default value
						oParameter.defaultValue = formatters.formatDefaultValue(oParameter.defaultValue);

						// Description
						if (oParameter.description) {
							oParameter.description = formatters.formatDescription(oParameter.description);
						}

					});
				}

				// Throws
				if (oConstructor.throws) {
					oConstructor.throws.forEach((oThrows) => {

						// Description
						if (oThrows.description) {
							oThrows.description = formatters.formatDescription(oThrows.description);
						}

						// Exception link enabled
						if (oThrows.type) {
							oThrows.linkEnabled = formatters.formatExceptionLink(oThrows.type);
						}

					});
				}
			}

			// Description
			if (oSymbol.description) {
				oSymbol.description = formatters.formatOverviewDescription(oSymbol.description, oSymbol.constructor.references);
			}

			// Deprecated
			if (oSymbol.deprecated) {
				oSymbol.deprecatedText = formatters.formatDeprecated(oSymbol.deprecated.since, oSymbol.deprecated.text);
				// Keep file size in check
				delete oSymbol.deprecated;
			}

			// Properties
			if (oSymbol.properties) {

				// Pre-process properties
				if (oSymbol.kind === "typedef") {
					oSymbol.properties = methods.buildPropertiesModel(oSymbol.properties);
				}

				oSymbol.properties.forEach((oProperty) => {

					// Name
					oProperty.name = formatters.formatEntityName(oProperty.name, oSymbol.name, oProperty.static);

					// Description
					if (oProperty.deprecated) {
						oProperty.description = formatters.formatDescription(oProperty.description,
							oProperty.deprecated.text, oProperty.deprecated.since);
					} else {
						oProperty.description = formatters.formatDescription(oProperty.description);
					}

					// Examples
					if (oProperty.examples) {
						oProperty.examples.forEach((oExample) => {
							oExample.data = formatters.formatExample(oExample.caption, oExample.text);

							// Keep file size in check
							if (oExample.caption) {
								delete oExample.caption;
							}
							if (oExample.text) {
								delete oExample.text;
							}
						});
					}

					// Type
					if (oSymbol.kind !== "enum") { // enum properties don't have an own type
						if (oProperty.type) {
							oProperty.typeInfo = parseUI5Types(oProperty.type);
							// Keep file size in check
							delete oProperty.type;
						}
					}

					// Keep file size in check
					if (oProperty.static) {
						delete oProperty.static;
					}

					delete oProperty.type;

				});
			}

			// UI5 Metadata
			if (oSymbol["ui5-metadata"]) {
				const oMeta = oSymbol["ui5-metadata"];

				// Properties
				if (oMeta.properties) {
					// Sort
					oMeta.properties.sort(function (a, b) {
						if (a.name < b.name) {
							return -1;
						} else if (a.name > b.name) {
							return 1;
						} else {
							return 0;
						}
					});

					// Pre-process
					oMeta.properties.forEach((oProperty) => {
						// Name
						oProperty.name = formatters.formatEntityName(oProperty.name, oSymbol.name, oProperty.static);

						// Type
						if (oProperty.type) {
							oProperty.typeInfo = parseUI5Types(oProperty.type);
							// Keep file size in check
							delete oProperty.type;
						}

						// Description
						oProperty.description = formatters.formatDescriptionSince(oProperty.description, oProperty.since);

						// Default value
						oProperty.defaultValue = formatters.formatDefaultValue(oProperty.defaultValue);

						// Deprecated
						if (oProperty.deprecated) {
							oProperty.deprecatedText = formatters.formatDeprecated(oProperty.deprecated.since,
								oProperty.deprecated.text);

							// Keep file size in check
							delete oProperty.deprecated;
						}
					});
				}

				// Aggregations
				if (oMeta.aggregations) {
					// Sort
					oMeta.aggregations.sort(function (a, b) {
						if (a.name < b.name) {
							return -1;
						} else if (a.name > b.name) {
							return 1;
						} else {
							return 0;
						}
					});

					// Pre-process
					oMeta.aggregations.forEach((oAggregation) => {
						// Link Enabled
						if (!isBuiltInType(oAggregation.type)) {
							oAggregation.linkEnabled = true;
						}

						// Description
						if (oAggregation.deprecated) {
							oAggregation.description = formatters.formatDescription(oAggregation.description);
							oAggregation.deprecatedText = formatters.formatDeprecated(oAggregation.deprecated.since,
								oAggregation.deprecated.text);
						} else {
							oAggregation.description = formatters.formatDescriptionSince(oAggregation.description, oAggregation.since);
						}

						// Link enabled
						oAggregation.linkEnabled = !isBuiltInType(oAggregation.type);
					});
				}

				// Associations

				if (oMeta.associations) {
					// Sort
					oMeta.associations.sort(function (a, b) {
						if (a.name < b.name) {
							return -1;
						} else if (a.name > b.name) {
							return 1;
						} else {
							return 0;
						}
					});

					// Pre-process
					oMeta.associations.forEach((oAssociation) => {
						// Link Enabled
						if (!isBuiltInType(oAssociation.type)) {
							oAssociation.linkEnabled = true;
						}

						// Description
						if (oAssociation.deprecated) {
							oAssociation.description = formatters.formatDescription(oAssociation.description,
								oAssociation.deprecated.text, oAssociation.deprecated.since);
						} else {
							oAssociation.description = formatters.formatDescriptionSince(oAssociation.description, oAssociation.since);
						}
					});
				}

				// Events
				if (oMeta.events) {

					oMeta.events.forEach((oEvent) => {
						const aParams = oEvent.parameters;

						if (aParams) {
							Object.keys(aParams).forEach((sParam) => {
								const sSince = aParams[sParam].since;
								const oDeprecated = aParams[sParam].deprecated;
								const oEvtInSymbol = oSymbol.events.find((e) => e.name === oEvent.name);
								const oParamInSymbol = oEvtInSymbol && oEvtInSymbol.parameters[0] &&
														oEvtInSymbol.parameters[0].parameterProperties &&
														oEvtInSymbol.parameters[0].parameterProperties.getParameters &&
														oEvtInSymbol.parameters[0].parameterProperties.getParameters.parameterProperties &&
														oEvtInSymbol.parameters[0].parameterProperties.getParameters.parameterProperties[sParam];

								if (typeof oParamInSymbol === 'object' && oParamInSymbol !== null) {
									if (sSince) {
										oParamInSymbol.since = sSince;
									}

									if (oDeprecated) {
										oParamInSymbol.deprecated = oDeprecated;
									}
								}
							});
						}
					});

					// We don't need event's data from the UI5-metadata for now. Keep file size in check
					delete oMeta.events;
				}

				// Special Settings
				if (oMeta.specialSettings) {
					oMeta.specialSettings.forEach((oSetting) => {

						// Link Enabled
						if (oSetting.type) {
							oSetting.typeInfo = parseUI5Types(oSetting.type);
							delete oSetting.type; // Keep file size in check
						}

						// Description
						if (oSetting.deprecated) {
							oSetting.description = formatters.formatDescription(oSetting.description,
								oSetting.deprecated.text, oSetting.deprecated.since);
						} else {
							oSetting.description = formatters.formatDescription(oSetting.description);
						}

					});
				}

				// Annotations
				if (oMeta.annotations) {
					oMeta.annotations.forEach((oAnnotation) => {

						// Description
						oAnnotation.description = formatters.formatAnnotationDescription(oAnnotation.description,
							oAnnotation.since);

						// Namespace
						oAnnotation.namespaceText = oAnnotation.namespace;
						oAnnotation.namespace = formatters.formatAnnotationNamespace(oAnnotation.namespace);

						// Target
						oAnnotation.target = formatters.formatAnnotationTarget(oAnnotation.target);

						// Applies to
						oAnnotation.appliesTo = formatters.formatAnnotationTarget(oAnnotation.appliesTo);

					});
				}

			}

			if (oSymbol.events) {

				// Pre-process events
				methods.buildEventsModel(oSymbol.events);

				oSymbol.events.forEach((oEvent) => {

					// Description
					if (oEvent.description) {
						oEvent.description = formatters.formatDescriptionSince(oEvent.description, oEvent.since);
					}

					if (oEvent.references) {
						formatters.formatReferencesInDescription(oEvent);
					}

					if (oEvent.description) {
						oEvent.description = formatters.formatDescription(oEvent.description);
					}

					// Deprecated
					if (oEvent.deprecated) {
						oEvent.deprecatedText = formatters.formatEventDeprecated(oEvent.deprecated.since,
							oEvent.deprecated.text);
					}

					// Parameters
					if (oEvent.parameters && Array.isArray(oEvent.parameters)) {
						oEvent.parameters.forEach((oParameter) => {

							if (oParameter.type) {
								oParameter.typeInfo = parseUI5Types(oParameter.type);
								delete oParameter.type; // Keep file size in check
							}

							// Description
							if (oParameter.description) {
								oParameter.description = formatters.formatDescriptionSince(oParameter.description, oParameter.since);
							}

							if (oParameter.references) {
								formatters.formatReferencesInDescription(oParameter);
							}

							if (oParameter.description) {
								oParameter.description = formatters.formatDescription(oParameter.description);
							}

							// Deprecated
							if (oParameter.deprecated) {
								oParameter.deprecatedText = formatters.formatDeprecated(oParameter.deprecated.since,
									oParameter.deprecated.text);
							}
						});
					}

				});

			}

			// Methods
			if (oSymbol.methods) {

				// Pre-process methods
				methods.buildMethodsModel(oSymbol.methods);

				oSymbol.methods.forEach((oMethod) => {

					// Name and link
					if (oMethod.name) {
						oMethod.name = formatters.formatEntityName(oMethod.name, oSymbol.name, oMethod.static);

						// Link
						oMethod.href = "api/" + oSymbol.name +
							"#methods/" + oMethod.name;
					}

					formatters.formatReferencesInDescription(oMethod);

					// Description
					if (oMethod.description) {
						oMethod.description = formatters.formatDescription(oMethod.description);
					}

					// Examples
					oMethod.examples?.forEach((oExample) => {
						oExample = formatters.formatExample(oExample.caption, oExample.text);
					});

					// Deprecated
					if (oMethod.deprecated) {
						oMethod.deprecatedText = formatters.formatEventDeprecated(oMethod.deprecated.since,
							oMethod.deprecated.text);
					}

					// Code example
					oMethod.code = formatters.formatMethodCode(oMethod.name, oMethod.parameters, oMethod.returnValue);

					// Parameters
					if (oMethod.parameters) {
						oMethod.parameters?.forEach((oParameter) => {

							// Default value
							oParameter.defaultValue = formatters.formatDefaultValue(oParameter.defaultValue);

							// Description
							if (oParameter.deprecated) {
								oParameter.description = formatters.formatDescription(oParameter.description,
									oParameter.deprecated.text, oParameter.deprecated.since);
							} else {
								oParameter.description = formatters.formatDescription(oParameter.description);
							}

						});
					}

					// Return value
					if (oMethod.returnValue) {

						// Description
						oMethod.returnValue.description = formatters.formatDescription(oMethod.returnValue.description);

					}

					// Throws
					if (oMethod.throws) {
						oMethod.throws.forEach((oThrows) => {

							// Description
							if (oThrows.description) {
								oThrows.description = formatters.formatDescription(oThrows.description);
							}

							// Exception link enabled
							if (oThrows.type) {
								oThrows.linkEnabled = formatters.formatExceptionLink(oThrows.type);
							}

						});
					}

					// Examples
					if (oMethod.examples) {
						oMethod.examples.forEach((oExample) => {
							oExample.data = formatters.formatExample(oExample.caption, oExample.text);

							// Keep file size in check
							if (oExample.caption) {
								delete oExample.caption;
							}
							if (oExample.text) {
								delete oExample.text;
							}
						});

					}


				});
			}

			// Formatting namespaces, functions and enums, which may contain examples
			// or references with links to process them similar to methods and constructors of classes

			if (oSymbol.kind !== "class") {

				if (oSymbol.examples) {
					oSymbol.examples.forEach((oExample) => {
						oExample.data = formatters.formatExample(oExample.caption, oExample.text);
						// Keep file size in check
						if (oExample.caption) {
							delete oExample.caption;
						}
						if (oExample.text) {
							delete oExample.text;
						}
					});
				}

				if (oSymbol.references) {
					formatters.modifyReferences(oSymbol);
					formatters.formatReferencesInDescription(oSymbol);
				}

				// Description
				if (oSymbol.description) {
					oSymbol.description = formatters.formatDescription(oSymbol.description);
				}
			}
		});

		oChainObject.parsedData = oData;

		return oChainObject;
	}
Transforms api.json file
@param {object} oChainObject chain object