@regulaforensics/cordova-plugin-document-reader-api 5.4.0 → 5.8.0

package/src/android/JSONConstructor.java

@@ -1,26 +1,31 @@
 package cordova.plugin.documentreader;
 
 import android.content.Context;
+import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
-import android.graphics.Canvas;
-import android.graphics.Matrix;
 import android.graphics.Rect;
-import android.graphics.Bitmap;
-import android.graphics.drawable.BitmapDrawable;
-import android.graphics.drawable.Drawable;
 import android.util.Base64;
 
-import com.regula.documentreader.api.enums.BarcodeType;
 import com.regula.documentreader.api.enums.DocReaderAction;
+import com.regula.documentreader.api.enums.PDF417Info;
+import com.regula.documentreader.api.enums.eGraphicFieldType;
+import com.regula.documentreader.api.enums.eRPRM_Lights;
+import com.regula.documentreader.api.errors.DocumentReaderException;
 import com.regula.documentreader.api.params.FaceMetaData;
+import com.regula.documentreader.api.params.rfid.authorization.PAAttribute;
+import com.regula.documentreader.api.params.rfid.authorization.PAResourcesIssuer;
+import com.regula.documentreader.api.params.rfid.authorization.TAChallenge;
 import com.regula.documentreader.api.results.Bounds;
 import com.regula.documentreader.api.results.Coordinate;
 import com.regula.documentreader.api.results.DocReaderFieldRect;
+import com.regula.documentreader.api.results.DocumentReaderBarcodeField;
+import com.regula.documentreader.api.results.DocumentReaderBarcodeResult;
 import com.regula.documentreader.api.results.DocumentReaderDocumentType;
 import com.regula.documentreader.api.results.DocumentReaderGraphicField;
 import com.regula.documentreader.api.results.DocumentReaderGraphicResult;
 import com.regula.documentreader.api.results.DocumentReaderNotification;
 import com.regula.documentreader.api.results.DocumentReaderResults;
+import com.regula.documentreader.api.results.DocumentReaderScenario;
 import com.regula.documentreader.api.results.DocumentReaderScenarioFull;
 import com.regula.documentreader.api.results.DocumentReaderTextField;
 import com.regula.documentreader.api.results.DocumentReaderTextResult;
@@ -28,12 +33,9 @@ import com.regula.documentreader.api.results.DocumentReaderValue;
 import com.regula.documentreader.api.results.ElementPosition;
 import com.regula.documentreader.api.results.ImageQuality;
 import com.regula.documentreader.api.results.ImageQualityGroup;
-import com.regula.documentreader.api.results.authenticity.DocumentReaderAuthenticityResult;
 import com.regula.documentreader.api.results.authenticity.DocumentReaderAuthenticityCheck;
 import com.regula.documentreader.api.results.authenticity.DocumentReaderAuthenticityElement;
-import com.regula.documentreader.api.results.DocumentReaderBarcodeResult;
-import com.regula.documentreader.api.results.DocumentReaderBarcodeField;
-import com.regula.documentreader.api.results.DocumentReaderScenario;
+import com.regula.documentreader.api.results.authenticity.DocumentReaderAuthenticityResult;
 import com.regula.documentreader.api.results.rfid.AccessControlProcedureType;
 import com.regula.documentreader.api.results.rfid.Application;
 import com.regula.documentreader.api.results.rfid.Attribute;
@@ -51,218 +53,189 @@ import com.regula.documentreader.api.results.rfid.SecurityObjectCertificates;
 import com.regula.documentreader.api.results.rfid.SignerInfo;
 import com.regula.documentreader.api.results.rfid.Validity;
 import com.regula.documentreader.api.results.rfid.Value;
-import com.regula.documentreader.api.enums.PDF417Info;
-import com.regula.documentreader.api.enums.eRPRM_Lights;
-import com.regula.documentreader.api.enums.eGraphicFieldType;
 
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 
-@SuppressWarnings("RedundantSuppression")
+@SuppressWarnings({"ConstantConditions", "unused", "RedundantSuppression"})
 class JSONConstructor {
-
-    // To JSON
+    interface JSONObjectGeneratorWithContext<T> {
+        JSONObject generateJSONObject(T param, Context context) throws JSONException;
+    }
 
     interface JSONObjectGenerator<T> {
-        JSONObject generateJSONObject(T param, Context context) throws JSONException;
+        JSONObject generateJSONObject(T param) throws JSONException;
+    }
+
+    interface StringGenerator<T> {
+        String generateString(T param);
     }
 
-    static <T> JSONArray generateList(List<T> list, JSONObjectGenerator<T> generator, Context context) throws JSONException {
+    static <T> JSONArray generateList(List<T> list) {
         JSONArray result = new JSONArray();
+        if(list == null) return result;
         for (T t : list)
             if (t != null)
-                result.put(generator.generateJSONObject(t, context));
+                result.put(t);
 
         return result;
     }
 
-    static <T> JSONArray generateList(List<T> list) {
+    static <T> JSONArray generateList(List<T> list, JSONObjectGenerator<T> generator) throws JSONException {
         JSONArray result = new JSONArray();
+        if(list == null) return result;
         for (T t : list)
             if (t != null)
-                result.put(t);
+                result.put(generator.generateJSONObject(t));
+
+        return result;
+    }
+
+    static <T> JSONArray generateList(List<T> list, StringGenerator<T> generator) {
+        JSONArray result = new JSONArray();
+        if(list == null) return result;
+        for (T t : list)
+            if (t != null)
+                result.put(generator.generateString(t));
+
+        return result;
+    }
+
+    static <T> JSONArray generateList(List<T> list, JSONObjectGeneratorWithContext<T> generator, Context context) throws JSONException {
+        JSONArray result = new JSONArray();
+        if(list == null) return result;
+        for (T t : list)
+            if (t != null)
+                result.put(generator.generateJSONObject(t, context));
 
         return result;
     }
 
     static <T> JSONArray generateArray(T[] array) throws JSONException {
         JSONArray result = new JSONArray();
+        if(array == null) return result;
         for (int i = 0; i < array.length; i++)
             result.put(i, array[i]);
 
         return result;
     }
 
-    static <T> JSONArray generateArray(T[] array, JSONObjectGenerator<T> generator, Context context) throws JSONException {
+    static <T> JSONArray generateArray(T[] array, JSONObjectGenerator<T> generator) throws JSONException {
         JSONArray result = new JSONArray();
+        if(array == null) return result;
         for (int i = 0; i < array.length; i++)
-            result.put(i, generator.generateJSONObject(array[i], context));
+            result.put(i, generator.generateJSONObject(array[i]));
 
         return result;
     }
 
-    static JSONObject resultsToJsonObject(DocumentReaderResults results, Context context) {
-        JSONObject jsonObject = new JSONObject();
-        if (results == null) return jsonObject;
-        try {
-            jsonObject.put("chipPage", results.chipPage);
-            jsonObject.put("highResolution", results.highResolution);
-            jsonObject.put("morePagesAvailable", results.morePagesAvailable);
-            jsonObject.put("processingFinishedStatus", results.processingFinishedStatus);
-            jsonObject.put("rfidResult", results.rfidResult);
-            jsonObject.put("elapsedTimeRFID", results.elapsedTimeRFID);
-            jsonObject.put("elapsedTime", results.elapsedTime);
-            jsonObject.put("overallResult", results.getOverallResult());
-            jsonObject.put("documentType", generateList(results.documentType, JSONConstructor::generateDocumentReaderDocumentType, context));
-            if (results.barcodePosition != null)
-                jsonObject.put("barcodePosition", generateElementPosition(results.barcodePosition));
-            if (results.documentPosition != null)
-                jsonObject.put("documentPosition", generateElementPosition(results.documentPosition));
-            if (results.documentReaderNotification != null)
-                jsonObject.put("documentReaderNotification", generateDocumentReaderNotification(results.documentReaderNotification));
-            if (results.graphicResult != null)
-                jsonObject.put("graphicResult", generateDocumentReaderGraphicResult(results.graphicResult, context));
-            if (results.imageQuality != null)
-                jsonObject.put("imageQuality", generateImageQualityGroup(results.imageQuality, context));
-            if (results.rawResult != null)
-                jsonObject.put("rawResult", results.rawResult);
-            if (results.mrzPosition != null)
-                jsonObject.put("mrzPosition", generateElementPosition(results.mrzPosition));
-            if (results.rfidSessionData != null)
-                jsonObject.put("rfidSessionData", generateRfidSessionData(results.rfidSessionData, context));
-            if (results.textResult != null)
-                jsonObject.put("textResult", generateDocumentReaderTextResult(results.textResult, context));
-            if (results.authenticityResult != null)
-                jsonObject.put("authenticityResult", generateDocumentReaderAuthenticityResult(results.authenticityResult, context));
-            if (results.barcodeResult != null)
-                jsonObject.put("barcodeResult", generateDocumentReaderBarcodeResult(results.barcodeResult, context));
-        } catch (JSONException ignored) {
-        }
+    static <T> JSONArray generateArray(T[] array, StringGenerator<T> generator) throws JSONException {
+        JSONArray result = new JSONArray();
+        if(array == null) return result;
+        for (int i = 0; i < array.length; i++)
+            result.put(i, generator.generateString(array[i]));
 
-        return jsonObject;
+        return result;
     }
 
-    static JSONObject resultsToJsonObjectNotification(DocumentReaderResults results) throws JSONException {
-        if (results != null && results.documentReaderNotification != null)
-            return new JSONObject().put("documentReaderNotification", generateDocumentReaderNotification(results.documentReaderNotification));
-        return new JSONObject();
+    static <T> JSONArray generateArray(T[] array, JSONObjectGeneratorWithContext<T> generator, Context context) throws JSONException {
+        JSONArray result = new JSONArray();
+        if(array == null) return result;
+        for (int i = 0; i < array.length; i++)
+            result.put(i, generator.generateJSONObject(array[i], context));
+
+        return result;
     }
 
-    static JSONObject generateElementPosition(ElementPosition elementPosition) throws JSONException {
+    static <T, V> JSONObject generateMap(Map<T, V> map) throws JSONException {
         JSONObject result = new JSONObject();
-        result.put("angle", elementPosition.angle);
-        result.put("perspectiveTr", elementPosition.perspectiveTr);
-        result.put("objArea", elementPosition.objArea);
-        result.put("objIntAngleDev", elementPosition.objIntAngleDev);
-        result.put("pageIndex", elementPosition.pageIndex);
-        result.put("dpi", elementPosition.dpi);
-        result.put("inverse", elementPosition.inverse);
-        result.put("resultStatus", elementPosition.resultStatus);
-        result.put("docFormat", elementPosition.docFormat);
-        result.put("height", elementPosition.height);
-        result.put("width", elementPosition.width);
-        result.put("center", generateCoordinate(elementPosition.center));
-        result.put("leftBottom", generateCoordinate(elementPosition.leftBottom));
-        result.put("leftTop", generateCoordinate(elementPosition.leftTop));
-        result.put("rightBottom", generateCoordinate(elementPosition.rightBottom));
-        result.put("rightTop", generateCoordinate(elementPosition.rightTop));
-
+        if(map == null) return result;
+        for (Map.Entry<T, V> entry : map.entrySet())
+            if (entry != null)
+                result.put(entry.getKey().toString(), entry.getValue());
         return result;
     }
 
-    static JSONObject generateCoordinate(Coordinate coordinate) throws JSONException {
+    static <T, V> JSONObject generateMap(Map<T, V> map, JSONObjectGenerator<V> generator) throws JSONException {
         JSONObject result = new JSONObject();
-        if (coordinate == null) return result;
-        result.put("x", coordinate.x);
-        result.put("y", coordinate.y);
-
+        if(map == null) return result;
+        for (Map.Entry<T, V> entry : map.entrySet())
+            if (entry != null)
+                result.put(entry.getKey().toString(), generator.generateJSONObject(entry.getValue()));
         return result;
     }
 
-    static JSONObject generateDocumentReaderScenario(DocumentReaderScenario documentReaderScenario, @SuppressWarnings("unused") Context context) throws JSONException {
+    static <T, V> JSONObject generateMap(Map<T, V> map, StringGenerator<V> generator) throws JSONException {
         JSONObject result = new JSONObject();
-        result.put("name", documentReaderScenario.name);
-        result.put("caption", documentReaderScenario.caption);
-        result.put("description", documentReaderScenario.description);
-        result.put("uvTorch", documentReaderScenario.uvTorch);
-        result.put("seriesProcessMode", documentReaderScenario.seriesProcessMode);
-
+        if(map == null) return result;
+        for (Map.Entry<T, V> entry : map.entrySet())
+            if (entry != null)
+                result.put(entry.getKey().toString(), generator.generateString(entry.getValue()));
         return result;
     }
 
-    static JSONObject generateDocumentReaderScenario(DocumentReaderScenarioFull documentReaderScenario) throws JSONException {
+    static <T, V> JSONObject generateMap(Map<T, V> map, JSONObjectGeneratorWithContext<V> generator, Context context) throws JSONException {
         JSONObject result = new JSONObject();
-        result.put("name", documentReaderScenario.name);
-        result.put("caption", documentReaderScenario.caption);
-        result.put("description", documentReaderScenario.description);
-        result.put("uvTorch", documentReaderScenario.uvTorch);
-        result.put("seriesProcessMode", documentReaderScenario.seriesProcessMode);
-        result.put("multiPageOff", documentReaderScenario.multiPageOff);
-        result.put("frameKWHLandscape", documentReaderScenario.frameKWHLandscape);
-        result.put("frameKWHPortrait", documentReaderScenario.frameKWHPortrait);
-        result.put("frameKWHDoublePageSpreadPortrait", documentReaderScenario.frameKWHDoublePageSpreadPortrait);
-        result.put("frameKWHDoublePageSpreadLandscape", documentReaderScenario.frameKWHDoublePageSpreadLandscape);
-        result.put("frameOrientation", documentReaderScenario.frameOrientation);
-        result.put("faceExt", documentReaderScenario.faceExt);
+        if(map == null) return result;
+        for (Map.Entry<T, V> entry : map.entrySet())
+            if (entry != null)
+                result.put(entry.getKey().toString(), generator.generateJSONObject(entry.getValue(), context));
+        return result;
+    }
+
+    static JSONArray generateIntArray(int[] array) throws JSONException {
+        JSONArray result = new JSONArray();
+        if(array == null) return result;
+        for (int i = 0; i < array.length; i++)
+            result.put(i, array[i]);
 
         return result;
     }
 
-    static private JSONObject generateDocumentReaderNotification(DocumentReaderNotification documentReaderNotification) throws JSONException {
-        JSONObject result = new JSONObject();
-        result.put("code", documentReaderNotification.code & 0xFFFF0000);
-        result.put("number", documentReaderNotification.code & 0x0000FFFF);
-        result.put("value", documentReaderNotification.value);
+    static JSONArray generateBooleanArray(boolean[] array) throws JSONException {
+        JSONArray result = new JSONArray();
+        if(array == null) return result;
+        for (int i = 0; i < array.length; i++)
+            result.put(i, array[i]);
 
         return result;
     }
 
-    static private JSONObject generateDocumentReaderDocumentType(DocumentReaderDocumentType documentReaderDocumentType, Context context) throws JSONException {
-        JSONObject documentType = new JSONObject();
-        documentType.put("dFormat", documentReaderDocumentType.dFormat);
-        documentType.put("dMRZ", documentReaderDocumentType.dMRZ);
-        documentType.put("documentID", documentReaderDocumentType.documentID);
-        documentType.put("dType", documentReaderDocumentType.dType);
-        documentType.put("dCountryName", documentReaderDocumentType.dCountryName);
-        documentType.put("dDescription", documentReaderDocumentType.dDescription);
-        documentType.put("dYear", documentReaderDocumentType.dYear);
-        documentType.put("ICAOCode", documentReaderDocumentType.ICAOCode);
-        documentType.put("name", documentReaderDocumentType.name);
-        documentType.put("pageIndex", documentReaderDocumentType.pageIndex);
-        if (documentReaderDocumentType.FDSID != null)
-            documentType.put("FDSID", generateIntArray(documentReaderDocumentType.FDSID));
+    static JSONArray generateDoubleArray(double[] array) throws JSONException {
+        JSONArray result = new JSONArray();
+        if(array == null) return result;
+        for (int i = 0; i < array.length; i++)
+            result.put(i, array[i]);
 
-        return documentType;
+        return result;
     }
 
-    static private JSONObject generateDocumentReaderGraphicResult(DocumentReaderGraphicResult documentReaderGraphicResult, Context context) throws JSONException {
-        return new JSONObject().put("fields", generateList(documentReaderGraphicResult.fields, JSONConstructor::generateDocumentReaderGraphicField, context));
+    static JSONArray generateByteArray(byte[] array) throws JSONException {
+        JSONArray result = new JSONArray();
+        if(array == null) return result;
+        for (int i = 0; i < array.length; i++)
+            result.put(i, array[i]);
+
+        return result;
     }
 
-    static private JSONObject generateDocumentReaderGraphicField(DocumentReaderGraphicField documentReaderGraphicField, Context context) throws JSONException {
-        JSONObject result = new JSONObject();
-        result.put("sourceType", documentReaderGraphicField.sourceType);
-        result.put("fieldType", documentReaderGraphicField.fieldType);
-        result.put("fieldName", eGraphicFieldType.getTranslation(context, documentReaderGraphicField.fieldType));
-        result.put("lightType", documentReaderGraphicField.light);
-        result.put("lightName", eRPRM_Lights.getTranslation(context, documentReaderGraphicField.light));
-        result.put("pageIndex", documentReaderGraphicField.pageIndex);
-        result.put("value", documentReaderGraphicField.imageBase64());
-        if (documentReaderGraphicField.boundRect != null)
-            result.put("fieldRect", generateDocReaderFieldRect(documentReaderGraphicField.boundRect));
+    static JSONArray generateLongArray(long[] array) throws JSONException {
+        JSONArray result = new JSONArray();
+        if(array == null) return result;
+        for (int i = 0; i < array.length; i++)
+            result.put(i, array[i]);
 
         return result;
     }
 
-    static String bitmapToBase64String(Bitmap bitmap) {
+    static String generateBitmap(Bitmap bitmap) {
+        if (bitmap == null) return "";
         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
         bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream);
         byte[] byteArray = byteArrayOutputStream.toByteArray();
@@ -270,555 +243,1905 @@ class JSONConstructor {
         return Base64.encodeToString(byteArray, Base64.DEFAULT);
     }
 
-    static private JSONObject generateDocReaderFieldRect(DocReaderFieldRect rect) throws JSONException {
-        JSONObject result = new JSONObject();
-        result.put("bottom", rect.bottom);
-        result.put("top", rect.top);
-        result.put("left", rect.left);
-        result.put("right", rect.right);
-
+    static Bitmap BitmapFromJSON(String base64) {
+        byte[] decodedString = Base64.decode(base64, Base64.DEFAULT);
+        BitmapFactory.Options options = new BitmapFactory.Options();
+        options.inPreferredConfig = Bitmap.Config.RGB_565;
+        Bitmap result = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length, options);
+        int sizeMultiplier = result.getByteCount() / 5000000;
+        if (result.getByteCount() > 5000000)
+            result = Bitmap.createScaledBitmap(result, result.getWidth() / (int) Math.sqrt(sizeMultiplier), result.getHeight() / (int) Math.sqrt(sizeMultiplier), false);
         return result;
     }
 
-    static private JSONObject generateImageQualityGroup(ImageQualityGroup imageQualityGroup, Context context) throws JSONException {
+    static JSONObject generateVideoEncoderCompletion(String sessionId, java.io.File file) {
         JSONObject result = new JSONObject();
-        result.put("result", imageQualityGroup.result);
-        result.put("count", imageQualityGroup.count);
-        result.put("imageQualityList", generateList(imageQualityGroup.imageQualityList, JSONConstructor::generateImageQuality, context));
+
+        try {
+            result.put("sessionId", sessionId);
+            result.put("filePath", file.getPath());
+
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
 
         return result;
     }
 
-    static private JSONObject generateImageQuality(ImageQuality imageQuality, Context context) throws JSONException {
+    static JSONObject generateCompletion(int action, DocumentReaderResults results, DocumentReaderException error, Context context) {
         JSONObject result = new JSONObject();
-        result.put("result", imageQuality.result);
-        result.put("type", imageQuality.type);
-        result.put("featureType", imageQuality.featureType);
+        try {
+            result.put("action", action);
+            switch (action) {
+                case DocReaderAction.PROCESS:
+                case DocReaderAction.PROCESS_WHITE_UV_IMAGES:
+                    break;
+                case DocReaderAction.NOTIFICATION:
+                    result.put("results", generateDocumentReaderResultsNotification(results));
+                    break;
+                case DocReaderAction.COMPLETE:
+                case DocReaderAction.MORE_PAGES_AVAILABLE:
+                case DocReaderAction.CANCEL:
+                case DocReaderAction.ERROR:
+                    result.put("results", generateDocumentReaderResults(results, context));
+                    break;
+            }
+            if (error != null)
+                result.put("error", generateDocumentReaderException(error));
+        } catch (JSONException ignored) {
+        }
 
         return result;
     }
 
-    static private JSONObject generateRfidSessionData(RFIDSessionData rfidSessionData, Context context) throws JSONException {
+    static JSONObject generatePACertificateCompletion(byte[] serialNumber, PAResourcesIssuer issuer) {
         JSONObject result = new JSONObject();
-        result.put("totalBytesSent", rfidSessionData.totalBytesSent);
-        result.put("totalBytesReceived", rfidSessionData.totalBytesReceived);
-        result.put("status", rfidSessionData.status);
-        result.put("processTime", rfidSessionData.processTime);
-        result.put("extLeSupport", rfidSessionData.extLeSupport);
-        result.put("accessControls", generateList(rfidSessionData.accessControls, JSONConstructor::generateAccessControlProcedureType, context));
-        result.put("applications", generateList(rfidSessionData.applications, JSONConstructor::generateApplication, context));
-        result.put("securityObjects", generateList(rfidSessionData.securityObjects, JSONConstructor::generateSecurityObject, context));
-        if (rfidSessionData.cardProperties != null)
-            result.put("cardProperties", generateCardProperties(rfidSessionData.cardProperties));
-        if (rfidSessionData.sessionDataStatus != null)
-            result.put("sessionDataStatus", generateRFIDSessionDataStatus(rfidSessionData.sessionDataStatus));
+        try {
+            result.put("serialNumber", generateByteArray(serialNumber));
+            result.put("issuer", generatePAResourcesIssuer(issuer));
+        } catch (JSONException ignored) {
+        }
 
         return result;
     }
 
-    static private JSONObject generateRFIDSessionDataStatus(RFIDSessionDataStatus input) throws JSONException {
-        JSONObject result = new JSONObject();
-        result.put("AA", input.AA);
-        result.put("BAC", input.BAC);
-        result.put("CA", input.CA);
-        result.put("PA", input.PA);
-        result.put("PACE", input.PACE);
-        result.put("TA", input.TA);
-        result.put("overallStatus", input.overallStatus);
+    static JSONObject generateDocumentReaderResultsNotification(DocumentReaderResults results) throws JSONException {
+        if (results != null && results.documentReaderNotification != null)
+            return new JSONObject().put("documentReaderNotification", generateDocumentReaderNotification(results.documentReaderNotification));
+        return new JSONObject();
+    }
 
+    static DocumentReaderNotification DocumentReaderNotificationFromJSON(JSONObject jsonObject) {
+        DocumentReaderNotification result = new DocumentReaderNotification();
+        try {
+            if (jsonObject.has("value"))
+                result.value = jsonObject.getInt("value");
+        } catch (JSONException ignored) {
+        }
         return result;
     }
 
-    static private JSONObject generateAccessControlProcedureType(AccessControlProcedureType type, Context context) throws JSONException {
-        JSONObject accessControl = new JSONObject();
-        accessControl.put("activeOptionIdx", type.activeOptionIdx);
-        accessControl.put("status", type.status);
-        accessControl.put("type", type.type);
-        accessControl.put("notifications", generateList(type.notifications));
+    static Throwable ThrowableFromJSON(JSONObject jsonObject) {
+        return new Throwable();
+    }
 
-        return accessControl;
+    static StackTraceElement StackTraceElementFromJSON(JSONObject jsonObject) {
+        return null;
     }
 
-    static private JSONObject generateApplication(Application application, Context context) throws JSONException {
-        JSONObject result = new JSONObject();
-        result.put("status", application.status);
-        result.put("type", application.type);
-        result.put("applicationID", application.applicationID);
-        result.put("dataHashAlgorithm", application.dataHashAlgorithm);
-        result.put("unicodeVersion", application.unicodeVersion);
-        result.put("version", application.version);
-        result.put("files", generateList(application.files, JSONConstructor::generateFile, context));
+    // To JSON
 
+    static JSONObject generateDocumentReaderScenario(DocumentReaderScenario input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("uvTorch", input.uvTorch);
+            result.put("seriesProcessMode", input.seriesProcessMode);
+            result.put("name", input.name);
+            result.put("caption", input.caption);
+            result.put("description", input.description);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateFile(File file, Context context) throws JSONException {
+    static JSONObject generateDocumentReaderScenarioFull(DocumentReaderScenarioFull input) {
         JSONObject result = new JSONObject();
-        result.put("fileID", file.fileID);
-        result.put("pAStatus", file.pAStatus);
-        result.put("readingStatus", file.readingStatus);
-        result.put("readingTime", file.readingTime);
-        result.put("type", file.type);
-        result.put("docFieldsText", generateList(file.docFieldsText));
-        result.put("notifications", generateList(file.notifications));
-        result.put("docFieldsGraphics", generateList(file.docFieldsGraphics));
-        result.put("docFieldsOriginals", generateList(file.docFieldsOriginals));
-        if (file.certificates != null)
-            result.put("certificates", generateSecurityObjectCertificates(file.certificates));
-        if (file.fileData != null)
-            result.put("fileData", generateFileData(file.fileData));
-
+        if (input == null) return result;
+        try {
+            result.put("uvTorch", input.uvTorch);
+            result.put("frameOrientation", input.frameOrientation);
+            result.put("faceExt", input.faceExt);
+            result.put("multiPageOff", input.multiPageOff);
+            result.put("seriesProcessMode", input.seriesProcessMode);
+            result.put("frameKWHLandscape", input.frameKWHLandscape);
+            result.put("frameKWHPortrait", input.frameKWHPortrait);
+            result.put("frameKWHDoublePageSpreadPortrait", input.frameKWHDoublePageSpreadPortrait);
+            result.put("frameKWHDoublePageSpreadLandscape", input.frameKWHDoublePageSpreadLandscape);
+            result.put("name", input.name);
+            result.put("caption", input.caption);
+            result.put("description", input.description);
+            result.put("manualCrop", input.manualCrop);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateSecurityObjectCertificates(SecurityObjectCertificates securityObjectCertificates) throws JSONException {
+    static JSONObject generateFaceMetaData(FaceMetaData input) {
         JSONObject result = new JSONObject();
-        if (securityObjectCertificates.securityObject != null)
-            result.put("securityObject", generateCertificateData(securityObjectCertificates.securityObject));
+        if (input == null) return result;
+        try {
+            result.put("ID", input.ID);
+            result.put("rollAngle", input.rollAngle);
+            result.put("bounds", generateBounds(input.bounds));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateCertificateData(CertificateData certificateData) throws JSONException {
+    static JSONObject generateBounds(Bounds input) {
         JSONObject result = new JSONObject();
-        result.put("length", certificateData.length);
-        result.put("data", certificateData.data);
-
+        if (input == null) return result;
+        try {
+            result.put("x", input.x);
+            result.put("y", input.y);
+            result.put("width", input.width);
+            result.put("height", input.height);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateFileData(FileData fileData) throws JSONException {
+    static JSONObject generateRect(Rect input) {
         JSONObject result = new JSONObject();
-        result.put("length", fileData.length);
-        result.put("status", fileData.status);
-        result.put("type", fileData.type);
-        result.put("data", fileData.data);
-
+        if (input == null) return result;
+        try {
+            result.put("bottom", input.bottom);
+            result.put("top", input.top);
+            result.put("left", input.left);
+            result.put("right", input.right);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateCardProperties(CardProperties cardProperties) throws JSONException {
+    static JSONObject generateDocReaderFieldRect(DocReaderFieldRect input) {
         JSONObject result = new JSONObject();
-        result.put("aTQA", cardProperties.aTQA);
-        result.put("bitRateR", cardProperties.bitRateR);
-        result.put("bitRateS", cardProperties.bitRateS);
-        result.put("chipTypeA", cardProperties.chipTypeA);
-        result.put("mifareMemory", cardProperties.mifareMemory);
-        result.put("rfidType", cardProperties.rfidType);
-        result.put("sAK", cardProperties.sAK);
-        result.put("support4", cardProperties.support4);
-        result.put("supportMifare", cardProperties.supportMifare);
-        result.put("aTQB", cardProperties.aTQB);
-        result.put("aTR", cardProperties.aTR);
-        result.put("baudrate1", cardProperties.baudrate1);
-        result.put("baudrate2", cardProperties.baudrate2);
-        result.put("uID", cardProperties.uID);
-
+        if (input == null) return result;
+        try {
+            result.put("bottom", input.bottom);
+            result.put("top", input.top);
+            result.put("left", input.left);
+            result.put("right", input.right);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateSecurityObject(SecurityObject securityObject, Context context) throws JSONException {
+    static JSONObject generateDocumentReaderGraphicField(DocumentReaderGraphicField input, Context context) {
         JSONObject result = new JSONObject();
-        result.put("objectType", securityObject.objectType);
-        result.put("fileReference", securityObject.fileReference);
-        result.put("version", securityObject.version);
-        result.put("notifications", generateList(securityObject.notifications));
-        result.put("signerInfos", generateList(securityObject.signerInfos, JSONConstructor::generateSignerInfo, context));
-
+        if (input == null) return result;
+        try {
+            result.put("sourceType", input.sourceType);
+            result.put("fieldType", input.fieldType);
+            result.put("lightType", input.light);
+            result.put("pageIndex", input.pageIndex);
+            result.put("fieldName", eGraphicFieldType.getTranslation(context, input.fieldType));
+            result.put("lightName", eRPRM_Lights.getTranslation(context, input.light));
+            result.put("value", input.imageBase64());
+            result.put("fieldRect", generateDocReaderFieldRect(input.boundRect));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateAttribute(Attribute attribute, Context context) throws JSONException {
+    static JSONObject generateDocumentReaderGraphicResult(DocumentReaderGraphicResult input, Context context) {
         JSONObject result = new JSONObject();
-        if (attribute.value != null)
-            result.put("value", generateValue(attribute.value));
-        result.put("type", attribute.type);
-
+        if (input == null) return result;
+        try {
+            result.put("fields", generateList(input.fields, JSONConstructor::generateDocumentReaderGraphicField, context));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateExtension(Extension extension, Context context) throws JSONException {
+    static JSONObject generateDocumentReaderValue(DocumentReaderValue input) {
         JSONObject result = new JSONObject();
-        result.put("data", extension.data);
-        result.put("type", extension.type);
-
+        if (input == null) return result;
+        try {
+            result.put("pageIndex", input.pageIndex);
+            result.put("sourceType", input.sourceType);
+            result.put("validity", input.validity);
+            result.put("probability", input.probability);
+            result.put("value", input.value);
+            result.put("originalValue", input.originalValue);
+            result.put("boundRect", generateRect(input.boundRect));
+            result.put("comparison", generateMap(input.comparison));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateCertificateChain(CertificateChain certificateChain, Context context) throws JSONException {
+    static JSONObject generateDocumentReaderTextField(DocumentReaderTextField input, Context context) {
         JSONObject result = new JSONObject();
-        result.put("origin", certificateChain.origin);
-        result.put("paStatus", certificateChain.paStatus);
-        result.put("type", certificateChain.type);
-        result.put("version", certificateChain.version);
-        result.put("serialNumber", certificateChain.serialNumber);
-        result.put("signatureAlgorithm", certificateChain.signatureAlgorithm);
-        result.put("subjectPKAlgorithm", certificateChain.subjectPKAlgorithm);
-        result.put("notifications", generateList(certificateChain.notifications));
-        result.put("extensions", generateList(certificateChain.extensions, JSONConstructor::generateExtension, context));
-        if (certificateChain.fileName != null)
-            result.put("fileName", generateValue(certificateChain.fileName));
-        if (certificateChain.subject != null)
-            result.put("subject", generateAuthority(certificateChain.subject, context));
-        if (certificateChain.issuer != null)
-            result.put("issuer", generateAuthority(certificateChain.issuer, context));
-        if (certificateChain.validity != null)
-            result.put("validity", generateValidity(certificateChain.validity));
-
+        if (input == null) return result;
+        try {
+            result.put("fieldType", input.fieldType);
+            result.put("lcid", input.lcid);
+            result.put("status", input.status);
+            result.put("lcidName", input.getLcidName(context));
+            result.put("fieldName", input.getFieldName(context));
+            result.put("value", generateDocumentReaderValue(input.value()));
+            result.put("values", generateList(input.values, JSONConstructor::generateDocumentReaderValue));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateValue(Value value) throws JSONException {
+    static JSONObject generateDocumentReaderTextResult(DocumentReaderTextResult input, Context context) {
         JSONObject result = new JSONObject();
-        result.put("data", value.data);
-        result.put("length", value.length);
-        result.put("status", value.status);
-        result.put("type", value.type);
-        result.put("format", value.format);
-
+        if (input == null) return result;
+        try {
+            result.put("status", input.status);
+            result.put("fields", generateList(input.fields, JSONConstructor::generateDocumentReaderTextField, context));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateAuthority(Authority authority, Context context) throws JSONException {
+    static JSONObject generateCoordinate(Coordinate input) {
         JSONObject result = new JSONObject();
-        result.put("data", authority.data);
-        result.put("attributes", generateList(authority.attributes, JSONConstructor::generateAttribute, context));
-        if (authority.friendlyName != null)
-            result.put("friendlyName", generateValue(authority.friendlyName));
-
+        if (input == null) return result;
+        try {
+            result.put("x", input.x);
+            result.put("y", input.y);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateValidity(Validity validity) throws JSONException {
+    static JSONObject generateElementPosition(ElementPosition input) {
         JSONObject result = new JSONObject();
-        if (validity.notAfter != null)
-            result.put("notAfter", generateValue(validity.notAfter));
-        if (validity.notBefore != null)
-            result.put("notBefore", generateValue(validity.notBefore));
-
+        if (input == null) return result;
+        try {
+            result.put("docFormat", input.docFormat);
+            result.put("width", input.width);
+            result.put("height", input.height);
+            result.put("dpi", input.dpi);
+            result.put("pageIndex", input.pageIndex);
+            result.put("inverse", input.inverse);
+            result.put("perspectiveTr", input.perspectiveTr);
+            result.put("objArea", input.objArea);
+            result.put("objIntAngleDev", input.objIntAngleDev);
+            result.put("resultStatus", input.resultStatus);
+            result.put("angle", input.angle);
+            result.put("center", generateCoordinate(input.center));
+            result.put("leftTop", generateCoordinate(input.leftTop));
+            result.put("leftBottom", generateCoordinate(input.leftBottom));
+            result.put("rightTop", generateCoordinate(input.rightTop));
+            result.put("rightBottom", generateCoordinate(input.rightBottom));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateSignerInfo(SignerInfo signerInfo, Context context) throws JSONException {
+    static JSONObject generateImageQuality(ImageQuality input) {
         JSONObject result = new JSONObject();
-        result.put("paStatus", signerInfo.paStatus);
-        result.put("version", signerInfo.version);
-        result.put("dataToHash", signerInfo.dataToHash);
-        result.put("digestAlgorithm", signerInfo.digestAlgorithm);
-        result.put("signatureAlgorithm", signerInfo.signatureAlgorithm);
-        result.put("certificateChain", generateList(signerInfo.certificateChain, JSONConstructor::generateCertificateChain, context));
-        result.put("notifications", generateList(signerInfo.notifications));
-        result.put("signedAttributes", generateList(signerInfo.signedAttributes, JSONConstructor::generateExtension, context));
-        if (signerInfo.signature != null)
-            result.put("signature", generateValue(signerInfo.signature));
-        if (signerInfo.serialNumber != null)
-            result.put("serialNumber", generateValue(signerInfo.serialNumber));
-        if (signerInfo.subjectKeyIdentifier != null)
-            result.put("subjectKeyIdentifier", generateValue(signerInfo.subjectKeyIdentifier));
-        if (signerInfo.issuer != null)
-            result.put("issuer", generateAuthority(signerInfo.issuer, context));
-
+        if (input == null) return result;
+        try {
+            result.put("featureType", input.featureType);
+            result.put("result", input.result);
+            result.put("type", input.type);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateDocumentReaderTextResult(DocumentReaderTextResult documentReaderTextResult, Context context) throws JSONException {
+    static JSONObject generateImageQualityGroup(ImageQualityGroup input) {
         JSONObject result = new JSONObject();
-        result.put("status", documentReaderTextResult.status);
-        result.put("fields", generateList(documentReaderTextResult.fields, JSONConstructor::generateDocumentReaderTextField, context));
-
+        if (input == null) return result;
+        try {
+            result.put("count", input.count);
+            result.put("result", input.result);
+            result.put("imageQualityList", generateList(input.imageQualityList, JSONConstructor::generateImageQuality));
+            result.put("pageIndex", input.pageIndex);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateDocumentReaderTextField(DocumentReaderTextField documentReaderTextField, Context context) throws JSONException {
+    static JSONObject generateDocumentReaderDocumentType(DocumentReaderDocumentType input) {
         JSONObject result = new JSONObject();
-        result.put("fieldType", documentReaderTextField.fieldType);
-        result.put("lcid", documentReaderTextField.lcid);
-        result.put("lcidName", documentReaderTextField.getLcidName(context));
-        result.put("status", documentReaderTextField.status);
-        result.put("fieldName", documentReaderTextField.getFieldName(context));
-        result.put("values", generateList(documentReaderTextField.values, JSONConstructor::generateDocumentReaderValue, context));
-        if (documentReaderTextField.value() != null)
-            result.put("value", generateDocumentReaderValue(Objects.requireNonNull(documentReaderTextField.value()), context));
-
+        if (input == null) return result;
+        try {
+            result.put("pageIndex", input.pageIndex);
+            result.put("documentID", input.documentID);
+            result.put("dType", input.dType);
+            result.put("dFormat", input.dFormat);
+            result.put("dMRZ", input.dMRZ);
+            result.put("name", input.name);
+            result.put("ICAOCode", input.ICAOCode);
+            result.put("dDescription", input.dDescription);
+            result.put("dYear", input.dYear);
+            result.put("dCountryName", input.dCountryName);
+            result.put("FDSID", generateIntArray(input.FDSID));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateDocumentReaderValue(DocumentReaderValue documentReaderValue, Context context) throws JSONException {
+    static JSONObject generateDocumentReaderNotification(DocumentReaderNotification input) {
         JSONObject result = new JSONObject();
-        result.put("pageIndex", documentReaderValue.pageIndex);
-        result.put("sourceType", documentReaderValue.sourceType);
-        result.put("validity", documentReaderValue.validity);
-        result.put("value", documentReaderValue.value);
-        result.put("originalValue", documentReaderValue.originalValue);
-        result.put("probability", documentReaderValue.probability);
-        result.put("comparison", generateMapIntegerInteger(documentReaderValue.comparison));
-        if (documentReaderValue.boundRect != null)
-            result.put("boundRect", generateRect(documentReaderValue.boundRect));
-
+        if (input == null) return result;
+        try {
+            result.put("code", input.code & 0xFFFF0000);
+            result.put("number", input.code & 0x0000FFFF);
+            result.put("value", input.value);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateRect(Rect rect) throws JSONException {
+    static JSONObject generateAccessControlProcedureType(AccessControlProcedureType input) {
         JSONObject result = new JSONObject();
-        result.put("bottom", rect.bottom);
-        result.put("left", rect.left);
-        result.put("top", rect.top);
-        result.put("right", rect.right);
-
+        if (input == null) return result;
+        try {
+            result.put("activeOptionIdx", input.activeOptionIdx);
+            result.put("type", input.type);
+            result.put("status", input.status);
+            result.put("notifications", generateList(input.notifications));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateMapIntegerInteger(Map<Integer, Integer> map) throws JSONException {
+    static JSONObject generateFileData(FileData input) {
         JSONObject result = new JSONObject();
-        for (Map.Entry<Integer, Integer> entry : map.entrySet())
-            if (entry != null)
-                result.put(entry.getKey().toString(), entry.getValue());
+        if (input == null) return result;
+        try {
+            result.put("length", input.length);
+            result.put("type", input.type);
+            result.put("status", input.status);
+            result.put("data", input.data);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateDocumentReaderAuthenticityResult(DocumentReaderAuthenticityResult documentReaderAuthenticityResult, Context context) throws JSONException {
+    static JSONObject generateCertificateData(CertificateData input) {
         JSONObject result = new JSONObject();
-        result.put("status", documentReaderAuthenticityResult.getStatus());
-        result.put("checks", generateList(documentReaderAuthenticityResult.checks, JSONConstructor::generateDocumentReaderAuthenticityCheck, context));
-
+        if (input == null) return result;
+        try {
+            result.put("length", input.length);
+            result.put("data", input.data);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateDocumentReaderAuthenticityCheck(DocumentReaderAuthenticityCheck documentReaderAuthenticityCheck, Context context) throws JSONException {
+    static JSONObject generateSecurityObjectCertificates(SecurityObjectCertificates input) {
         JSONObject result = new JSONObject();
-        result.put("type", documentReaderAuthenticityCheck.type);
-        result.put("typeName", documentReaderAuthenticityCheck.getTypeName(context));
-        result.put("pageIndex", documentReaderAuthenticityCheck.pageIndex);
-        result.put("elements", generateList(documentReaderAuthenticityCheck.elements, JSONConstructor::generateDocumentReaderAuthenticityElement, context));
-        result.put("status", documentReaderAuthenticityCheck.getStatus());
-
+        if (input == null) return result;
+        try {
+            result.put("securityObject", generateCertificateData(input.securityObject));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateDocumentReaderAuthenticityElement(DocumentReaderAuthenticityElement documentReaderAuthenticityElement, Context context) throws JSONException {
+    static JSONObject generateFile(File input) {
         JSONObject result = new JSONObject();
-        result.put("status", documentReaderAuthenticityElement.status);
-        result.put("elementType", documentReaderAuthenticityElement.elementType);
-        result.put("elementTypeName", documentReaderAuthenticityElement.getElementTypeName(context));
-        result.put("elementDiagnose", documentReaderAuthenticityElement.elementDiagnose);
-        result.put("elementDiagnoseName", documentReaderAuthenticityElement.getElementDiagnoseName(context));
-
+        if (input == null) return result;
+        try {
+            result.put("readingTime", input.readingTime);
+            result.put("type", input.type);
+            result.put("pAStatus", input.pAStatus);
+            result.put("readingStatus", input.readingStatus);
+            result.put("fileID", input.fileID);
+            result.put("fileData", generateFileData(input.fileData));
+            result.put("certificates", generateSecurityObjectCertificates(input.certificates));
+            result.put("docFieldsText", generateList(input.docFieldsText));
+            result.put("docFieldsGraphics", generateList(input.docFieldsGraphics));
+            result.put("docFieldsOriginals", generateList(input.docFieldsOriginals));
+            result.put("notifications", generateList(input.notifications));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateDocumentReaderBarcodeResult(DocumentReaderBarcodeResult documentReaderBarcodeResult, Context context) throws JSONException {
-        return new JSONObject().put("fields", generateList(documentReaderBarcodeResult.fields, JSONConstructor::generateDocumentReaderBarcodeField, context));
+    static JSONObject generateApplication(Application input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("type", input.type);
+            result.put("status", input.status);
+            result.put("applicationID", input.applicationID);
+            result.put("dataHashAlgorithm", input.dataHashAlgorithm);
+            result.put("unicodeVersion", input.unicodeVersion);
+            result.put("version", input.version);
+            result.put("files", generateList(input.files, JSONConstructor::generateFile));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return result;
     }
 
-    static private JSONObject generateDocumentReaderBarcodeField(DocumentReaderBarcodeField documentReaderBarcodeField, Context context) throws JSONException {
+    static JSONObject generateValue(Value input) {
         JSONObject result = new JSONObject();
-        result.put("barcodeType", documentReaderBarcodeField.barcodeType);
-        result.put("status", documentReaderBarcodeField.status);
-        result.put("pageIndex", documentReaderBarcodeField.pageIndex);
-        if (documentReaderBarcodeField.pdf417Info != null)
-            result.put("pdf417Info", generatePDF417Info(documentReaderBarcodeField.pdf417Info));
-        if (documentReaderBarcodeField.data != null)
-            result.put("data", generateByteArray(documentReaderBarcodeField.data));
-
+        if (input == null) return result;
+        try {
+            result.put("length", input.length);
+            result.put("type", input.type);
+            result.put("status", input.status);
+            result.put("data", input.data);
+            result.put("format", input.format);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generatePDF417Info(PDF417Info pdf417Info) throws JSONException {
+    static JSONObject generateAttribute(Attribute input) {
         JSONObject result = new JSONObject();
-        result.put("errorLevel", pdf417Info.errorLevel);
-        result.put("columns", pdf417Info.columns);
-        result.put("rows", pdf417Info.rows);
-
+        if (input == null) return result;
+        try {
+            result.put("type", input.type);
+            result.put("value", generateValue(input.value));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static JSONObject generateFaceMetaData(FaceMetaData faceMetaData, @SuppressWarnings("unused") Context context) throws JSONException {
+    static JSONObject generateAuthority(Authority input) {
         JSONObject result = new JSONObject();
-        result.put("ID", faceMetaData.ID);
-        result.put("rollAngle", faceMetaData.rollAngle);
-        result.put("bounds", generateBounds(faceMetaData.bounds));
-
+        if (input == null) return result;
+        try {
+            result.put("data", input.data);
+            result.put("friendlyName", generateValue(input.friendlyName));
+            result.put("attributes", generateList(input.attributes, JSONConstructor::generateAttribute));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static private JSONObject generateBounds(Bounds bounds) throws JSONException {
+    static JSONObject generateExtension(Extension input) {
         JSONObject result = new JSONObject();
-        result.put("height", bounds.height);
-        result.put("width", bounds.width);
-        result.put("x", bounds.x);
-        result.put("y", bounds.y);
-
+        if (input == null) return result;
+        try {
+            result.put("data", input.data);
+            result.put("type", input.type);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static JSONArray generateIntArray(int[] array) throws JSONException {
-        JSONArray result = new JSONArray();
-        for (int i = 0; i < array.length; i++)
-            result.put(i, array[i]);
-
+    static JSONObject generateValidity(Validity input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("notAfter", generateValue(input.notAfter));
+            result.put("notBefore", generateValue(input.notBefore));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static JSONArray generateByteArray(byte[] array) throws JSONException {
-        JSONArray result = new JSONArray();
-        for (int i = 0; i < array.length; i++)
-            result.put(i, array[i]);
-
+    static JSONObject generateCertificateChain(CertificateChain input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("origin", input.origin);
+            result.put("type", input.type);
+            result.put("version", input.version);
+            result.put("paStatus", input.paStatus);
+            result.put("serialNumber", input.serialNumber);
+            result.put("signatureAlgorithm", input.signatureAlgorithm);
+            result.put("subjectPKAlgorithm", input.subjectPKAlgorithm);
+            result.put("fileName", generateValue(input.fileName));
+            result.put("validity", generateValidity(input.validity));
+            result.put("issuer", generateAuthority(input.issuer));
+            result.put("subject", generateAuthority(input.subject));
+            result.put("notifications", generateList(input.notifications));
+            result.put("extensions", generateList(input.extensions, JSONConstructor::generateExtension));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static JSONObject generateCompletion(int action, DocumentReaderResults results, Throwable error, Context context) {
+    static JSONObject generateSignerInfo(SignerInfo input) {
         JSONObject result = new JSONObject();
+        if (input == null) return result;
         try {
-            result.put("action", action);
-            switch (action) {
-                case DocReaderAction.PROCESS:
-                case DocReaderAction.PROCESS_WHITE_UV_IMAGES:
-                    result.put("results", "");
-                    break;
-                case DocReaderAction.NOTIFICATION:
-                    result.put("results", resultsToJsonObjectNotification(results));
-                    break;
-                case DocReaderAction.COMPLETE:
-                case DocReaderAction.MORE_PAGES_AVAILABLE:
-                case DocReaderAction.CANCEL:
-                case DocReaderAction.ERROR:
-                    result.put("results", resultsToJsonObject(results, context));
-                    break;
-            }
-            result.put("error", generateThrowable(error, context));
-        } catch (JSONException ignored) {
+            result.put("version", input.version);
+            result.put("paStatus", input.paStatus);
+            result.put("dataToHash", input.dataToHash);
+            result.put("digestAlgorithm", input.digestAlgorithm);
+            result.put("signatureAlgorithm", input.signatureAlgorithm);
+            result.put("serialNumber", generateValue(input.serialNumber));
+            result.put("signature", generateValue(input.signature));
+            result.put("subjectKeyIdentifier", generateValue(input.subjectKeyIdentifier));
+            result.put("issuer", generateAuthority(input.issuer));
+            result.put("notifications", generateList(input.notifications));
+            result.put("signedAttributes", generateList(input.signedAttributes, JSONConstructor::generateExtension));
+            result.put("certificateChain", generateList(input.certificateChain, JSONConstructor::generateCertificateChain));
+        } catch (JSONException e) {
+            e.printStackTrace();
         }
-
         return result;
     }
 
-    static JSONObject generateThrowable(Throwable throwable, Context context) throws JSONException {
+    static JSONObject generateSecurityObject(SecurityObject input) {
         JSONObject result = new JSONObject();
-        if (throwable == null)
-            return result;
-        result.put("localizedMessage", throwable.getLocalizedMessage());
-        result.put("message", throwable.getMessage());
-        result.put("string", throwable.toString());
-        result.put("stackTrace", generateArray(throwable.getStackTrace(), JSONConstructor::generateStackTraceElement, context));
-
+        if (input == null) return result;
+        try {
+            result.put("fileReference", input.fileReference);
+            result.put("version", input.version);
+            result.put("objectType", input.objectType);
+            result.put("notifications", generateList(input.notifications));
+            result.put("signerInfos", generateList(input.signerInfos, JSONConstructor::generateSignerInfo));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static JSONObject generateStackTraceElement(StackTraceElement e, Context context) throws JSONException {
+    static JSONObject generateCardProperties(CardProperties input) {
         JSONObject result = new JSONObject();
-        if (e == null)
-            return result;
-        result.put("className", e.getClassName());
-        result.put("fileName", e.getFileName());
-        result.put("lineNumber", e.getLineNumber());
-        result.put("methodName", e.getMethodName());
-        result.put("isNativeMethod", e.isNativeMethod());
-        result.put("string", e.toString());
-
+        if (input == null) return result;
+        try {
+            result.put("aTQA", input.aTQA);
+            result.put("bitRateR", input.bitRateR);
+            result.put("bitRateS", input.bitRateS);
+            result.put("chipTypeA", input.chipTypeA);
+            result.put("mifareMemory", input.mifareMemory);
+            result.put("rfidType", input.rfidType);
+            result.put("sAK", input.sAK);
+            result.put("support4", input.support4);
+            result.put("supportMifare", input.supportMifare);
+            result.put("aTQB", input.aTQB);
+            result.put("aTR", input.aTR);
+            result.put("baudrate1", input.baudrate1);
+            result.put("baudrate2", input.baudrate2);
+            result.put("uID", input.uID);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    // From JSON
-
-    static Bitmap bitmapFromBase64(String base64) {
-        byte[] decodedString = Base64.decode(base64, Base64.DEFAULT);
-        BitmapFactory.Options options = new BitmapFactory.Options();
-        options.inPreferredConfig = Bitmap.Config.RGB_565;
-        Bitmap result = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length, options);
-        int sizeMultiplier = result.getByteCount() / 5000000;
-        if (result.getByteCount() > 5000000)
-            result = Bitmap.createScaledBitmap(result, result.getWidth() / (int) Math.sqrt(sizeMultiplier), result.getHeight() / (int) Math.sqrt(sizeMultiplier), false);
+    static JSONObject generateRFIDSessionData(RFIDSessionData input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("totalBytesReceived", input.totalBytesReceived);
+            result.put("totalBytesSent", input.totalBytesSent);
+            result.put("status", input.status);
+            result.put("extLeSupport", input.extLeSupport);
+            result.put("processTime", input.processTime);
+            result.put("cardProperties", generateCardProperties(input.cardProperties));
+            result.put("sessionDataStatus", generateRFIDSessionDataStatus(input.sessionDataStatus));
+            result.put("accessControls", generateList(input.accessControls, JSONConstructor::generateAccessControlProcedureType));
+            result.put("applications", generateList(input.applications, JSONConstructor::generateApplication));
+            result.put("securityObjects", generateList(input.securityObjects, JSONConstructor::generateSecurityObject));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static Drawable drawableFromBase64(String base64, Context context) {
-        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(Base64.decode(base64.getBytes(), Base64.DEFAULT));
-        return Drawable.createFromResourceStream(context.getResources(), null, byteArrayInputStream, null);
+    static JSONObject generateDocumentReaderAuthenticityCheck(DocumentReaderAuthenticityCheck input, Context context) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("type", input.type);
+            result.put("status", input.getStatus());
+            result.put("typeName", input.getTypeName(context));
+            result.put("pageIndex", input.pageIndex);
+            result.put("elements", generateList(input.elements, JSONConstructor::generateDocumentReaderAuthenticityElement, context));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return result;
     }
 
-    static Bitmap bitmapFromDrawable(Drawable drawable) {
-        Bitmap bitmap;
+    static JSONObject generatePDF417Info(PDF417Info input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("errorLevel", input.errorLevel);
+            result.put("columns", input.columns);
+            result.put("rows", input.rows);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return result;
+    }
 
-        if (drawable instanceof BitmapDrawable) {
-            BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
-            if (bitmapDrawable.getBitmap() != null) {
-                return bitmapDrawable.getBitmap();
-            }
+    static JSONObject generateRFIDSessionDataStatus(RFIDSessionDataStatus input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("AA", input.AA);
+            result.put("BAC", input.BAC);
+            result.put("CA", input.CA);
+            result.put("PA", input.PA);
+            result.put("PACE", input.PACE);
+            result.put("TA", input.TA);
+            result.put("overallStatus", input.overallStatus);
+        } catch (JSONException e) {
+            e.printStackTrace();
         }
+        return result;
+    }
 
-        if (drawable.getIntrinsicWidth() <= 0 || drawable.getIntrinsicHeight() <= 0) {
-            bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
-        } else {
-            bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+    static JSONObject generateDocumentReaderBarcodeResult(DocumentReaderBarcodeResult input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("fields", generateList(input.fields, JSONConstructor::generateDocumentReaderBarcodeField));
+        } catch (JSONException e) {
+            e.printStackTrace();
         }
+        return result;
+    }
 
-        Canvas canvas = new Canvas(bitmap);
-        drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
-        drawable.draw(canvas);
-        return bitmap;
+    static JSONObject generateDocumentReaderBarcodeField(DocumentReaderBarcodeField input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("barcodeType", input.barcodeType);
+            result.put("status", input.status);
+            result.put("pageIndex", input.pageIndex);
+            result.put("pdf417Info", generatePDF417Info(input.pdf417Info));
+            result.put("data", generateByteArray(input.data));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return result;
     }
 
-    static Matrix matrixFromFloatArray(float[] floats) {
-        Matrix matrix = new Matrix();
-        matrix.setValues(floats);
-        return matrix;
+    static JSONObject generateDocumentReaderAuthenticityResult(DocumentReaderAuthenticityResult input, Context context) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("status", input.getStatus());
+            result.put("checks", generateList(input.checks, JSONConstructor::generateDocumentReaderAuthenticityCheck, context));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return result;
     }
 
-    static float[] floatArrayFromJson(JSONArray jsonArray) throws JSONException {
-        float[] result = new float[jsonArray.length()];
-        for (int i = 0; i < jsonArray.length(); i++)
-            result[i] = (float) jsonArray.getDouble(i);
+    static JSONObject generateDocumentReaderAuthenticityElement(DocumentReaderAuthenticityElement input, Context context) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("status", input.status);
+            result.put("elementType", input.elementType);
+            result.put("elementDiagnose", input.elementDiagnose);
+            result.put("elementTypeName", input.getElementTypeName(context));
+            result.put("elementDiagnoseName", input.getElementDiagnoseName(context));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return result;
+    }
 
+    static JSONObject generateDocumentReaderException(DocumentReaderException input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("errorCode", input.getErrorCode());
+            result.put("localizedMessage", input.getLocalizedMessage());
+            result.put("message", input.getMessage());
+            result.put("string", input.toString());
+            result.put("stackTrace", generateArray(input.getStackTrace(), JSONConstructor::generateStackTraceElement));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static int[] intArrayFromJson(JSONArray jsonArray) throws JSONException {
-        int[] result = new int[jsonArray.length()];
-        for (int i = 0; i < jsonArray.length(); i++)
-            result[i] = jsonArray.getInt(i);
+    static JSONObject generateThrowable(Throwable input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("localizedMessage", input.getLocalizedMessage());
+            result.put("message", input.getMessage());
+            result.put("string", input.toString());
+            result.put("stackTrace", generateArray(input.getStackTrace(), JSONConstructor::generateStackTraceElement));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return result;
+    }
 
+    static JSONObject generateStackTraceElement(StackTraceElement input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("lineNumber", input.getLineNumber());
+            result.put("isNativeMethod", input.isNativeMethod());
+            result.put("className", input.getClassName());
+            result.put("fileName", input.getFileName());
+            result.put("methodName", input.getMethodName());
+            result.put("string", input.toString());
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static String[] barcodeTypeArrayFromJson(JSONArray jsonArray) throws JSONException {
-        String[] result = new String[jsonArray.length()];
-        for (int i = 0; i < jsonArray.length(); i++)
-            result[i] = BarcodeType.valueOf(jsonArray.getInt(i));
+    static JSONObject generatePAResourcesIssuer(PAResourcesIssuer input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("data", generateByteArray(input.data));
+            result.put("friendlyName", input.friendlyName);
+            result.put("attributes", generateArray(input.attributes, JSONConstructor::generatePAAttribute));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return result;
+    }
 
+    static JSONObject generatePAAttribute(PAAttribute input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("type", input.type);
+            result.put("value", input.value);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static FaceMetaData[] faceMetaDataArrayFromJson(JSONArray jsonArray) throws JSONException {
-        FaceMetaData[] result = new FaceMetaData[jsonArray.length()];
-        for (int i = 0; i < jsonArray.length(); i++)
-            result[i] = faceMetaDataFromJson(jsonArray.getJSONObject(i));
+    static JSONObject generateTAChallenge(TAChallenge input) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("data", generateByteArray(input.data));
+            result.put("auxPCD", input.auxPCD);
+            result.put("challengePICC", input.challengePICC);
+            result.put("hashPK", input.hashPK);
+            result.put("idPICC", input.idPICC);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return result;
+    }
 
+    static JSONObject generateDocumentReaderResults(DocumentReaderResults input, Context context) {
+        JSONObject result = new JSONObject();
+        if (input == null) return result;
+        try {
+            result.put("chipPage", input.chipPage);
+            result.put("overallResult", input.getOverallResult());
+            result.put("processingFinishedStatus", input.processingFinishedStatus);
+            result.put("elapsedTime", input.elapsedTime);
+            result.put("elapsedTimeRFID", input.elapsedTimeRFID);
+            result.put("morePagesAvailable", input.morePagesAvailable);
+            result.put("rfidResult", input.rfidResult);
+            result.put("highResolution", input.highResolution);
+            result.put("graphicResult", generateDocumentReaderGraphicResult(input.graphicResult, context));
+            result.put("textResult", generateDocumentReaderTextResult(input.textResult, context));
+            result.put("documentPosition", generateList(input.documentPosition, JSONConstructor::generateElementPosition));
+            result.put("barcodePosition", generateList(input.barcodePosition, JSONConstructor::generateElementPosition));
+            result.put("mrzPosition", generateList(input.mrzPosition, JSONConstructor::generateElementPosition));
+            result.put("imageQuality", generateList(input.imageQuality, JSONConstructor::generateImageQualityGroup));
+            result.put("rawResult", input.rawResult);
+            result.put("documentReaderNotification", generateDocumentReaderNotification(input.documentReaderNotification));
+            result.put("rfidSessionData", generateRFIDSessionData(input.rfidSessionData));
+            result.put("authenticityResult", generateDocumentReaderAuthenticityResult(input.authenticityResult, context));
+            result.put("barcodeResult", generateDocumentReaderBarcodeResult(input.barcodeResult));
+            result.put("documentType", generateList(input.documentType, JSONConstructor::generateDocumentReaderDocumentType));
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
         return result;
     }
 
-    static FaceMetaData faceMetaDataFromJson(JSONObject object) throws JSONException {
-        FaceMetaData result = new FaceMetaData();
-        result.ID = object.getInt("ID");
-        result.rollAngle = object.getInt("rollAngle");
-        result.bounds = boundsFromJson(object.getJSONObject("bounds"));
+    // From JSON
 
-        return result;
+    static DocumentReaderScenario DocumentReaderScenarioFromJSON(JSONObject input) {
+        try {
+            DocumentReaderScenario result = new DocumentReaderScenario();
+            if (input.has("uvTorch"))
+                result.uvTorch = input.getBoolean("uvTorch");
+            if (input.has("seriesProcessMode"))
+                result.seriesProcessMode = input.getBoolean("seriesProcessMode");
+            if (input.has("name"))
+                result.name = input.getString("name");
+            if (input.has("caption"))
+                result.caption = input.getString("caption");
+            if (input.has("description"))
+                result.description = input.getString("description");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
     }
 
-    static Bounds boundsFromJson(JSONObject object) throws JSONException {
-        Bounds result = new Bounds();
-        result.height = object.getInt("height");
-        result.width = object.getInt("width");
-        result.x = object.getInt("x");
-        result.y = object.getInt("y");
+    static DocumentReaderScenarioFull DocumentReaderScenarioFullFromJSON(JSONObject input) {
+        try {
+            DocumentReaderScenarioFull result = new DocumentReaderScenarioFull();
+            if (input.has("uvTorch"))
+                result.uvTorch = input.getBoolean("uvTorch");
+            if (input.has("frameOrientation"))
+                result.frameOrientation = input.getInt("frameOrientation");
+            if (input.has("faceExt"))
+                result.faceExt = input.getBoolean("faceExt");
+            if (input.has("multiPageOff"))
+                result.multiPageOff = input.getInt("multiPageOff");
+            if (input.has("seriesProcessMode"))
+                result.seriesProcessMode = input.getBoolean("seriesProcessMode");
+            if (input.has("frameKWHLandscape"))
+                result.frameKWHLandscape = input.getDouble("frameKWHLandscape");
+            if (input.has("frameKWHPortrait"))
+                result.frameKWHPortrait = input.getDouble("frameKWHPortrait");
+            if (input.has("frameKWHDoublePageSpreadPortrait"))
+                result.frameKWHDoublePageSpreadPortrait = input.getDouble("frameKWHDoublePageSpreadPortrait");
+            if (input.has("frameKWHDoublePageSpreadLandscape"))
+                result.frameKWHDoublePageSpreadLandscape = input.getDouble("frameKWHDoublePageSpreadLandscape");
+            if (input.has("name"))
+                result.name = input.getString("name");
+            if (input.has("caption"))
+                result.caption = input.getString("caption");
+            if (input.has("description"))
+                result.description = input.getString("description");
+            if (input.has("manualCrop"))
+                result.manualCrop = input.getBoolean("manualCrop");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
 
-        return result;
+    static FaceMetaData FaceMetaDataFromJSON(JSONObject input) {
+        try {
+            FaceMetaData result = new FaceMetaData();
+            if (input.has("ID"))
+                result.ID = input.getInt("ID");
+            if (input.has("rollAngle"))
+                result.rollAngle = input.getInt("rollAngle");
+            if (input.has("bounds"))
+                result.bounds = BoundsFromJSON(input.getJSONObject("bounds"));
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
     }
 
-    static List<String> stringListFromJson(JSONArray jsonArray) {
-        List<String> result = new ArrayList<>();
-        for (int i = 0; i < jsonArray.length(); i++)
-            result.add(jsonArray.optString(i));
-        return result;
+    static Bounds BoundsFromJSON(JSONObject input) {
+        try {
+            Bounds result = new Bounds();
+            if (input.has("x"))
+                result.x = input.getInt("x");
+            if (input.has("y"))
+                result.y = input.getInt("y");
+            if (input.has("width"))
+                result.width = input.getInt("width");
+            if (input.has("height"))
+                result.height = input.getInt("height");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static Rect RectFromJSON(JSONObject input) {
+        try {
+            Rect result = new Rect();
+            if (input.has("bottom"))
+                result.bottom = input.getInt("bottom");
+            if (input.has("top"))
+                result.top = input.getInt("top");
+            if (input.has("left"))
+                result.left = input.getInt("left");
+            if (input.has("right"))
+                result.right = input.getInt("right");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocReaderFieldRect DocReaderFieldRectFromJSON(JSONObject input) {
+        try {
+            DocReaderFieldRect result = new DocReaderFieldRect();
+            if (input.has("bottom"))
+                result.bottom = input.getInt("bottom");
+            if (input.has("top"))
+                result.top = input.getInt("top");
+            if (input.has("left"))
+                result.left = input.getInt("left");
+            if (input.has("right"))
+                result.right = input.getInt("right");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderGraphicField DocumentReaderGraphicFieldFromJSON(JSONObject input) {
+        try {
+            DocumentReaderGraphicField result = new DocumentReaderGraphicField();
+            if (input.has("sourceType"))
+                result.sourceType = input.getInt("sourceType");
+            if (input.has("fieldType"))
+                result.fieldType = input.getInt("fieldType");
+            if (input.has("lightType"))
+                result.light = input.getInt("lightType");
+            if (input.has("pageIndex"))
+                result.pageIndex = input.getInt("pageIndex");
+            if (input.has("fieldRect"))
+                result.boundRect = DocReaderFieldRectFromJSON(input.getJSONObject("fieldRect"));
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderGraphicResult DocumentReaderGraphicResultFromJSON(JSONObject input) {
+        try {
+            DocumentReaderGraphicResult result = new DocumentReaderGraphicResult();
+            if (input.has("fields")){
+                JSONArray jsonArray_fields = input.getJSONArray("fields");
+                List<DocumentReaderGraphicField> fields = new ArrayList<>();
+                for (int i = 0; i < jsonArray_fields.length(); i++)
+                    fields.add(DocumentReaderGraphicFieldFromJSON(jsonArray_fields.getJSONObject(i)));
+                result.fields = fields;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderValue DocumentReaderValueFromJSON(JSONObject input) {
+        try {
+            DocumentReaderValue result = new DocumentReaderValue();
+            if (input.has("pageIndex"))
+                result.pageIndex = input.getInt("pageIndex");
+            if (input.has("sourceType"))
+                result.sourceType = input.getInt("sourceType");
+            if (input.has("validity"))
+                result.validity = input.getInt("validity");
+            if (input.has("probability"))
+                result.probability = input.getInt("probability");
+            if (input.has("value"))
+                result.value = input.getString("value");
+            if (input.has("originalValue"))
+                result.originalValue = input.getString("originalValue");
+            if (input.has("boundRect"))
+                result.boundRect = RectFromJSON(input.getJSONObject("boundRect"));
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderTextField DocumentReaderTextFieldFromJSON(JSONObject input) {
+        try {
+            DocumentReaderTextField result = new DocumentReaderTextField();
+            if (input.has("fieldType"))
+                result.fieldType = input.getInt("fieldType");
+            if (input.has("lcid"))
+                result.lcid = input.getInt("lcid");
+            if (input.has("status"))
+                result.status = input.getInt("status");
+            if (input.has("values")){
+                JSONArray jsonArray_values = input.getJSONArray("values");
+                List<DocumentReaderValue> values = new ArrayList<>();
+                for (int i = 0; i < jsonArray_values.length(); i++)
+                    values.add(DocumentReaderValueFromJSON(jsonArray_values.getJSONObject(i)));
+                result.values = values;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderTextResult DocumentReaderTextResultFromJSON(JSONObject input) {
+        try {
+            DocumentReaderTextResult result = new DocumentReaderTextResult();
+            if (input.has("status"))
+                result.status = input.getInt("status");
+            if (input.has("fields")){
+                JSONArray jsonArray_fields = input.getJSONArray("fields");
+                List<DocumentReaderTextField> fields = new ArrayList<>();
+                for (int i = 0; i < jsonArray_fields.length(); i++)
+                    fields.add(DocumentReaderTextFieldFromJSON(jsonArray_fields.getJSONObject(i)));
+                result.fields = fields;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static Coordinate CoordinateFromJSON(JSONObject input) {
+        try {
+            Coordinate result = new Coordinate();
+            if (input.has("x"))
+                result.x = input.getInt("x");
+            if (input.has("y"))
+                result.y = input.getInt("y");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static ElementPosition ElementPositionFromJSON(JSONObject input) {
+        try {
+            ElementPosition result = new ElementPosition();
+            if (input.has("docFormat"))
+                result.docFormat = input.getInt("docFormat");
+            if (input.has("width"))
+                result.width = input.getInt("width");
+            if (input.has("height"))
+                result.height = input.getInt("height");
+            if (input.has("dpi"))
+                result.dpi = input.getInt("dpi");
+            if (input.has("pageIndex"))
+                result.pageIndex = input.getInt("pageIndex");
+            if (input.has("inverse"))
+                result.inverse = input.getInt("inverse");
+            if (input.has("perspectiveTr"))
+                result.perspectiveTr = input.getInt("perspectiveTr");
+            if (input.has("objArea"))
+                result.objArea = input.getInt("objArea");
+            if (input.has("objIntAngleDev"))
+                result.objIntAngleDev = input.getInt("objIntAngleDev");
+            if (input.has("resultStatus"))
+                result.resultStatus = input.getInt("resultStatus");
+            if (input.has("angle"))
+                result.angle = input.getDouble("angle");
+            if (input.has("center"))
+                result.center = CoordinateFromJSON(input.getJSONObject("center"));
+            if (input.has("leftTop"))
+                result.leftTop = CoordinateFromJSON(input.getJSONObject("leftTop"));
+            if (input.has("leftBottom"))
+                result.leftBottom = CoordinateFromJSON(input.getJSONObject("leftBottom"));
+            if (input.has("rightTop"))
+                result.rightTop = CoordinateFromJSON(input.getJSONObject("rightTop"));
+            if (input.has("rightBottom"))
+                result.rightBottom = CoordinateFromJSON(input.getJSONObject("rightBottom"));
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static ImageQuality ImageQualityFromJSON(JSONObject input) {
+        try {
+            ImageQuality result = new ImageQuality();
+            if (input.has("featureType"))
+                result.featureType = input.getInt("featureType");
+            if (input.has("result"))
+                result.result = input.getInt("result");
+            if (input.has("type"))
+                result.type = input.getInt("type");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static ImageQualityGroup ImageQualityGroupFromJSON(JSONObject input) {
+        try {
+            ImageQualityGroup result = new ImageQualityGroup();
+            if (input.has("count"))
+                result.count = input.getInt("count");
+            if (input.has("result"))
+                result.result = input.getInt("result");
+            if (input.has("imageQualityList")){
+                JSONArray jsonArray_imageQualityList = input.getJSONArray("imageQualityList");
+                List<ImageQuality> imageQualityList = new ArrayList<>();
+                for (int i = 0; i < jsonArray_imageQualityList.length(); i++)
+                    imageQualityList.add(ImageQualityFromJSON(jsonArray_imageQualityList.getJSONObject(i)));
+                result.imageQualityList = imageQualityList;
+            }
+            if (input.has("pageIndex"))
+                result.pageIndex = input.getInt("pageIndex");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderDocumentType DocumentReaderDocumentTypeFromJSON(JSONObject input) {
+        try {
+            DocumentReaderDocumentType result = new DocumentReaderDocumentType();
+            if (input.has("pageIndex"))
+                result.pageIndex = input.getInt("pageIndex");
+            if (input.has("documentID"))
+                result.documentID = input.getInt("documentID");
+            if (input.has("dType"))
+                result.dType = input.getInt("dType");
+            if (input.has("dFormat"))
+                result.dFormat = input.getInt("dFormat");
+            if (input.has("dMRZ"))
+                result.dMRZ = input.getBoolean("dMRZ");
+            if (input.has("name"))
+                result.name = input.getString("name");
+            if (input.has("ICAOCode"))
+                result.ICAOCode = input.getString("ICAOCode");
+            if (input.has("dDescription"))
+                result.dDescription = input.getString("dDescription");
+            if (input.has("dYear"))
+                result.dYear = input.getString("dYear");
+            if (input.has("dCountryName"))
+                result.dCountryName = input.getString("dCountryName");
+            if (input.has("FDSID")){
+                JSONArray jsonArray_FDSID = input.getJSONArray("FDSID");
+                int[] FDSID = new int[jsonArray_FDSID.length()];
+                for (int i = 0; i < jsonArray_FDSID.length(); i++)
+                    FDSID[i] = jsonArray_FDSID.getInt(i);
+                result.FDSID = FDSID;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static AccessControlProcedureType AccessControlProcedureTypeFromJSON(JSONObject input) {
+        try {
+            AccessControlProcedureType result = new AccessControlProcedureType();
+            if (input.has("activeOptionIdx"))
+                result.activeOptionIdx = input.getInt("activeOptionIdx");
+            if (input.has("type"))
+                result.type = input.getInt("type");
+            if (input.has("status"))
+                result.status = input.getInt("status");
+            if (input.has("notifications")){
+                JSONArray jsonArray_notifications = input.getJSONArray("notifications");
+                List<Long> notifications = new ArrayList<>();
+                for (int i = 0; i < jsonArray_notifications.length(); i++)
+                    notifications.add(jsonArray_notifications.getLong(i));
+                result.notifications = notifications;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static FileData FileDataFromJSON(JSONObject input) {
+        try {
+            FileData result = new FileData();
+            if (input.has("length"))
+                result.length = input.getInt("length");
+            if (input.has("type"))
+                result.type = input.getInt("type");
+            if (input.has("status"))
+                result.status = input.getInt("status");
+            if (input.has("data"))
+                result.data = input.getString("data");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static CertificateData CertificateDataFromJSON(JSONObject input) {
+        try {
+            CertificateData result = new CertificateData();
+            if (input.has("length"))
+                result.length = input.getInt("length");
+            if (input.has("data"))
+                result.data = input.getString("data");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static SecurityObjectCertificates SecurityObjectCertificatesFromJSON(JSONObject input) {
+        try {
+            SecurityObjectCertificates result = new SecurityObjectCertificates();
+            if (input.has("securityObject"))
+                result.securityObject = CertificateDataFromJSON(input.getJSONObject("securityObject"));
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static File FileFromJSON(JSONObject input) {
+        try {
+            File result = new File();
+            if (input.has("readingTime"))
+                result.readingTime = input.getInt("readingTime");
+            if (input.has("type"))
+                result.type = input.getInt("type");
+            if (input.has("pAStatus"))
+                result.pAStatus = input.getInt("pAStatus");
+            if (input.has("readingStatus"))
+                result.readingStatus = input.getInt("readingStatus");
+            if (input.has("fileID"))
+                result.fileID = input.getString("fileID");
+            if (input.has("fileData"))
+                result.fileData = FileDataFromJSON(input.getJSONObject("fileData"));
+            if (input.has("certificates"))
+                result.certificates = SecurityObjectCertificatesFromJSON(input.getJSONObject("certificates"));
+            if (input.has("docFieldsText")){
+                JSONArray jsonArray_docFieldsText = input.getJSONArray("docFieldsText");
+                List<Integer> docFieldsText = new ArrayList<>();
+                for (int i = 0; i < jsonArray_docFieldsText.length(); i++)
+                    docFieldsText.add(jsonArray_docFieldsText.getInt(i));
+                result.docFieldsText = docFieldsText;
+            }
+            if (input.has("docFieldsGraphics")){
+                JSONArray jsonArray_docFieldsGraphics = input.getJSONArray("docFieldsGraphics");
+                List<Integer> docFieldsGraphics = new ArrayList<>();
+                for (int i = 0; i < jsonArray_docFieldsGraphics.length(); i++)
+                    docFieldsGraphics.add(jsonArray_docFieldsGraphics.getInt(i));
+                result.docFieldsGraphics = docFieldsGraphics;
+            }
+            if (input.has("docFieldsOriginals")){
+                JSONArray jsonArray_docFieldsOriginals = input.getJSONArray("docFieldsOriginals");
+                List<Integer> docFieldsOriginals = new ArrayList<>();
+                for (int i = 0; i < jsonArray_docFieldsOriginals.length(); i++)
+                    docFieldsOriginals.add(jsonArray_docFieldsOriginals.getInt(i));
+                result.docFieldsOriginals = docFieldsOriginals;
+            }
+            if (input.has("notifications")){
+                JSONArray jsonArray_notifications = input.getJSONArray("notifications");
+                List<Long> notifications = new ArrayList<>();
+                for (int i = 0; i < jsonArray_notifications.length(); i++)
+                    notifications.add(jsonArray_notifications.getLong(i));
+                result.notifications = notifications;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static Application ApplicationFromJSON(JSONObject input) {
+        try {
+            Application result = new Application();
+            if (input.has("type"))
+                result.type = input.getInt("type");
+            if (input.has("status"))
+                result.status = input.getInt("status");
+            if (input.has("applicationID"))
+                result.applicationID = input.getString("applicationID");
+            if (input.has("dataHashAlgorithm"))
+                result.dataHashAlgorithm = input.getString("dataHashAlgorithm");
+            if (input.has("unicodeVersion"))
+                result.unicodeVersion = input.getString("unicodeVersion");
+            if (input.has("version"))
+                result.version = input.getString("version");
+            if (input.has("files")){
+                JSONArray jsonArray_files = input.getJSONArray("files");
+                List<File> files = new ArrayList<>();
+                for (int i = 0; i < jsonArray_files.length(); i++)
+                    files.add(FileFromJSON(jsonArray_files.getJSONObject(i)));
+                result.files = files;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static Value ValueFromJSON(JSONObject input) {
+        try {
+            Value result = new Value();
+            if (input.has("length"))
+                result.length = input.getInt("length");
+            if (input.has("type"))
+                result.type = input.getInt("type");
+            if (input.has("status"))
+                result.status = input.getInt("status");
+            if (input.has("data"))
+                result.data = input.getString("data");
+            if (input.has("format"))
+                result.format = input.getString("format");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static Attribute AttributeFromJSON(JSONObject input) {
+        try {
+            Attribute result = new Attribute();
+            if (input.has("type"))
+                result.type = input.getString("type");
+            if (input.has("value"))
+                result.value = ValueFromJSON(input.getJSONObject("value"));
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static Authority AuthorityFromJSON(JSONObject input) {
+        try {
+            Authority result = new Authority();
+            if (input.has("data"))
+                result.data = input.getString("data");
+            if (input.has("friendlyName"))
+                result.friendlyName = ValueFromJSON(input.getJSONObject("friendlyName"));
+            if (input.has("attributes")){
+                JSONArray jsonArray_attributes = input.getJSONArray("attributes");
+                List<Attribute> attributes = new ArrayList<>();
+                for (int i = 0; i < jsonArray_attributes.length(); i++)
+                    attributes.add(AttributeFromJSON(jsonArray_attributes.getJSONObject(i)));
+                result.attributes = attributes;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static Extension ExtensionFromJSON(JSONObject input) {
+        try {
+            Extension result = new Extension();
+            if (input.has("data"))
+                result.data = input.getString("data");
+            if (input.has("type"))
+                result.type = input.getString("type");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static Validity ValidityFromJSON(JSONObject input) {
+        try {
+            Validity result = new Validity();
+            if (input.has("notAfter"))
+                result.notAfter = ValueFromJSON(input.getJSONObject("notAfter"));
+            if (input.has("notBefore"))
+                result.notBefore = ValueFromJSON(input.getJSONObject("notBefore"));
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static CertificateChain CertificateChainFromJSON(JSONObject input) {
+        try {
+            CertificateChain result = new CertificateChain();
+            if (input.has("origin"))
+                result.origin = input.getInt("origin");
+            if (input.has("type"))
+                result.type = input.getInt("type");
+            if (input.has("version"))
+                result.version = input.getInt("version");
+            if (input.has("paStatus"))
+                result.paStatus = input.getInt("paStatus");
+            if (input.has("serialNumber"))
+                result.serialNumber = input.getString("serialNumber");
+            if (input.has("signatureAlgorithm"))
+                result.signatureAlgorithm = input.getString("signatureAlgorithm");
+            if (input.has("subjectPKAlgorithm"))
+                result.subjectPKAlgorithm = input.getString("subjectPKAlgorithm");
+            if (input.has("fileName"))
+                result.fileName = ValueFromJSON(input.getJSONObject("fileName"));
+            if (input.has("validity"))
+                result.validity = ValidityFromJSON(input.getJSONObject("validity"));
+            if (input.has("issuer"))
+                result.issuer = AuthorityFromJSON(input.getJSONObject("issuer"));
+            if (input.has("subject"))
+                result.subject = AuthorityFromJSON(input.getJSONObject("subject"));
+            if (input.has("notifications")){
+                JSONArray jsonArray_notifications = input.getJSONArray("notifications");
+                List<Long> notifications = new ArrayList<>();
+                for (int i = 0; i < jsonArray_notifications.length(); i++)
+                    notifications.add(jsonArray_notifications.getLong(i));
+                result.notifications = notifications;
+            }
+            if (input.has("extensions")){
+                JSONArray jsonArray_extensions = input.getJSONArray("extensions");
+                List<Extension> extensions = new ArrayList<>();
+                for (int i = 0; i < jsonArray_extensions.length(); i++)
+                    extensions.add(ExtensionFromJSON(jsonArray_extensions.getJSONObject(i)));
+                result.extensions = extensions;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static SignerInfo SignerInfoFromJSON(JSONObject input) {
+        try {
+            SignerInfo result = new SignerInfo();
+            if (input.has("version"))
+                result.version = input.getInt("version");
+            if (input.has("paStatus"))
+                result.paStatus = input.getInt("paStatus");
+            if (input.has("dataToHash"))
+                result.dataToHash = input.getString("dataToHash");
+            if (input.has("digestAlgorithm"))
+                result.digestAlgorithm = input.getString("digestAlgorithm");
+            if (input.has("signatureAlgorithm"))
+                result.signatureAlgorithm = input.getString("signatureAlgorithm");
+            if (input.has("serialNumber"))
+                result.serialNumber = ValueFromJSON(input.getJSONObject("serialNumber"));
+            if (input.has("signature"))
+                result.signature = ValueFromJSON(input.getJSONObject("signature"));
+            if (input.has("subjectKeyIdentifier"))
+                result.subjectKeyIdentifier = ValueFromJSON(input.getJSONObject("subjectKeyIdentifier"));
+            if (input.has("issuer"))
+                result.issuer = AuthorityFromJSON(input.getJSONObject("issuer"));
+            if (input.has("notifications")){
+                JSONArray jsonArray_notifications = input.getJSONArray("notifications");
+                List<Long> notifications = new ArrayList<>();
+                for (int i = 0; i < jsonArray_notifications.length(); i++)
+                    notifications.add(jsonArray_notifications.getLong(i));
+                result.notifications = notifications;
+            }
+            if (input.has("signedAttributes")){
+                JSONArray jsonArray_signedAttributes = input.getJSONArray("signedAttributes");
+                List<Extension> signedAttributes = new ArrayList<>();
+                for (int i = 0; i < jsonArray_signedAttributes.length(); i++)
+                    signedAttributes.add(ExtensionFromJSON(jsonArray_signedAttributes.getJSONObject(i)));
+                result.signedAttributes = signedAttributes;
+            }
+            if (input.has("certificateChain")){
+                JSONArray jsonArray_certificateChain = input.getJSONArray("certificateChain");
+                List<CertificateChain> certificateChain = new ArrayList<>();
+                for (int i = 0; i < jsonArray_certificateChain.length(); i++)
+                    certificateChain.add(CertificateChainFromJSON(jsonArray_certificateChain.getJSONObject(i)));
+                result.certificateChain = certificateChain;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static SecurityObject SecurityObjectFromJSON(JSONObject input) {
+        try {
+            SecurityObject result = new SecurityObject();
+            if (input.has("fileReference"))
+                result.fileReference = input.getInt("fileReference");
+            if (input.has("version"))
+                result.version = input.getInt("version");
+            if (input.has("objectType"))
+                result.objectType = input.getString("objectType");
+            if (input.has("notifications")){
+                JSONArray jsonArray_notifications = input.getJSONArray("notifications");
+                List<Long> notifications = new ArrayList<>();
+                for (int i = 0; i < jsonArray_notifications.length(); i++)
+                    notifications.add(jsonArray_notifications.getLong(i));
+                result.notifications = notifications;
+            }
+            if (input.has("signerInfos")){
+                JSONArray jsonArray_signerInfos = input.getJSONArray("signerInfos");
+                List<SignerInfo> signerInfos = new ArrayList<>();
+                for (int i = 0; i < jsonArray_signerInfos.length(); i++)
+                    signerInfos.add(SignerInfoFromJSON(jsonArray_signerInfos.getJSONObject(i)));
+                result.signerInfos = signerInfos;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static CardProperties CardPropertiesFromJSON(JSONObject input) {
+        try {
+            CardProperties result = new CardProperties();
+            if (input.has("aTQA"))
+                result.aTQA = input.getInt("aTQA");
+            if (input.has("bitRateR"))
+                result.bitRateR = input.getInt("bitRateR");
+            if (input.has("bitRateS"))
+                result.bitRateS = input.getInt("bitRateS");
+            if (input.has("chipTypeA"))
+                result.chipTypeA = input.getInt("chipTypeA");
+            if (input.has("mifareMemory"))
+                result.mifareMemory = input.getInt("mifareMemory");
+            if (input.has("rfidType"))
+                result.rfidType = input.getInt("rfidType");
+            if (input.has("sAK"))
+                result.sAK = input.getInt("sAK");
+            if (input.has("support4"))
+                result.support4 = input.getBoolean("support4");
+            if (input.has("supportMifare"))
+                result.supportMifare = input.getBoolean("supportMifare");
+            if (input.has("aTQB"))
+                result.aTQB = input.getString("aTQB");
+            if (input.has("aTR"))
+                result.aTR = input.getString("aTR");
+            if (input.has("baudrate1"))
+                result.baudrate1 = input.getString("baudrate1");
+            if (input.has("baudrate2"))
+                result.baudrate2 = input.getString("baudrate2");
+            if (input.has("uID"))
+                result.uID = input.getString("uID");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static RFIDSessionData RFIDSessionDataFromJSON(JSONObject input) {
+        try {
+            RFIDSessionData result = new RFIDSessionData();
+            if (input.has("totalBytesReceived"))
+                result.totalBytesReceived = input.getInt("totalBytesReceived");
+            if (input.has("totalBytesSent"))
+                result.totalBytesSent = input.getInt("totalBytesSent");
+            if (input.has("status"))
+                result.status = input.getInt("status");
+            if (input.has("extLeSupport"))
+                result.extLeSupport = input.getInt("extLeSupport");
+            if (input.has("processTime"))
+                result.processTime = input.getInt("processTime");
+            if (input.has("cardProperties"))
+                result.cardProperties = CardPropertiesFromJSON(input.getJSONObject("cardProperties"));
+            if (input.has("sessionDataStatus"))
+                result.sessionDataStatus = RFIDSessionDataStatusFromJSON(input.getJSONObject("sessionDataStatus"));
+            if (input.has("accessControls")){
+                JSONArray jsonArray_accessControls = input.getJSONArray("accessControls");
+                List<AccessControlProcedureType> accessControls = new ArrayList<>();
+                for (int i = 0; i < jsonArray_accessControls.length(); i++)
+                    accessControls.add(AccessControlProcedureTypeFromJSON(jsonArray_accessControls.getJSONObject(i)));
+                result.accessControls = accessControls;
+            }
+            if (input.has("applications")){
+                JSONArray jsonArray_applications = input.getJSONArray("applications");
+                List<Application> applications = new ArrayList<>();
+                for (int i = 0; i < jsonArray_applications.length(); i++)
+                    applications.add(ApplicationFromJSON(jsonArray_applications.getJSONObject(i)));
+                result.applications = applications;
+            }
+            if (input.has("securityObjects")){
+                JSONArray jsonArray_securityObjects = input.getJSONArray("securityObjects");
+                List<SecurityObject> securityObjects = new ArrayList<>();
+                for (int i = 0; i < jsonArray_securityObjects.length(); i++)
+                    securityObjects.add(SecurityObjectFromJSON(jsonArray_securityObjects.getJSONObject(i)));
+                result.securityObjects = securityObjects;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderAuthenticityCheck DocumentReaderAuthenticityCheckFromJSON(JSONObject input) {
+        try {
+            DocumentReaderAuthenticityCheck result = new DocumentReaderAuthenticityCheck();
+            if (input.has("type"))
+                result.type = input.getInt("type");
+            if (input.has("pageIndex"))
+                result.pageIndex = input.getInt("pageIndex");
+            if (input.has("elements")){
+                JSONArray jsonArray_elements = input.getJSONArray("elements");
+                List<DocumentReaderAuthenticityElement> elements = new ArrayList<>();
+                for (int i = 0; i < jsonArray_elements.length(); i++)
+                    elements.add(DocumentReaderAuthenticityElementFromJSON(jsonArray_elements.getJSONObject(i)));
+                result.elements = elements;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static PDF417Info PDF417InfoFromJSON(JSONObject input) {
+        try {
+            PDF417Info result = new PDF417Info();
+            if (input.has("errorLevel"))
+                result.errorLevel = input.getInt("errorLevel");
+            if (input.has("columns"))
+                result.columns = input.getInt("columns");
+            if (input.has("rows"))
+                result.rows = input.getInt("rows");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static RFIDSessionDataStatus RFIDSessionDataStatusFromJSON(JSONObject input) {
+        try {
+            RFIDSessionDataStatus result = new RFIDSessionDataStatus();
+            if (input.has("AA"))
+                result.AA = input.getInt("AA");
+            if (input.has("BAC"))
+                result.BAC = input.getInt("BAC");
+            if (input.has("CA"))
+                result.CA = input.getInt("CA");
+            if (input.has("PA"))
+                result.PA = input.getInt("PA");
+            if (input.has("PACE"))
+                result.PACE = input.getInt("PACE");
+            if (input.has("TA"))
+                result.TA = input.getInt("TA");
+            if (input.has("overallStatus"))
+                result.overallStatus = input.getInt("overallStatus");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderBarcodeResult DocumentReaderBarcodeResultFromJSON(JSONObject input) {
+        try {
+            DocumentReaderBarcodeResult result = new DocumentReaderBarcodeResult();
+            if (input.has("fields")){
+                JSONArray jsonArray_fields = input.getJSONArray("fields");
+                List<DocumentReaderBarcodeField> fields = new ArrayList<>();
+                for (int i = 0; i < jsonArray_fields.length(); i++)
+                    fields.add(DocumentReaderBarcodeFieldFromJSON(jsonArray_fields.getJSONObject(i)));
+                result.fields = fields;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderBarcodeField DocumentReaderBarcodeFieldFromJSON(JSONObject input) {
+        try {
+            DocumentReaderBarcodeField result = new DocumentReaderBarcodeField();
+            if (input.has("barcodeType"))
+                result.barcodeType = input.getInt("barcodeType");
+            if (input.has("status"))
+                result.status = input.getInt("status");
+            if (input.has("pageIndex"))
+                result.pageIndex = input.getInt("pageIndex");
+            if (input.has("pdf417Info"))
+                result.pdf417Info = PDF417InfoFromJSON(input.getJSONObject("pdf417Info"));
+            if (input.has("data")){
+                JSONArray jsonArray_data = input.getJSONArray("data");
+                byte[] data = new byte[jsonArray_data.length()];
+                for (int i = 0; i < jsonArray_data.length(); i++)
+                    data[i] = (byte) jsonArray_data.get(i);
+                result.data = data;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderAuthenticityResult DocumentReaderAuthenticityResultFromJSON(JSONObject input) {
+        try {
+            DocumentReaderAuthenticityResult result = new DocumentReaderAuthenticityResult();
+            if (input.has("checks")){
+                JSONArray jsonArray_checks = input.getJSONArray("checks");
+                List<DocumentReaderAuthenticityCheck> checks = new ArrayList<>();
+                for (int i = 0; i < jsonArray_checks.length(); i++)
+                    checks.add(DocumentReaderAuthenticityCheckFromJSON(jsonArray_checks.getJSONObject(i)));
+                result.checks = checks;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderAuthenticityElement DocumentReaderAuthenticityElementFromJSON(JSONObject input) {
+        try {
+            DocumentReaderAuthenticityElement result = new DocumentReaderAuthenticityElement();
+            if (input.has("status"))
+                result.status = input.getInt("status");
+            if (input.has("elementType"))
+                result.elementType = input.getInt("elementType");
+            if (input.has("elementDiagnose"))
+                result.elementDiagnose = input.getInt("elementDiagnose");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static PAResourcesIssuer PAResourcesIssuerFromJSON(JSONObject input) {
+        try {
+            PAResourcesIssuer result = new PAResourcesIssuer();
+            if (input.has("data")){
+                JSONArray jsonArray_data = input.getJSONArray("data");
+                byte[] data = new byte[jsonArray_data.length()];
+                for (int i = 0; i < jsonArray_data.length(); i++)
+                    data[i] = (byte) jsonArray_data.get(i);
+                result.data = data;
+            }
+            if (input.has("friendlyName"))
+                result.friendlyName = input.getString("friendlyName");
+            if (input.has("attributes")){
+                JSONArray jsonArray_attributes = input.getJSONArray("attributes");
+                PAAttribute[] attributes = new PAAttribute[jsonArray_attributes.length()];
+                for (int i = 0; i < jsonArray_attributes.length(); i++)
+                    attributes[i] = PAAttributeFromJSON(jsonArray_attributes.getJSONObject(i));
+                result.attributes = attributes;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static PAAttribute PAAttributeFromJSON(JSONObject input) {
+        try {
+            PAAttribute result = new PAAttribute();
+            if (input.has("type"))
+                result.type = input.getString("type");
+            if (input.has("value"))
+                result.value = input.getString("value");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static TAChallenge TAChallengeFromJSON(JSONObject input) {
+        try {
+            TAChallenge result = new TAChallenge();
+            if (input.has("data")){
+                JSONArray jsonArray_data = input.getJSONArray("data");
+                byte[] data = new byte[jsonArray_data.length()];
+                for (int i = 0; i < jsonArray_data.length(); i++)
+                    data[i] = (byte) jsonArray_data.get(i);
+                result.data = data;
+            }
+            if (input.has("auxPCD"))
+                result.auxPCD = input.getString("auxPCD");
+            if (input.has("challengePICC"))
+                result.challengePICC = input.getString("challengePICC");
+            if (input.has("hashPK"))
+                result.hashPK = input.getString("hashPK");
+            if (input.has("idPICC"))
+                result.idPICC = input.getString("idPICC");
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    static DocumentReaderResults DocumentReaderResultsFromJSON(JSONObject input) {
+        try {
+            DocumentReaderResults result = new DocumentReaderResults();
+            if (input.has("chipPage"))
+                result.chipPage = input.getInt("chipPage");
+            if (input.has("processingFinishedStatus"))
+                result.processingFinishedStatus = input.getInt("processingFinishedStatus");
+            if (input.has("elapsedTime"))
+                result.elapsedTime = input.getInt("elapsedTime");
+            if (input.has("elapsedTimeRFID"))
+                result.elapsedTimeRFID = input.getInt("elapsedTimeRFID");
+            if (input.has("morePagesAvailable"))
+                result.morePagesAvailable = input.getInt("morePagesAvailable");
+            if (input.has("rfidResult"))
+                result.rfidResult = input.getInt("rfidResult");
+            if (input.has("highResolution"))
+                result.highResolution = input.getBoolean("highResolution");
+            if (input.has("graphicResult"))
+                result.graphicResult = DocumentReaderGraphicResultFromJSON(input.getJSONObject("graphicResult"));
+            if (input.has("textResult"))
+                result.textResult = DocumentReaderTextResultFromJSON(input.getJSONObject("textResult"));
+            if (input.has("documentPosition")){
+                JSONArray jsonArray_documentPosition = input.getJSONArray("documentPosition");
+                List<ElementPosition> documentPosition = new ArrayList<>();
+                for (int i = 0; i < jsonArray_documentPosition.length(); i++)
+                    documentPosition.add(ElementPositionFromJSON(jsonArray_documentPosition.getJSONObject(i)));
+                result.documentPosition = documentPosition;
+            }
+            if (input.has("barcodePosition")){
+                JSONArray jsonArray_barcodePosition = input.getJSONArray("barcodePosition");
+                List<ElementPosition> barcodePosition = new ArrayList<>();
+                for (int i = 0; i < jsonArray_barcodePosition.length(); i++)
+                    barcodePosition.add(ElementPositionFromJSON(jsonArray_barcodePosition.getJSONObject(i)));
+                result.barcodePosition = barcodePosition;
+            }
+            if (input.has("mrzPosition")){
+                JSONArray jsonArray_mrzPosition = input.getJSONArray("mrzPosition");
+                List<ElementPosition> mrzPosition = new ArrayList<>();
+                for (int i = 0; i < jsonArray_mrzPosition.length(); i++)
+                    mrzPosition.add(ElementPositionFromJSON(jsonArray_mrzPosition.getJSONObject(i)));
+                result.mrzPosition = mrzPosition;
+            }
+            if (input.has("imageQuality")){
+                JSONArray jsonArray_imageQuality = input.getJSONArray("imageQuality");
+                List<ImageQualityGroup> imageQuality = new ArrayList<>();
+                for (int i = 0; i < jsonArray_imageQuality.length(); i++)
+                    imageQuality.add(ImageQualityGroupFromJSON(jsonArray_imageQuality.getJSONObject(i)));
+                result.imageQuality = imageQuality;
+            }
+            if (input.has("rawResult"))
+                result.rawResult = input.getString("rawResult");
+            if (input.has("documentReaderNotification"))
+                result.documentReaderNotification = DocumentReaderNotificationFromJSON(input.getJSONObject("documentReaderNotification"));
+            if (input.has("rfidSessionData"))
+                result.rfidSessionData = RFIDSessionDataFromJSON(input.getJSONObject("rfidSessionData"));
+            if (input.has("authenticityResult"))
+                result.authenticityResult = DocumentReaderAuthenticityResultFromJSON(input.getJSONObject("authenticityResult"));
+            if (input.has("barcodeResult"))
+                result.barcodeResult = DocumentReaderBarcodeResultFromJSON(input.getJSONObject("barcodeResult"));
+            if (input.has("documentType")){
+                JSONArray jsonArray_documentType = input.getJSONArray("documentType");
+                List<DocumentReaderDocumentType> documentType = new ArrayList<>();
+                for (int i = 0; i < jsonArray_documentType.length(); i++)
+                    documentType.add(DocumentReaderDocumentTypeFromJSON(jsonArray_documentType.getJSONObject(i)));
+                result.documentType = documentType;
+            }
+            return result;
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return null;
     }
 }