package Torello.Browser.JavaScriptAPI;

import java.util.*;
import javax.json.*;
import javax.json.stream.*;
import java.io.*;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.function.Function;

import Torello.Browser.BrowserEvent;
import Torello.Browser.BrowserAPI.*;
import Torello.Browser.helper.*;

import Torello.Java.Additional.*;
import Torello.Java.JSON.*;

import static Torello.Java.JSON.JFlag.*;

import Torello.Java.StrCmpr;
import Torello.JavaDoc.StaticFunctional;
import Torello.JavaDoc.JDHeaderBackgroundImg;
import Torello.JavaDoc.Excuse;

/**
 * <SPAN CLASS=COPIEDJDK><B>RunTime domain exposes JavaScript runtime by means of remote evaluation and mirror objects.
 * Evaluation results are returned as mirror object that expose object type, string representation
 * and unique identifier that can be used for further object reference. Original objects are
 * maintained in memory unless they are either explicitly released or are released along with the
 * other objects in their object group.</B></SPAN>
 * 
 * <EMBED CLASS='external-html' DATA-FILE-ID=CODE_GEN_NOTE>
 */
@StaticFunctional(Excused={"counter"}, Excuses={Excuse.CONFIGURATION})
@JDHeaderBackgroundImg(EmbedTagFileID="WOOD_PLANK_NOTE")
public class RunTime
{
    // ********************************************************************************************
    // ********************************************************************************************
    // Class Header Stuff
    // ********************************************************************************************
    // ********************************************************************************************


    // No Pubic Constructors
    private RunTime () { }

    // These two Vector's are used by all the "Methods" exported by this class.  java.lang.reflect
    // is used to generate the JSON String's.  It saves thousands of lines of Auto-Generated Code.
    private static final Map<String, Vector<String>>    parameterNames = new HashMap<>();
    private static final Map<String, Vector<Class<?>>>  parameterTypes = new HashMap<>();

    // Some Methods do not take any parameters - for instance all the "enable()" and "disable()"
    // I simply could not get ride of RAW-TYPES and UNCHECKED warnings... so there are now,
    // offically, two empty-vectors.  One for String's, and the other for Classes.

    private static final Vector<String>     EMPTY_VEC_STR = new Vector<>();
    private static final Vector<Class<?>>   EMPTY_VEC_CLASS = new Vector<>();

    static
    {
        for (Method m : RunTime.class.getMethods())
        {
            // This doesn't work!  The parameter names are all "arg0" ... "argN"
            // It works for java.lang.reflect.Field, BUT NOT java.lang.reflect.Parameter!
            //
            // Vector<String> parameterNamesList = new Vector<>(); -- NOPE!

            Vector<Class<?>> parameterTypesList = new Vector<>();
        
            for (Parameter p : m.getParameters()) parameterTypesList.add(p.getType());

            parameterTypes.put(
                m.getName(),
                (parameterTypesList.size() > 0) ? parameterTypesList : EMPTY_VEC_CLASS
            );
        }
    }

    static
    {
        Vector<String> v = null;

        v = new Vector<String>(3);
        parameterNames.put("awaitPromise", v);
        Collections.addAll(v, new String[]
        { "promiseObjectId", "returnByValue", "generatePreview", });

        v = new Vector<String>(13);
        parameterNames.put("callFunctionOn", v);
        Collections.addAll(v, new String[]
        { "functionDeclaration", "objectId", "arguments", "silent", "returnByValue", "generatePreview", "userGesture", "awaitPromise", "executionContextId", "objectGroup", "throwOnSideEffect", "uniqueContextId", "serializationOptions", });

        v = new Vector<String>(4);
        parameterNames.put("compileScript", v);
        Collections.addAll(v, new String[]
        { "expression", "sourceURL", "persistScript", "executionContextId", });

        parameterNames.put("disable", EMPTY_VEC_STR);

        parameterNames.put("discardConsoleEntries", EMPTY_VEC_STR);

        parameterNames.put("enable", EMPTY_VEC_STR);

        v = new Vector<String>(16);
        parameterNames.put("evaluate", v);
        Collections.addAll(v, new String[]
        { "expression", "objectGroup", "includeCommandLineAPI", "silent", "contextId", "returnByValue", "generatePreview", "userGesture", "awaitPromise", "throwOnSideEffect", "timeout", "disableBreaks", "replMode", "allowUnsafeEvalBlockedByCSP", "uniqueContextId", "serializationOptions", });

        parameterNames.put("getIsolateId", EMPTY_VEC_STR);

        parameterNames.put("getHeapUsage", EMPTY_VEC_STR);

        v = new Vector<String>(5);
        parameterNames.put("getProperties", v);
        Collections.addAll(v, new String[]
        { "objectId", "ownProperties", "accessorPropertiesOnly", "generatePreview", "nonIndexedPropertiesOnly", });

        v = new Vector<String>(1);
        parameterNames.put("globalLexicalScopeNames", v);
        Collections.addAll(v, new String[]
        { "executionContextId", });

        v = new Vector<String>(2);
        parameterNames.put("queryObjects", v);
        Collections.addAll(v, new String[]
        { "prototypeObjectId", "objectGroup", });

        v = new Vector<String>(1);
        parameterNames.put("releaseObject", v);
        Collections.addAll(v, new String[]
        { "objectId", });

        v = new Vector<String>(1);
        parameterNames.put("releaseObjectGroup", v);
        Collections.addAll(v, new String[]
        { "objectGroup", });

        parameterNames.put("runIfWaitingForDebugger", EMPTY_VEC_STR);

        v = new Vector<String>(8);
        parameterNames.put("runScript", v);
        Collections.addAll(v, new String[]
        { "scriptId", "executionContextId", "objectGroup", "silent", "includeCommandLineAPI", "returnByValue", "generatePreview", "awaitPromise", });

        v = new Vector<String>(1);
        parameterNames.put("setAsyncCallStackDepth", v);
        Collections.addAll(v, new String[]
        { "maxDepth", });

        v = new Vector<String>(1);
        parameterNames.put("setCustomObjectFormatterEnabled", v);
        Collections.addAll(v, new String[]
        { "enabled", });

        v = new Vector<String>(1);
        parameterNames.put("setMaxCallStackSizeToCapture", v);
        Collections.addAll(v, new String[]
        { "size", });

        parameterNames.put("terminateExecution", EMPTY_VEC_STR);

        v = new Vector<String>(3);
        parameterNames.put("addBinding", v);
        Collections.addAll(v, new String[]
        { "name", "executionContextId", "executionContextName", });

        v = new Vector<String>(1);
        parameterNames.put("removeBinding", v);
        Collections.addAll(v, new String[]
        { "name", });

        v = new Vector<String>(1);
        parameterNames.put("getExceptionDetails", v);
        Collections.addAll(v, new String[]
        { "errorObjectId", });
    }


    // ********************************************************************************************
    // ********************************************************************************************
    // Types - Static Inner Classes
    // ********************************************************************************************
    // ********************************************************************************************

    // public static class ScriptId => String
    
    // public static class RemoteObjectId => String
    
    // public static class UnserializableValue => String
    
    // public static class ExecutionContextId => Integer
    
    // public static class Timestamp => Number
    
    // public static class TimeDelta => Number
    
    // public static class UniqueDebuggerId => String
    
    /** Represents options for serialization. Overrides {@code generatePreview} and {@code returnByValue}. */
    public static class SerializationOptions
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, true, true, }; }
        
        /** <CODE>[No Description Provided by Google]</CODE> */
        public final String serialization;
        
        /**
         * Deep serialization depth. Default is full depth. Respected only in {@code deep} serialization mode.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final Integer maxDepth;
        
        /**
         * Embedder-specific parameters. For example if connected to V8 in Chrome these control DOM
         * serialization via {@code maxNodeDepth: integer} and {@code includeShadowTree: "none" | "open" | "all"}.
         * Values can be only of type string or integer.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final JsonObject additionalParameters;
        
        /**
         * Constructor
         *
         * @param serialization -
         * <BR />Acceptable Values: ["deep", "json", "idOnly"]
         * 
         * @param maxDepth Deep serialization depth. Default is full depth. Respected only in {@code deep} serialization mode.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param additionalParameters 
         * Embedder-specific parameters. For example if connected to V8 in Chrome these control DOM
         * serialization via {@code maxNodeDepth: integer} and {@code includeShadowTree: "none" | "open" | "all"}.
         * Values can be only of type string or integer.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public SerializationOptions
            (String serialization, Integer maxDepth, JsonObject additionalParameters)
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (serialization == null) THROWS.throwNPE("serialization");
            
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            THROWS.checkIAE(
                "serialization", serialization,
                "deep", "json", "idOnly"
            );
            
            this.serialization         = serialization;
            this.maxDepth              = maxDepth;
            this.additionalParameters  = additionalParameters;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'SerializationOptions'}.
         */
        public SerializationOptions (JsonObject jo)
        {
            this.serialization         = ReadJSON.getString(jo, "serialization", false, true);
            this.maxDepth              = ReadBoxedJSON.getInteger(jo, "maxDepth", true);
            this.additionalParameters  = jo.getJsonObject("additionalParameters");
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            SerializationOptions o = (SerializationOptions) other;
        
            return
                    Objects.equals(this.serialization, o.serialization)
                &&  Objects.equals(this.maxDepth, o.maxDepth)
                &&  Objects.equals(this.additionalParameters, o.additionalParameters);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.serialization)
                +   Objects.hashCode(this.maxDepth)
                +   Objects.hashCode(this.additionalParameters);
        }
    }
    
    /** Represents deep serialized value. */
    public static class DeepSerializedValue
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, true, true, true, }; }
        
        /** <CODE>[No Description Provided by Google]</CODE> */
        public final String type;
        
        /**
         * <CODE>[No Description Provided by Google]</CODE>
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final JsonValue value;
        
        /**
         * <CODE>[No Description Provided by Google]</CODE>
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String objectId;
        
        /**
         * Set if value reference met more then once during serialization. In such
         * case, value is provided only to one of the serialized values. Unique
         * per value in the scope of one CDP call.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final Integer weakLocalObjectReference;
        
        /**
         * Constructor
         *
         * @param type -
         * <BR />Acceptable Values: ["undefined", "null", "string", "number", "boolean", "bigint", "regexp", "date", "symbol", "array", "object", "function", "map", "set", "weakmap", "weakset", "error", "proxy", "promise", "typedarray", "arraybuffer", "node", "window", "generator"]
         * 
         * @param value -
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param objectId -
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param weakLocalObjectReference 
         * Set if value reference met more then once during serialization. In such
         * case, value is provided only to one of the serialized values. Unique
         * per value in the scope of one CDP call.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public DeepSerializedValue
            (String type, JsonValue value, String objectId, Integer weakLocalObjectReference)
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (type == null) THROWS.throwNPE("type");
            
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            THROWS.checkIAE(
                "type", type,
                "undefined", "null", "string", "number", "boolean", "bigint", "regexp", "date", "symbol", "array", "object", "function", "map", "set", "weakmap", "weakset", "error", "proxy", "promise", "typedarray", "arraybuffer", "node", "window", "generator"
            );
            
            this.type                      = type;
            this.value                     = value;
            this.objectId                  = objectId;
            this.weakLocalObjectReference  = weakLocalObjectReference;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'DeepSerializedValue'}.
         */
        public DeepSerializedValue (JsonObject jo)
        {
            this.type                      = ReadJSON.getString(jo, "type", false, true);
            this.value                     = jo.get("value");
            this.objectId                  = ReadJSON.getString(jo, "objectId", true, false);
            this.weakLocalObjectReference  = ReadBoxedJSON.getInteger(jo, "weakLocalObjectReference", true);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            DeepSerializedValue o = (DeepSerializedValue) other;
        
            return
                    Objects.equals(this.type, o.type)
                &&  Objects.equals(this.value, o.value)
                &&  Objects.equals(this.objectId, o.objectId)
                &&  Objects.equals(this.weakLocalObjectReference, o.weakLocalObjectReference);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.type)
                +   Objects.hashCode(this.value)
                +   Objects.hashCode(this.objectId)
                +   Objects.hashCode(this.weakLocalObjectReference);
        }
    }
    
    /** Mirror object referencing original JavaScript object. */
    public static class RemoteObject
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, true, true, true, true, true, true, true, true, true, }; }
        
        /** Object type. */
        public final String type;
        
        /**
         * Object subtype hint. Specified for {@code object} type values only.
         * NOTE: If you change anything here, make sure to also update
         * {@code subtype} in {@code ObjectPreview} and {@code PropertyPreview} below.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String subtype;
        
        /**
         * Object class (constructor) name. Specified for {@code object} type values only.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String className;
        
        /**
         * Remote object value in case of primitive values or JSON values (if it was requested).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final JsonValue value;
        
        /**
         * Primitive value which can not be JSON-stringified does not have {@code value}, but gets this
         * property.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String unserializableValue;
        
        /**
         * String representation of the object.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String description;
        
        /**
         * Deep serialized value.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
        <B CLASS=Exp>EXPERIMENTAL</B>
         */
        public final RunTime.DeepSerializedValue deepSerializedValue;
        
        /**
         * Unique object identifier (for non-primitive values).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String objectId;
        
        /**
         * Preview containing abbreviated property values. Specified for {@code object} type values only.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
        <B CLASS=Exp>EXPERIMENTAL</B>
         */
        public final RunTime.ObjectPreview preview;
        
        /**
         * <CODE>[No Description Provided by Google]</CODE>
         * <BR /><B CLASS=Opt>OPTIONAL</B>
        <B CLASS=Exp>EXPERIMENTAL</B>
         */
        public final RunTime.CustomPreview customPreview;
        
        /**
         * Constructor
         *
         * @param type Object type.
         * <BR />Acceptable Values: ["object", "function", "undefined", "string", "number", "boolean", "symbol", "bigint"]
         * 
         * @param subtype 
         * Object subtype hint. Specified for {@code object} type values only.
         * NOTE: If you change anything here, make sure to also update
         * {@code subtype} in {@code ObjectPreview} and {@code PropertyPreview} below.
         * <BR />Acceptable Values: ["array", "null", "node", "regexp", "date", "map", "set", "weakmap", "weakset", "iterator", "generator", "error", "proxy", "promise", "typedarray", "arraybuffer", "dataview", "webassemblymemory", "wasmvalue"]
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param className Object class (constructor) name. Specified for {@code object} type values only.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param value Remote object value in case of primitive values or JSON values (if it was requested).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param unserializableValue 
         * Primitive value which can not be JSON-stringified does not have {@code value}, but gets this
         * property.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param description String representation of the object.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param deepSerializedValue Deep serialized value.
         * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
         * 
         * @param objectId Unique object identifier (for non-primitive values).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param preview Preview containing abbreviated property values. Specified for {@code object} type values only.
         * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
         * 
         * @param customPreview -
         * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
         */
        public RemoteObject(
                String type, String subtype, String className, JsonValue value, 
                String unserializableValue, String description, 
                RunTime.DeepSerializedValue deepSerializedValue, String objectId, 
                RunTime.ObjectPreview preview, RunTime.CustomPreview customPreview
            )
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (type == null) THROWS.throwNPE("type");
            
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            THROWS.checkIAE(
                "type", type,
                "object", "function", "undefined", "string", "number", "boolean", "symbol", "bigint"
            );
            THROWS.checkIAE(
                "subtype", subtype,
                "array", "null", "node", "regexp", "date", "map", "set", "weakmap", "weakset", "iterator", "generator", "error", "proxy", "promise", "typedarray", "arraybuffer", "dataview", "webassemblymemory", "wasmvalue"
            );
            
            this.type                 = type;
            this.subtype              = subtype;
            this.className            = className;
            this.value                = value;
            this.unserializableValue  = unserializableValue;
            this.description          = description;
            this.deepSerializedValue  = deepSerializedValue;
            this.objectId             = objectId;
            this.preview              = preview;
            this.customPreview        = customPreview;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'RemoteObject'}.
         */
        public RemoteObject (JsonObject jo)
        {
            this.type                 = ReadJSON.getString(jo, "type", false, true);
            this.subtype              = ReadJSON.getString(jo, "subtype", true, false);
            this.className            = ReadJSON.getString(jo, "className", true, false);
            this.value                = jo.get("value");
            this.unserializableValue  = ReadJSON.getString(jo, "unserializableValue", true, false);
            this.description          = ReadJSON.getString(jo, "description", true, false);
            this.deepSerializedValue  = ReadJSON.getObject(jo, "deepSerializedValue", RunTime.DeepSerializedValue.class, true, false);
            this.objectId             = ReadJSON.getString(jo, "objectId", true, false);
            this.preview              = ReadJSON.getObject(jo, "preview", RunTime.ObjectPreview.class, true, false);
            this.customPreview        = ReadJSON.getObject(jo, "customPreview", RunTime.CustomPreview.class, true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            RemoteObject o = (RemoteObject) other;
        
            return
                    Objects.equals(this.type, o.type)
                &&  Objects.equals(this.subtype, o.subtype)
                &&  Objects.equals(this.className, o.className)
                &&  Objects.equals(this.value, o.value)
                &&  Objects.equals(this.unserializableValue, o.unserializableValue)
                &&  Objects.equals(this.description, o.description)
                &&  Objects.equals(this.deepSerializedValue, o.deepSerializedValue)
                &&  Objects.equals(this.objectId, o.objectId)
                &&  Objects.equals(this.preview, o.preview)
                &&  Objects.equals(this.customPreview, o.customPreview);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.type)
                +   Objects.hashCode(this.subtype)
                +   Objects.hashCode(this.className)
                +   Objects.hashCode(this.value)
                +   Objects.hashCode(this.unserializableValue)
                +   Objects.hashCode(this.description)
                +   this.deepSerializedValue.hashCode()
                +   Objects.hashCode(this.objectId)
                +   this.preview.hashCode()
                +   this.customPreview.hashCode();
        }
    }
    
    /**
     * <CODE>[No Description Provided by Google]</CODE>
     * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
     */
    public static class CustomPreview
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, true, }; }
        
        /**
         * The JSON-stringified result of formatter.header(object, config) call.
         * It contains json ML array that represents RemoteObject.
         */
        public final String header;
        
        /**
         * If formatter returns true as a result of formatter.hasBody call then bodyGetterId will
         * contain RemoteObjectId for the function that returns result of formatter.body(object, config) call.
         * The result value is json ML array.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String bodyGetterId;
        
        /**
         * Constructor
         *
         * @param header 
         * The JSON-stringified result of formatter.header(object, config) call.
         * It contains json ML array that represents RemoteObject.
         * 
         * @param bodyGetterId 
         * If formatter returns true as a result of formatter.hasBody call then bodyGetterId will
         * contain RemoteObjectId for the function that returns result of formatter.body(object, config) call.
         * The result value is json ML array.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public CustomPreview(String header, String bodyGetterId)
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (header == null) THROWS.throwNPE("header");
            
            this.header        = header;
            this.bodyGetterId  = bodyGetterId;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'CustomPreview'}.
         */
        public CustomPreview (JsonObject jo)
        {
            this.header        = ReadJSON.getString(jo, "header", false, true);
            this.bodyGetterId  = ReadJSON.getString(jo, "bodyGetterId", true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            CustomPreview o = (CustomPreview) other;
        
            return
                    Objects.equals(this.header, o.header)
                &&  Objects.equals(this.bodyGetterId, o.bodyGetterId);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.header)
                +   Objects.hashCode(this.bodyGetterId);
        }
    }
    
    /**
     * Object containing abbreviated remote object value.
     * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
     */
    public static class ObjectPreview
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, true, true, false, false, true, }; }
        
        /** Object type. */
        public final String type;
        
        /**
         * Object subtype hint. Specified for {@code object} type values only.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String subtype;
        
        /**
         * String representation of the object.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String description;
        
        /** True iff some of the properties or entries of the original object did not fit. */
        public final boolean overflow;
        
        /** List of the properties. */
        public final RunTime.PropertyPreview[] properties;
        
        /**
         * List of the entries. Specified for {@code map} and {@code set} subtype values only.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.EntryPreview[] entries;
        
        /**
         * Constructor
         *
         * @param type Object type.
         * <BR />Acceptable Values: ["object", "function", "undefined", "string", "number", "boolean", "symbol", "bigint"]
         * 
         * @param subtype Object subtype hint. Specified for {@code object} type values only.
         * <BR />Acceptable Values: ["array", "null", "node", "regexp", "date", "map", "set", "weakmap", "weakset", "iterator", "generator", "error", "proxy", "promise", "typedarray", "arraybuffer", "dataview", "webassemblymemory", "wasmvalue"]
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param description String representation of the object.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param overflow True iff some of the properties or entries of the original object did not fit.
         * 
         * @param properties List of the properties.
         * 
         * @param entries List of the entries. Specified for {@code map} and {@code set} subtype values only.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public ObjectPreview(
                String type, String subtype, String description, boolean overflow, 
                RunTime.PropertyPreview[] properties, RunTime.EntryPreview[] entries
            )
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (type == null)       THROWS.throwNPE("type");
            if (properties == null) THROWS.throwNPE("properties");
            
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            THROWS.checkIAE(
                "type", type,
                "object", "function", "undefined", "string", "number", "boolean", "symbol", "bigint"
            );
            THROWS.checkIAE(
                "subtype", subtype,
                "array", "null", "node", "regexp", "date", "map", "set", "weakmap", "weakset", "iterator", "generator", "error", "proxy", "promise", "typedarray", "arraybuffer", "dataview", "webassemblymemory", "wasmvalue"
            );
            
            this.type         = type;
            this.subtype      = subtype;
            this.description  = description;
            this.overflow     = overflow;
            this.properties   = properties;
            this.entries      = entries;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'ObjectPreview'}.
         */
        public ObjectPreview (JsonObject jo)
        {
            this.type         = ReadJSON.getString(jo, "type", false, true);
            this.subtype      = ReadJSON.getString(jo, "subtype", true, false);
            this.description  = ReadJSON.getString(jo, "description", true, false);
            this.overflow     = ReadPrimJSON.getBoolean(jo, "overflow");
            this.properties = (jo.getJsonArray("properties") == null)
                ? null
                : RJArrIntoStream.objArr(jo.getJsonArray("properties"), null, 0, RunTime.PropertyPreview.class).toArray(RunTime.PropertyPreview[]::new);
        
            this.entries = (jo.getJsonArray("entries") == null)
                ? null
                : RJArrIntoStream.objArr(jo.getJsonArray("entries"), null, 0, RunTime.EntryPreview.class).toArray(RunTime.EntryPreview[]::new);
        
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            ObjectPreview o = (ObjectPreview) other;
        
            return
                    Objects.equals(this.type, o.type)
                &&  Objects.equals(this.subtype, o.subtype)
                &&  Objects.equals(this.description, o.description)
                &&  (this.overflow == o.overflow)
                &&  Arrays.deepEquals(this.properties, o.properties)
                &&  Arrays.deepEquals(this.entries, o.entries);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.type)
                +   Objects.hashCode(this.subtype)
                +   Objects.hashCode(this.description)
                +   (this.overflow ? 1 : 0)
                +   Arrays.deepHashCode(this.properties)
                +   Arrays.deepHashCode(this.entries);
        }
    }
    
    /**
     * <CODE>[No Description Provided by Google]</CODE>
     * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
     */
    public static class PropertyPreview
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, false, true, true, true, }; }
        
        /** Property name. */
        public final String name;
        
        /** Object type. Accessor means that the property itself is an accessor property. */
        public final String type;
        
        /**
         * User-friendly property value string.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String value;
        
        /**
         * Nested value preview.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.ObjectPreview valuePreview;
        
        /**
         * Object subtype hint. Specified for {@code object} type values only.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String subtype;
        
        /**
         * Constructor
         *
         * @param name Property name.
         * 
         * @param type Object type. Accessor means that the property itself is an accessor property.
         * <BR />Acceptable Values: ["object", "function", "undefined", "string", "number", "boolean", "symbol", "accessor", "bigint"]
         * 
         * @param value User-friendly property value string.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param valuePreview Nested value preview.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param subtype Object subtype hint. Specified for {@code object} type values only.
         * <BR />Acceptable Values: ["array", "null", "node", "regexp", "date", "map", "set", "weakmap", "weakset", "iterator", "generator", "error", "proxy", "promise", "typedarray", "arraybuffer", "dataview", "webassemblymemory", "wasmvalue"]
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public PropertyPreview(
                String name, String type, String value, RunTime.ObjectPreview valuePreview, 
                String subtype
            )
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (name == null) THROWS.throwNPE("name");
            if (type == null) THROWS.throwNPE("type");
            
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            THROWS.checkIAE(
                "type", type,
                "object", "function", "undefined", "string", "number", "boolean", "symbol", "accessor", "bigint"
            );
            THROWS.checkIAE(
                "subtype", subtype,
                "array", "null", "node", "regexp", "date", "map", "set", "weakmap", "weakset", "iterator", "generator", "error", "proxy", "promise", "typedarray", "arraybuffer", "dataview", "webassemblymemory", "wasmvalue"
            );
            
            this.name          = name;
            this.type          = type;
            this.value         = value;
            this.valuePreview  = valuePreview;
            this.subtype       = subtype;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'PropertyPreview'}.
         */
        public PropertyPreview (JsonObject jo)
        {
            this.name          = ReadJSON.getString(jo, "name", false, true);
            this.type          = ReadJSON.getString(jo, "type", false, true);
            this.value         = ReadJSON.getString(jo, "value", true, false);
            this.valuePreview  = ReadJSON.getObject(jo, "valuePreview", RunTime.ObjectPreview.class, true, false);
            this.subtype       = ReadJSON.getString(jo, "subtype", true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            PropertyPreview o = (PropertyPreview) other;
        
            return
                    Objects.equals(this.name, o.name)
                &&  Objects.equals(this.type, o.type)
                &&  Objects.equals(this.value, o.value)
                &&  Objects.equals(this.valuePreview, o.valuePreview)
                &&  Objects.equals(this.subtype, o.subtype);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.name)
                +   Objects.hashCode(this.type)
                +   Objects.hashCode(this.value)
                +   this.valuePreview.hashCode()
                +   Objects.hashCode(this.subtype);
        }
    }
    
    /**
     * <CODE>[No Description Provided by Google]</CODE>
     * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
     */
    public static class EntryPreview
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { true, false, }; }
        
        /**
         * Preview of the key. Specified for map-like collection entries.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.ObjectPreview key;
        
        /** Preview of the value. */
        public final RunTime.ObjectPreview value;
        
        /**
         * Constructor
         *
         * @param key Preview of the key. Specified for map-like collection entries.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param value Preview of the value.
         */
        public EntryPreview(RunTime.ObjectPreview key, RunTime.ObjectPreview value)
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (value == null) THROWS.throwNPE("value");
            
            this.key    = key;
            this.value  = value;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'EntryPreview'}.
         */
        public EntryPreview (JsonObject jo)
        {
            this.key    = ReadJSON.getObject(jo, "key", RunTime.ObjectPreview.class, true, false);
            this.value  = ReadJSON.getObject(jo, "value", RunTime.ObjectPreview.class, false, true);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            EntryPreview o = (EntryPreview) other;
        
            return
                    Objects.equals(this.key, o.key)
                &&  Objects.equals(this.value, o.value);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    this.key.hashCode()
                +   this.value.hashCode();
        }
    }
    
    /** Object property descriptor. */
    public static class PropertyDescriptor
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, true, true, true, true, false, false, true, true, true, }; }
        
        /** Property name or symbol description. */
        public final String name;
        
        /**
         * The value associated with the property.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.RemoteObject value;
        
        /**
         * True if the value associated with the property may be changed (data descriptors only).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final Boolean writable;
        
        /**
         * A function which serves as a getter for the property, or {@code undefined} if there is no getter
         * (accessor descriptors only).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.RemoteObject get;
        
        /**
         * A function which serves as a setter for the property, or {@code undefined} if there is no setter
         * (accessor descriptors only).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.RemoteObject set;
        
        /**
         * True if the type of this property descriptor may be changed and if the property may be
         * deleted from the corresponding object.
         */
        public final boolean configurable;
        
        /**
         * True if this property shows up during enumeration of the properties on the corresponding
         * object.
         */
        public final boolean enumerable;
        
        /**
         * True if the result was thrown during the evaluation.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final Boolean wasThrown;
        
        /**
         * True if the property is owned for the object.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final Boolean isOwn;
        
        /**
         * Property symbol object, if the property is of the {@code symbol} type.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.RemoteObject symbol;
        
        /**
         * Constructor
         *
         * @param name Property name or symbol description.
         * 
         * @param value The value associated with the property.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param writable True if the value associated with the property may be changed (data descriptors only).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param get 
         * A function which serves as a getter for the property, or {@code undefined} if there is no getter
         * (accessor descriptors only).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param set 
         * A function which serves as a setter for the property, or {@code undefined} if there is no setter
         * (accessor descriptors only).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param configurable 
         * True if the type of this property descriptor may be changed and if the property may be
         * deleted from the corresponding object.
         * 
         * @param enumerable 
         * True if this property shows up during enumeration of the properties on the corresponding
         * object.
         * 
         * @param wasThrown True if the result was thrown during the evaluation.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param isOwn True if the property is owned for the object.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param symbol Property symbol object, if the property is of the {@code symbol} type.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public PropertyDescriptor(
                String name, RunTime.RemoteObject value, Boolean writable, RunTime.RemoteObject get, 
                RunTime.RemoteObject set, boolean configurable, boolean enumerable, 
                Boolean wasThrown, Boolean isOwn, RunTime.RemoteObject symbol
            )
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (name == null) THROWS.throwNPE("name");
            
            this.name          = name;
            this.value         = value;
            this.writable      = writable;
            this.get           = get;
            this.set           = set;
            this.configurable  = configurable;
            this.enumerable    = enumerable;
            this.wasThrown     = wasThrown;
            this.isOwn         = isOwn;
            this.symbol        = symbol;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'PropertyDescriptor'}.
         */
        public PropertyDescriptor (JsonObject jo)
        {
            this.name          = ReadJSON.getString(jo, "name", false, true);
            this.value         = ReadJSON.getObject(jo, "value", RunTime.RemoteObject.class, true, false);
            this.writable      = ReadBoxedJSON.getBoolean(jo, "writable", true);
            this.get           = ReadJSON.getObject(jo, "get", RunTime.RemoteObject.class, true, false);
            this.set           = ReadJSON.getObject(jo, "set", RunTime.RemoteObject.class, true, false);
            this.configurable  = ReadPrimJSON.getBoolean(jo, "configurable");
            this.enumerable    = ReadPrimJSON.getBoolean(jo, "enumerable");
            this.wasThrown     = ReadBoxedJSON.getBoolean(jo, "wasThrown", true);
            this.isOwn         = ReadBoxedJSON.getBoolean(jo, "isOwn", true);
            this.symbol        = ReadJSON.getObject(jo, "symbol", RunTime.RemoteObject.class, true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            PropertyDescriptor o = (PropertyDescriptor) other;
        
            return
                    Objects.equals(this.name, o.name)
                &&  Objects.equals(this.value, o.value)
                &&  Objects.equals(this.writable, o.writable)
                &&  Objects.equals(this.get, o.get)
                &&  Objects.equals(this.set, o.set)
                &&  (this.configurable == o.configurable)
                &&  (this.enumerable == o.enumerable)
                &&  Objects.equals(this.wasThrown, o.wasThrown)
                &&  Objects.equals(this.isOwn, o.isOwn)
                &&  Objects.equals(this.symbol, o.symbol);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.name)
                +   this.value.hashCode()
                +   Objects.hashCode(this.writable)
                +   this.get.hashCode()
                +   this.set.hashCode()
                +   (this.configurable ? 1 : 0)
                +   (this.enumerable ? 1 : 0)
                +   Objects.hashCode(this.wasThrown)
                +   Objects.hashCode(this.isOwn)
                +   this.symbol.hashCode();
        }
    }
    
    /** Object internal property descriptor. This property isn't normally visible in JavaScript code. */
    public static class InternalPropertyDescriptor
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, true, }; }
        
        /** Conventional property name. */
        public final String name;
        
        /**
         * The value associated with the property.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.RemoteObject value;
        
        /**
         * Constructor
         *
         * @param name Conventional property name.
         * 
         * @param value The value associated with the property.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public InternalPropertyDescriptor(String name, RunTime.RemoteObject value)
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (name == null) THROWS.throwNPE("name");
            
            this.name   = name;
            this.value  = value;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'InternalPropertyDescriptor'}.
         */
        public InternalPropertyDescriptor (JsonObject jo)
        {
            this.name   = ReadJSON.getString(jo, "name", false, true);
            this.value  = ReadJSON.getObject(jo, "value", RunTime.RemoteObject.class, true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            InternalPropertyDescriptor o = (InternalPropertyDescriptor) other;
        
            return
                    Objects.equals(this.name, o.name)
                &&  Objects.equals(this.value, o.value);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.name)
                +   this.value.hashCode();
        }
    }
    
    /**
     * Object private field descriptor.
     * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
     */
    public static class PrivatePropertyDescriptor
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, true, true, true, }; }
        
        /** Private property name. */
        public final String name;
        
        /**
         * The value associated with the private property.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.RemoteObject value;
        
        /**
         * A function which serves as a getter for the private property,
         * or {@code undefined} if there is no getter (accessor descriptors only).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.RemoteObject get;
        
        /**
         * A function which serves as a setter for the private property,
         * or {@code undefined} if there is no setter (accessor descriptors only).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.RemoteObject set;
        
        /**
         * Constructor
         *
         * @param name Private property name.
         * 
         * @param value The value associated with the private property.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param get 
         * A function which serves as a getter for the private property,
         * or {@code undefined} if there is no getter (accessor descriptors only).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param set 
         * A function which serves as a setter for the private property,
         * or {@code undefined} if there is no setter (accessor descriptors only).
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public PrivatePropertyDescriptor(
                String name, RunTime.RemoteObject value, RunTime.RemoteObject get, 
                RunTime.RemoteObject set
            )
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (name == null) THROWS.throwNPE("name");
            
            this.name   = name;
            this.value  = value;
            this.get    = get;
            this.set    = set;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'PrivatePropertyDescriptor'}.
         */
        public PrivatePropertyDescriptor (JsonObject jo)
        {
            this.name   = ReadJSON.getString(jo, "name", false, true);
            this.value  = ReadJSON.getObject(jo, "value", RunTime.RemoteObject.class, true, false);
            this.get    = ReadJSON.getObject(jo, "get", RunTime.RemoteObject.class, true, false);
            this.set    = ReadJSON.getObject(jo, "set", RunTime.RemoteObject.class, true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            PrivatePropertyDescriptor o = (PrivatePropertyDescriptor) other;
        
            return
                    Objects.equals(this.name, o.name)
                &&  Objects.equals(this.value, o.value)
                &&  Objects.equals(this.get, o.get)
                &&  Objects.equals(this.set, o.set);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.name)
                +   this.value.hashCode()
                +   this.get.hashCode()
                +   this.set.hashCode();
        }
    }
    
    /**
     * Represents function call argument. Either remote object id {@code objectId}, primitive {@code value},
     * unserializable primitive value or neither of (for undefined) them should be specified.
     */
    public static class CallArgument
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { true, true, true, }; }
        
        /**
         * Primitive value or serializable javascript object.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final JsonValue value;
        
        /**
         * Primitive value which can not be JSON-stringified.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String unserializableValue;
        
        /**
         * Remote object handle.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String objectId;
        
        /**
         * Constructor
         *
         * @param value Primitive value or serializable javascript object.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param unserializableValue Primitive value which can not be JSON-stringified.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param objectId Remote object handle.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public CallArgument(JsonValue value, String unserializableValue, String objectId)
        {
            this.value                = value;
            this.unserializableValue  = unserializableValue;
            this.objectId             = objectId;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'CallArgument'}.
         */
        public CallArgument (JsonObject jo)
        {
            this.value                = jo.get("value");
            this.unserializableValue  = ReadJSON.getString(jo, "unserializableValue", true, false);
            this.objectId             = ReadJSON.getString(jo, "objectId", true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            CallArgument o = (CallArgument) other;
        
            return
                    Objects.equals(this.value, o.value)
                &&  Objects.equals(this.unserializableValue, o.unserializableValue)
                &&  Objects.equals(this.objectId, o.objectId);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.value)
                +   Objects.hashCode(this.unserializableValue)
                +   Objects.hashCode(this.objectId);
        }
    }
    
    /** Description of an isolated world. */
    public static class ExecutionContextDescription
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, false, false, false, true, }; }
        
        /**
         * Unique id of the execution context. It can be used to specify in which execution context
         * script evaluation should be performed.
         */
        public final int id;
        
        /** Execution context origin. */
        public final String origin;
        
        /** Human readable name describing given context. */
        public final String name;
        
        /**
         * A system-unique execution context identifier. Unlike the id, this is unique across
         * multiple processes, so can be reliably used to identify specific context while backend
         * performs a cross-process navigation.
         * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
         */
        public final String uniqueId;
        
        /**
         * Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'|'isolated'|'worker', frameId: string}
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final JsonObject auxData;
        
        /**
         * Constructor
         *
         * @param id 
         * Unique id of the execution context. It can be used to specify in which execution context
         * script evaluation should be performed.
         * 
         * @param origin Execution context origin.
         * 
         * @param name Human readable name describing given context.
         * 
         * @param uniqueId 
         * A system-unique execution context identifier. Unlike the id, this is unique across
         * multiple processes, so can be reliably used to identify specific context while backend
         * performs a cross-process navigation.
         * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
         * 
         * @param auxData Embedder-specific auxiliary data likely matching {isDefault: boolean, type: 'default'|'isolated'|'worker', frameId: string}
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public ExecutionContextDescription
            (int id, String origin, String name, String uniqueId, JsonObject auxData)
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (origin == null)   THROWS.throwNPE("origin");
            if (name == null)     THROWS.throwNPE("name");
            if (uniqueId == null) THROWS.throwNPE("uniqueId");
            
            this.id        = id;
            this.origin    = origin;
            this.name      = name;
            this.uniqueId  = uniqueId;
            this.auxData   = auxData;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'ExecutionContextDescription'}.
         */
        public ExecutionContextDescription (JsonObject jo)
        {
            this.id        = ReadPrimJSON.getInt(jo, "id");
            this.origin    = ReadJSON.getString(jo, "origin", false, true);
            this.name      = ReadJSON.getString(jo, "name", false, true);
            this.uniqueId  = ReadJSON.getString(jo, "uniqueId", false, true);
            this.auxData   = jo.getJsonObject("auxData");
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            ExecutionContextDescription o = (ExecutionContextDescription) other;
        
            return
                    Objects.equals(this.id, o.id)
                &&  Objects.equals(this.origin, o.origin)
                &&  Objects.equals(this.name, o.name)
                &&  Objects.equals(this.uniqueId, o.uniqueId)
                &&  Objects.equals(this.auxData, o.auxData);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    this.id
                +   Objects.hashCode(this.origin)
                +   Objects.hashCode(this.name)
                +   Objects.hashCode(this.uniqueId)
                +   Objects.hashCode(this.auxData);
        }
    }
    
    /**
     * Detailed information about exception (or error) that was thrown during script compilation or
     * execution.
     */
    public static class ExceptionDetails
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, false, false, false, true, true, true, true, true, true, }; }
        
        /** Exception id. */
        public final int exceptionId;
        
        /** Exception text, which should be used together with exception object when available. */
        public final String text;
        
        /** Line number of the exception location (0-based). */
        public final int lineNumber;
        
        /** Column number of the exception location (0-based). */
        public final int columnNumber;
        
        /**
         * Script ID of the exception location.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String scriptId;
        
        /**
         * URL of the exception location, to be used when the script was not reported.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String url;
        
        /**
         * JavaScript stack trace if available.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.StackTrace stackTrace;
        
        /**
         * Exception object if available.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.RemoteObject exception;
        
        /**
         * Identifier of the context where exception happened.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final Integer executionContextId;
        
        /**
         * Dictionary with entries of meta data that the client associated
         * with this exception, such as information about associated network
         * requests, etc.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
        <B CLASS=Exp>EXPERIMENTAL</B>
         */
        public final JsonObject exceptionMetaData;
        
        /**
         * Constructor
         *
         * @param exceptionId Exception id.
         * 
         * @param text Exception text, which should be used together with exception object when available.
         * 
         * @param lineNumber Line number of the exception location (0-based).
         * 
         * @param columnNumber Column number of the exception location (0-based).
         * 
         * @param scriptId Script ID of the exception location.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param url URL of the exception location, to be used when the script was not reported.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param stackTrace JavaScript stack trace if available.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param exception Exception object if available.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param executionContextId Identifier of the context where exception happened.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param exceptionMetaData 
         * Dictionary with entries of meta data that the client associated
         * with this exception, such as information about associated network
         * requests, etc.
         * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
         */
        public ExceptionDetails(
                int exceptionId, String text, int lineNumber, int columnNumber, String scriptId, 
                String url, RunTime.StackTrace stackTrace, RunTime.RemoteObject exception, 
                Integer executionContextId, JsonObject exceptionMetaData
            )
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (text == null) THROWS.throwNPE("text");
            
            this.exceptionId         = exceptionId;
            this.text                = text;
            this.lineNumber          = lineNumber;
            this.columnNumber        = columnNumber;
            this.scriptId            = scriptId;
            this.url                 = url;
            this.stackTrace          = stackTrace;
            this.exception           = exception;
            this.executionContextId  = executionContextId;
            this.exceptionMetaData   = exceptionMetaData;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'ExceptionDetails'}.
         */
        public ExceptionDetails (JsonObject jo)
        {
            this.exceptionId         = ReadPrimJSON.getInt(jo, "exceptionId");
            this.text                = ReadJSON.getString(jo, "text", false, true);
            this.lineNumber          = ReadPrimJSON.getInt(jo, "lineNumber");
            this.columnNumber        = ReadPrimJSON.getInt(jo, "columnNumber");
            this.scriptId            = ReadJSON.getString(jo, "scriptId", true, false);
            this.url                 = ReadJSON.getString(jo, "url", true, false);
            this.stackTrace          = ReadJSON.getObject(jo, "stackTrace", RunTime.StackTrace.class, true, false);
            this.exception           = ReadJSON.getObject(jo, "exception", RunTime.RemoteObject.class, true, false);
            this.executionContextId  = ReadBoxedJSON.getInteger(jo, "executionContextId", true);
            this.exceptionMetaData   = jo.getJsonObject("exceptionMetaData");
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            ExceptionDetails o = (ExceptionDetails) other;
        
            return
                    (this.exceptionId == o.exceptionId)
                &&  Objects.equals(this.text, o.text)
                &&  (this.lineNumber == o.lineNumber)
                &&  (this.columnNumber == o.columnNumber)
                &&  Objects.equals(this.scriptId, o.scriptId)
                &&  Objects.equals(this.url, o.url)
                &&  Objects.equals(this.stackTrace, o.stackTrace)
                &&  Objects.equals(this.exception, o.exception)
                &&  Objects.equals(this.executionContextId, o.executionContextId)
                &&  Objects.equals(this.exceptionMetaData, o.exceptionMetaData);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    this.exceptionId
                +   Objects.hashCode(this.text)
                +   this.lineNumber
                +   this.columnNumber
                +   Objects.hashCode(this.scriptId)
                +   Objects.hashCode(this.url)
                +   this.stackTrace.hashCode()
                +   this.exception.hashCode()
                +   Objects.hashCode(this.executionContextId)
                +   Objects.hashCode(this.exceptionMetaData);
        }
    }
    
    /** Stack entry for runtime errors and assertions. */
    public static class CallFrame
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, false, false, false, false, }; }
        
        /** JavaScript function name. */
        public final String functionName;
        
        /** JavaScript script id. */
        public final String scriptId;
        
        /** JavaScript script name or url. */
        public final String url;
        
        /** JavaScript script line number (0-based). */
        public final int lineNumber;
        
        /** JavaScript script column number (0-based). */
        public final int columnNumber;
        
        /**
         * Constructor
         *
         * @param functionName JavaScript function name.
         * 
         * @param scriptId JavaScript script id.
         * 
         * @param url JavaScript script name or url.
         * 
         * @param lineNumber JavaScript script line number (0-based).
         * 
         * @param columnNumber JavaScript script column number (0-based).
         */
        public CallFrame
            (String functionName, String scriptId, String url, int lineNumber, int columnNumber)
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (functionName == null) THROWS.throwNPE("functionName");
            if (scriptId == null)     THROWS.throwNPE("scriptId");
            if (url == null)          THROWS.throwNPE("url");
            
            this.functionName  = functionName;
            this.scriptId      = scriptId;
            this.url           = url;
            this.lineNumber    = lineNumber;
            this.columnNumber  = columnNumber;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'CallFrame'}.
         */
        public CallFrame (JsonObject jo)
        {
            this.functionName  = ReadJSON.getString(jo, "functionName", false, true);
            this.scriptId      = ReadJSON.getString(jo, "scriptId", false, true);
            this.url           = ReadJSON.getString(jo, "url", false, true);
            this.lineNumber    = ReadPrimJSON.getInt(jo, "lineNumber");
            this.columnNumber  = ReadPrimJSON.getInt(jo, "columnNumber");
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            CallFrame o = (CallFrame) other;
        
            return
                    Objects.equals(this.functionName, o.functionName)
                &&  Objects.equals(this.scriptId, o.scriptId)
                &&  Objects.equals(this.url, o.url)
                &&  (this.lineNumber == o.lineNumber)
                &&  (this.columnNumber == o.columnNumber);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.functionName)
                +   Objects.hashCode(this.scriptId)
                +   Objects.hashCode(this.url)
                +   this.lineNumber
                +   this.columnNumber;
        }
    }
    
    /** Call frames for assertions or error messages. */
    public static class StackTrace
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { true, false, true, true, }; }
        
        /**
         * String label of this stack trace. For async traces this may be a name of the function that
         * initiated the async call.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String description;
        
        /** JavaScript function name. */
        public final RunTime.CallFrame[] callFrames;
        
        /**
         * Asynchronous JavaScript stack trace that preceded this stack, if available.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.StackTrace parent;
        
        /**
         * Asynchronous JavaScript stack trace that preceded this stack, if available.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
        <B CLASS=Exp>EXPERIMENTAL</B>
         */
        public final RunTime.StackTraceId parentId;
        
        /**
         * Constructor
         *
         * @param description 
         * String label of this stack trace. For async traces this may be a name of the function that
         * initiated the async call.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param callFrames JavaScript function name.
         * 
         * @param parent Asynchronous JavaScript stack trace that preceded this stack, if available.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param parentId Asynchronous JavaScript stack trace that preceded this stack, if available.
         * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
         */
        public StackTrace(
                String description, RunTime.CallFrame[] callFrames, RunTime.StackTrace parent, 
                RunTime.StackTraceId parentId
            )
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (callFrames == null) THROWS.throwNPE("callFrames");
            
            this.description  = description;
            this.callFrames   = callFrames;
            this.parent       = parent;
            this.parentId     = parentId;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'StackTrace'}.
         */
        public StackTrace (JsonObject jo)
        {
            this.description  = ReadJSON.getString(jo, "description", true, false);
            this.callFrames = (jo.getJsonArray("callFrames") == null)
                ? null
                : RJArrIntoStream.objArr(jo.getJsonArray("callFrames"), null, 0, RunTime.CallFrame.class).toArray(RunTime.CallFrame[]::new);
        
            this.parent       = ReadJSON.getObject(jo, "parent", RunTime.StackTrace.class, true, false);
            this.parentId     = ReadJSON.getObject(jo, "parentId", RunTime.StackTraceId.class, true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            StackTrace o = (StackTrace) other;
        
            return
                    Objects.equals(this.description, o.description)
                &&  Arrays.deepEquals(this.callFrames, o.callFrames)
                &&  Objects.equals(this.parent, o.parent)
                &&  Objects.equals(this.parentId, o.parentId);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.description)
                +   Arrays.deepHashCode(this.callFrames)
                +   this.parent.hashCode()
                +   this.parentId.hashCode();
        }
    }
    
    /**
     * If {@code debuggerId} is set stack trace comes from another debugger and can be resolved there. This
     * allows to track cross-debugger calls. See {@code RunTime.StackTrace} and {@code Debugger.paused} for usages.
     * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
     */
    public static class StackTraceId
        extends BaseType
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, true, }; }
        
        /** <CODE>[No Description Provided by Google]</CODE> */
        public final String id;
        
        /**
         * <CODE>[No Description Provided by Google]</CODE>
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final String debuggerId;
        
        /**
         * Constructor
         *
         * @param id -
         * 
         * @param debuggerId -
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public StackTraceId(String id, String debuggerId)
        {
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (id == null) THROWS.throwNPE("id");
            
            this.id          = id;
            this.debuggerId  = debuggerId;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'StackTraceId'}.
         */
        public StackTraceId (JsonObject jo)
        {
            this.id          = ReadJSON.getString(jo, "id", false, true);
            this.debuggerId  = ReadJSON.getString(jo, "debuggerId", true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            StackTraceId o = (StackTraceId) other;
        
            return
                    Objects.equals(this.id, o.id)
                &&  Objects.equals(this.debuggerId, o.debuggerId);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.id)
                +   Objects.hashCode(this.debuggerId);
        }
    }
    
    /**
     * Issued when all executionContexts were cleared in browser
     *
     * <BR /><BR />This is Marker-Event.  Marker-Event's are Events that do not posses
     * any data, fields or state.  When they are fired, only the event name is supplied.
     */
    public static class executionContextsCleared
        extends BrowserEvent
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
    
        public boolean[] optionals() { return new boolean[0]; }
    
        /** JSON Object Constructor */
        public executionContextsCleared(JsonObject jo)
        { super("RunTime", "executionContextsCleared", 0); }
    
        @Override
        public String toString() { return "RunTime.executionContextsCleared Marker Event\n"; }
    }
    
    /**
     * Notification is issued every time when binding is called.
     * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
     */
    public static class bindingCalled
        extends BrowserEvent
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, false, false, }; }
        
        /** <CODE>[No Description Provided by Google]</CODE> */
        public final String name;
        
        /** <CODE>[No Description Provided by Google]</CODE> */
        public final String payload;
        
        /** Identifier of the context where the call was made. */
        public final int executionContextId;
        
        /**
         * Constructor
         *
         * @param name -
         * 
         * @param payload -
         * 
         * @param executionContextId Identifier of the context where the call was made.
         */
        public bindingCalled(String name, String payload, int executionContextId)
        {
            super("RunTime", "bindingCalled", 3);
            
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (name == null)    THROWS.throwNPE("name");
            if (payload == null) THROWS.throwNPE("payload");
            
            this.name                = name;
            this.payload             = payload;
            this.executionContextId  = executionContextId;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'bindingCalled'}.
         */
        public bindingCalled (JsonObject jo)
        {
            super("RunTime", "bindingCalled", 3);
        
            this.name                = ReadJSON.getString(jo, "name", false, true);
            this.payload             = ReadJSON.getString(jo, "payload", false, true);
            this.executionContextId  = ReadPrimJSON.getInt(jo, "executionContextId");
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            bindingCalled o = (bindingCalled) other;
        
            return
                    Objects.equals(this.name, o.name)
                &&  Objects.equals(this.payload, o.payload)
                &&  Objects.equals(this.executionContextId, o.executionContextId);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.name)
                +   Objects.hashCode(this.payload)
                +   this.executionContextId;
        }
    }
    
    /** Issued when console API was called. */
    public static class consoleAPICalled
        extends BrowserEvent
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, false, false, false, true, true, }; }
        
        /** Type of the call. */
        public final String type;
        
        /** Call arguments. */
        public final RunTime.RemoteObject[] args;
        
        /** Identifier of the context where the call was made. */
        public final int executionContextId;
        
        /** Call timestamp. */
        public final Number timestamp;
        
        /**
         * Stack trace captured when the call was made. The async stack chain is automatically reported for
         * the following call types: {@code assert}, {@code error}, {@code trace}, {@code warning}. For other types the async call
         * chain can be retrieved using {@code Debugger.getStackTrace} and {@code stackTrace.parentId} field.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         */
        public final RunTime.StackTrace stackTrace;
        
        /**
         * Console context descriptor for calls on non-default console context (not console.*):
         * 'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call
         * on named context.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
        <B CLASS=Exp>EXPERIMENTAL</B>
         */
        public final String context;
        
        /**
         * Constructor
         *
         * @param type Type of the call.
         * <BR />Acceptable Values: ["log", "debug", "info", "error", "warning", "dir", "dirxml", "table", "trace", "clear", "startGroup", "startGroupCollapsed", "endGroup", "assert", "profile", "profileEnd", "count", "timeEnd"]
         * 
         * @param args Call arguments.
         * 
         * @param executionContextId Identifier of the context where the call was made.
         * 
         * @param timestamp Call timestamp.
         * 
         * @param stackTrace 
         * Stack trace captured when the call was made. The async stack chain is automatically reported for
         * the following call types: {@code assert}, {@code error}, {@code trace}, {@code warning}. For other types the async call
         * chain can be retrieved using {@code Debugger.getStackTrace} and {@code stackTrace.parentId} field.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
         * 
         * @param context 
         * Console context descriptor for calls on non-default console context (not console.*):
         * 'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call
         * on named context.
         * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
         */
        public consoleAPICalled(
                String type, RunTime.RemoteObject[] args, int executionContextId, Number timestamp, 
                RunTime.StackTrace stackTrace, String context
            )
        {
            super("RunTime", "consoleAPICalled", 6);
            
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (type == null)      THROWS.throwNPE("type");
            if (args == null)      THROWS.throwNPE("args");
            if (timestamp == null) THROWS.throwNPE("timestamp");
            
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            THROWS.checkIAE(
                "type", type,
                "log", "debug", "info", "error", "warning", "dir", "dirxml", "table", "trace", "clear", "startGroup", "startGroupCollapsed", "endGroup", "assert", "profile", "profileEnd", "count", "timeEnd"
            );
            
            this.type                = type;
            this.args                = args;
            this.executionContextId  = executionContextId;
            this.timestamp           = timestamp;
            this.stackTrace          = stackTrace;
            this.context             = context;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'consoleAPICalled'}.
         */
        public consoleAPICalled (JsonObject jo)
        {
            super("RunTime", "consoleAPICalled", 6);
        
            this.type                = ReadJSON.getString(jo, "type", false, true);
            this.args = (jo.getJsonArray("args") == null)
                ? null
                : RJArrIntoStream.objArr(jo.getJsonArray("args"), null, 0, RunTime.RemoteObject.class).toArray(RunTime.RemoteObject[]::new);
        
            this.executionContextId  = ReadPrimJSON.getInt(jo, "executionContextId");
            this.timestamp           = ReadNumberJSON.get(jo, "timestamp", false, true);
            this.stackTrace          = ReadJSON.getObject(jo, "stackTrace", RunTime.StackTrace.class, true, false);
            this.context             = ReadJSON.getString(jo, "context", true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            consoleAPICalled o = (consoleAPICalled) other;
        
            return
                    Objects.equals(this.type, o.type)
                &&  Arrays.deepEquals(this.args, o.args)
                &&  Objects.equals(this.executionContextId, o.executionContextId)
                &&  Objects.equals(this.timestamp, o.timestamp)
                &&  Objects.equals(this.stackTrace, o.stackTrace)
                &&  Objects.equals(this.context, o.context);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.type)
                +   Arrays.deepHashCode(this.args)
                +   this.executionContextId
                +   Objects.hashCode(this.timestamp)
                +   this.stackTrace.hashCode()
                +   Objects.hashCode(this.context);
        }
    }
    
    /** Issued when unhandled exception was revoked. */
    public static class exceptionRevoked
        extends BrowserEvent
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, false, }; }
        
        /** Reason describing why exception was revoked. */
        public final String reason;
        
        /** The id of revoked exception, as reported in {@code exceptionThrown}. */
        public final int exceptionId;
        
        /**
         * Constructor
         *
         * @param reason Reason describing why exception was revoked.
         * 
         * @param exceptionId The id of revoked exception, as reported in {@code exceptionThrown}.
         */
        public exceptionRevoked(String reason, int exceptionId)
        {
            super("RunTime", "exceptionRevoked", 2);
            
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (reason == null) THROWS.throwNPE("reason");
            
            this.reason       = reason;
            this.exceptionId  = exceptionId;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'exceptionRevoked'}.
         */
        public exceptionRevoked (JsonObject jo)
        {
            super("RunTime", "exceptionRevoked", 2);
        
            this.reason       = ReadJSON.getString(jo, "reason", false, true);
            this.exceptionId  = ReadPrimJSON.getInt(jo, "exceptionId");
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            exceptionRevoked o = (exceptionRevoked) other;
        
            return
                    Objects.equals(this.reason, o.reason)
                &&  (this.exceptionId == o.exceptionId);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.reason)
                +   this.exceptionId;
        }
    }
    
    /** Issued when exception was thrown and unhandled. */
    public static class exceptionThrown
        extends BrowserEvent
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, false, }; }
        
        /** Timestamp of the exception. */
        public final Number timestamp;
        
        /** <CODE>[No Description Provided by Google]</CODE> */
        public final RunTime.ExceptionDetails exceptionDetails;
        
        /**
         * Constructor
         *
         * @param timestamp Timestamp of the exception.
         * 
         * @param exceptionDetails -
         */
        public exceptionThrown(Number timestamp, RunTime.ExceptionDetails exceptionDetails)
        {
            super("RunTime", "exceptionThrown", 2);
            
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (timestamp == null)        THROWS.throwNPE("timestamp");
            if (exceptionDetails == null) THROWS.throwNPE("exceptionDetails");
            
            this.timestamp         = timestamp;
            this.exceptionDetails  = exceptionDetails;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'exceptionThrown'}.
         */
        public exceptionThrown (JsonObject jo)
        {
            super("RunTime", "exceptionThrown", 2);
        
            this.timestamp         = ReadNumberJSON.get(jo, "timestamp", false, true);
            this.exceptionDetails  = ReadJSON.getObject(jo, "exceptionDetails", RunTime.ExceptionDetails.class, false, true);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            exceptionThrown o = (exceptionThrown) other;
        
            return
                    Objects.equals(this.timestamp, o.timestamp)
                &&  Objects.equals(this.exceptionDetails, o.exceptionDetails);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.timestamp)
                +   this.exceptionDetails.hashCode();
        }
    }
    
    /** Issued when new execution context is created. */
    public static class executionContextCreated
        extends BrowserEvent
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, }; }
        
        /** A newly created execution context. */
        public final RunTime.ExecutionContextDescription context;
        
        /**
         * Constructor
         *
         * @param context A newly created execution context.
         */
        public executionContextCreated(RunTime.ExecutionContextDescription context)
        {
            super("RunTime", "executionContextCreated", 1);
            
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (context == null) THROWS.throwNPE("context");
            
            this.context  = context;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'executionContextCreated'}.
         */
        public executionContextCreated (JsonObject jo)
        {
            super("RunTime", "executionContextCreated", 1);
        
            this.context  = ReadJSON.getObject(jo, "context", RunTime.ExecutionContextDescription.class, false, true);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            executionContextCreated o = (executionContextCreated) other;
        
            return
                    Objects.equals(this.context, o.context);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    this.context.hashCode();
        }
    }
    
    /** Issued when execution context is destroyed. */
    public static class executionContextDestroyed
        extends BrowserEvent
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, false, }; }
        
        /**
         * Id of the destroyed context
         * <BR /><B CLASS=Dep>DEPRECATED</B>
         */
        public final int executionContextId;
        
        /**
         * Unique Id of the destroyed context
         * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
         */
        public final String executionContextUniqueId;
        
        /**
         * Constructor
         *
         * @param executionContextId Id of the destroyed context
         * <BR /><B CLASS=Dep>DEPRECATED</B>
         * 
         * @param executionContextUniqueId Unique Id of the destroyed context
         * <BR /><B CLASS=Exp>EXPERIMENTAL</B>
         */
        public executionContextDestroyed
            (int executionContextId, String executionContextUniqueId)
        {
            super("RunTime", "executionContextDestroyed", 2);
            
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (executionContextUniqueId == null) THROWS.throwNPE("executionContextUniqueId");
            
            this.executionContextId        = executionContextId;
            this.executionContextUniqueId  = executionContextUniqueId;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'executionContextDestroyed'}.
         */
        public executionContextDestroyed (JsonObject jo)
        {
            super("RunTime", "executionContextDestroyed", 2);
        
            this.executionContextId        = ReadPrimJSON.getInt(jo, "executionContextId");
            this.executionContextUniqueId  = ReadJSON.getString(jo, "executionContextUniqueId", false, true);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            executionContextDestroyed o = (executionContextDestroyed) other;
        
            return
                    Objects.equals(this.executionContextId, o.executionContextId)
                &&  Objects.equals(this.executionContextUniqueId, o.executionContextUniqueId);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    this.executionContextId
                +   Objects.hashCode(this.executionContextUniqueId);
        }
    }
    
    /**
     * Issued when object should be inspected (for example, as a result of inspect() command line API
     * call).
     */
    public static class inspectRequested
        extends BrowserEvent
        implements java.io.Serializable
    {
        /** For Object Serialization.  java.io.Serializable */
        protected static final long serialVersionUID = 1;
        
        public boolean[] optionals()
        { return new boolean[] { false, false, true, }; }
        
        /** <CODE>[No Description Provided by Google]</CODE> */
        public final RunTime.RemoteObject object;
        
        /** <CODE>[No Description Provided by Google]</CODE> */
        public final JsonObject hints;
        
        /**
         * Identifier of the context where the call was made.
         * <BR /><B CLASS=Opt>OPTIONAL</B>
        <B CLASS=Exp>EXPERIMENTAL</B>
         */
        public final Integer executionContextId;
        
        /**
         * Constructor
         *
         * @param object -
         * 
         * @param hints -
         * 
         * @param executionContextId Identifier of the context where the call was made.
         * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
         */
        public inspectRequested
            (RunTime.RemoteObject object, JsonObject hints, Integer executionContextId)
        {
            super("RunTime", "inspectRequested", 3);
            
            // Exception-Check(s) to ensure that if any parameters which are not declared as
            // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
            
            if (object == null) THROWS.throwNPE("object");
            if (hints == null)  THROWS.throwNPE("hints");
            
            this.object              = object;
            this.hints               = hints;
            this.executionContextId  = executionContextId;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'inspectRequested'}.
         */
        public inspectRequested (JsonObject jo)
        {
            super("RunTime", "inspectRequested", 3);
        
            this.object              = ReadJSON.getObject(jo, "object", RunTime.RemoteObject.class, false, true);
            this.hints               = jo.getJsonObject("hints");
            this.executionContextId  = ReadBoxedJSON.getInteger(jo, "executionContextId", true);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (this == other)                       return true;
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            inspectRequested o = (inspectRequested) other;
        
            return
                    Objects.equals(this.object, o.object)
                &&  Objects.equals(this.hints, o.hints)
                &&  Objects.equals(this.executionContextId, o.executionContextId);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    this.object.hashCode()
                +   Objects.hashCode(this.hints)
                +   Objects.hashCode(this.executionContextId);
        }
    }
    
    
    // Counter for keeping the WebSocket Request ID's distinct.
    private static int counter = 1;
    
    /**
     * Add handler to promise with given promise object id.
     * 
     * @param promiseObjectId Identifier of the promise.
     * 
     * @param returnByValue Whether the result is expected to be a JSON object that should be sent by value.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param generatePreview Whether preview should be generated for the result.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret2}&gt;</CODE>
     *
     * <BR /><BR />This {@link Script} may be <B STYLE='color:red'>executed</B> (using 
     * {@link Script#exec()}), and a {@link Promise} returned.
     *
     * <BR /><BR />When the {@code Promise} is <B STYLE='color: red'>awaited</B>
     * (using {@link Promise#await()}), the {@code Ret2} will subsequently
     * be returned from that call.
     * 
     * <BR /><BR />The <B STYLE='color: red'>returned</B> values are encapsulated
     * in an instance of <B>{@link Ret2}</B>
     *
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE><B>Ret2.a:</B> {@link RunTime.RemoteObject} (<B>result</B>)</CODE>
     *     <BR />Promise result. Will contain rejected value if promise was rejected.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret2.b:</B> {@link RunTime.ExceptionDetails} (<B>exceptionDetails</B>)</CODE>
     *     <BR />Exception details if stack strace is available.
     *     </LI>
     * </UL>
     */
    public static Script<String, JsonObject, Ret2<RunTime.RemoteObject, RunTime.ExceptionDetails>> awaitPromise
        (String promiseObjectId, Boolean returnByValue, Boolean generatePreview)
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (promiseObjectId == null) THROWS.throwNPE("promiseObjectId");
        
        final int       webSocketID = 5000000 + counter++;
        final boolean[] optionals   = { false, true, true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("awaitPromise"),
            parameterNames.get("awaitPromise"),
            optionals, webSocketID,
            "Runtime.awaitPromise",
            promiseObjectId, returnByValue, generatePreview
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON into Java-Type 'Ret2'
        Function<JsonObject, Ret2<RunTime.RemoteObject, RunTime.ExceptionDetails>> 
            responseProcessor = (JsonObject jo) -> new Ret2<>(
                ReadJSON.getObject(jo, "result", RunTime.RemoteObject.class, false, true),
                ReadJSON.getObject(jo, "exceptionDetails", RunTime.ExceptionDetails.class, true, false)
            );
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * Calls function with given declaration on the given object. Object group of the result is
     * inherited from the target object.
     * 
     * @param functionDeclaration Declaration of the function to call.
     * 
     * @param objectId 
     * Identifier of the object to call function on. Either objectId or executionContextId should
     * be specified.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param arguments 
     * Call arguments. All call arguments must belong to the same JavaScript world as the target
     * object.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param silent 
     * In silent mode exceptions thrown during evaluation are not reported and do not pause
     * execution. Overrides {@code setPauseOnException} state.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param returnByValue 
     * Whether the result is expected to be a JSON object which should be sent by value.
     * Can be overriden by {@code serializationOptions}.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param generatePreview Whether preview should be generated for the result.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param userGesture Whether execution should be treated as initiated by user in the UI.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param awaitPromise 
     * Whether execution should {@code await} for resulting value and return once awaited promise is
     * resolved.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param executionContextId 
     * Specifies execution context which global object will be used to call function on. Either
     * executionContextId or objectId should be specified.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param objectGroup 
     * Symbolic group name that can be used to release multiple objects. If objectGroup is not
     * specified and objectId is, objectGroup will be inherited from object.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param throwOnSideEffect Whether to throw an exception if side effect cannot be ruled out during evaluation.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param uniqueContextId 
     * An alternative way to specify the execution context to call function on.
     * Compared to contextId that may be reused across processes, this is guaranteed to be
     * system-unique, so it can be used to prevent accidental function call
     * in context different than intended (e.g. as a result of navigation across process
     * boundaries).
     * This is mutually exclusive with {@code executionContextId}.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param serializationOptions 
     * Specifies the result serialization. If provided, overrides
     * {@code generatePreview} and {@code returnByValue}.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret2}&gt;</CODE>
     *
     * <BR /><BR />This {@link Script} may be <B STYLE='color:red'>executed</B> (using 
     * {@link Script#exec()}), and a {@link Promise} returned.
     *
     * <BR /><BR />When the {@code Promise} is <B STYLE='color: red'>awaited</B>
     * (using {@link Promise#await()}), the {@code Ret2} will subsequently
     * be returned from that call.
     * 
     * <BR /><BR />The <B STYLE='color: red'>returned</B> values are encapsulated
     * in an instance of <B>{@link Ret2}</B>
     *
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE><B>Ret2.a:</B> {@link RunTime.RemoteObject} (<B>result</B>)</CODE>
     *     <BR />Call result.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret2.b:</B> {@link RunTime.ExceptionDetails} (<B>exceptionDetails</B>)</CODE>
     *     <BR />Exception details.
     *     </LI>
     * </UL>
     */
    public static Script<String, JsonObject, Ret2<RunTime.RemoteObject, RunTime.ExceptionDetails>> callFunctionOn(
            String functionDeclaration, String objectId, RunTime.CallArgument[] arguments, 
            Boolean silent, Boolean returnByValue, Boolean generatePreview, Boolean userGesture, 
            Boolean awaitPromise, Integer executionContextId, String objectGroup, 
            Boolean throwOnSideEffect, String uniqueContextId, 
            RunTime.SerializationOptions serializationOptions
        )
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (functionDeclaration == null) THROWS.throwNPE("functionDeclaration");
        
        final int       webSocketID = 5001000 + counter++;
        final boolean[] optionals   = { false, true, true, true, true, true, true, true, true, true, true, true, true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("callFunctionOn"),
            parameterNames.get("callFunctionOn"),
            optionals, webSocketID,
            "Runtime.callFunctionOn",
            functionDeclaration, objectId, arguments, silent, returnByValue, generatePreview,
            userGesture, awaitPromise, executionContextId, objectGroup, throwOnSideEffect,
            uniqueContextId, serializationOptions
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON into Java-Type 'Ret2'
        Function<JsonObject, Ret2<RunTime.RemoteObject, RunTime.ExceptionDetails>> 
            responseProcessor = (JsonObject jo) -> new Ret2<>(
                ReadJSON.getObject(jo, "result", RunTime.RemoteObject.class, false, true),
                ReadJSON.getObject(jo, "exceptionDetails", RunTime.ExceptionDetails.class, true, false)
            );
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * Compiles expression.
     * 
     * @param expression Expression to compile.
     * 
     * @param sourceURL Source url to be set for the script.
     * 
     * @param persistScript Specifies whether the compiled script should be persisted.
     * 
     * @param executionContextId 
     * Specifies in which execution context to perform script run. If the parameter is omitted the
     * evaluation will be performed in the context of the inspected page.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret2}&gt;</CODE>
     *
     * <BR /><BR />This {@link Script} may be <B STYLE='color:red'>executed</B> (using 
     * {@link Script#exec()}), and a {@link Promise} returned.
     *
     * <BR /><BR />When the {@code Promise} is <B STYLE='color: red'>awaited</B>
     * (using {@link Promise#await()}), the {@code Ret2} will subsequently
     * be returned from that call.
     * 
     * <BR /><BR />The <B STYLE='color: red'>returned</B> values are encapsulated
     * in an instance of <B>{@link Ret2}</B>
     *
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE><B>Ret2.a:</B> String (<B>scriptId</B>)</CODE>
     *     <BR />Id of the script.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret2.b:</B> {@link RunTime.ExceptionDetails} (<B>exceptionDetails</B>)</CODE>
     *     <BR />Exception details.
     *     </LI>
     * </UL>
     */
    public static Script<String, JsonObject, Ret2<String, RunTime.ExceptionDetails>> compileScript
        (String expression, String sourceURL, boolean persistScript, Integer executionContextId)
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (expression == null) THROWS.throwNPE("expression");
        if (sourceURL == null)  THROWS.throwNPE("sourceURL");
        
        final int       webSocketID = 5002000 + counter++;
        final boolean[] optionals   = { false, false, false, true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("compileScript"),
            parameterNames.get("compileScript"),
            optionals, webSocketID,
            "Runtime.compileScript",
            expression, sourceURL, persistScript, executionContextId
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON into Java-Type 'Ret2'
        Function<JsonObject, Ret2<String, RunTime.ExceptionDetails>> 
            responseProcessor = (JsonObject jo) -> new Ret2<>(
                ReadJSON.getString(jo, "scriptId", true, false),
                ReadJSON.getObject(jo, "exceptionDetails", RunTime.ExceptionDetails.class, true, false)
            );
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * Disables reporting of execution contexts creation.
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> disable()
    {
        final int          webSocketID = 5003000 + counter++;
        final boolean[]    optionals   = new boolean[0];
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("disable"),
            parameterNames.get("disable"),
            optionals, webSocketID,
            "Runtime.disable"
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * Discards collected exceptions and console API calls.
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> discardConsoleEntries()
    {
        final int          webSocketID = 5004000 + counter++;
        final boolean[]    optionals   = new boolean[0];
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("discardConsoleEntries"),
            parameterNames.get("discardConsoleEntries"),
            optionals, webSocketID,
            "Runtime.discardConsoleEntries"
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * Enables reporting of execution contexts creation by means of {@code executionContextCreated} event.
     * When the reporting gets enabled the event will be sent immediately for each existing execution
     * context.
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> enable()
    {
        final int          webSocketID = 5005000 + counter++;
        final boolean[]    optionals   = new boolean[0];
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("enable"),
            parameterNames.get("enable"),
            optionals, webSocketID,
            "Runtime.enable"
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * Evaluates expression on global object.
     * 
     * @param expression Expression to evaluate.
     * 
     * @param objectGroup Symbolic group name that can be used to release multiple objects.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param includeCommandLineAPI Determines whether Command Line API should be available during the evaluation.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param silent 
     * In silent mode exceptions thrown during evaluation are not reported and do not pause
     * execution. Overrides {@code setPauseOnException} state.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param contextId 
     * Specifies in which execution context to perform evaluation. If the parameter is omitted the
     * evaluation will be performed in the context of the inspected page.
     * This is mutually exclusive with {@code uniqueContextId}, which offers an
     * alternative way to identify the execution context that is more reliable
     * in a multi-process environment.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param returnByValue Whether the result is expected to be a JSON object that should be sent by value.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param generatePreview Whether preview should be generated for the result.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param userGesture Whether execution should be treated as initiated by user in the UI.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param awaitPromise 
     * Whether execution should {@code await} for resulting value and return once awaited promise is
     * resolved.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param throwOnSideEffect 
     * Whether to throw an exception if side effect cannot be ruled out during evaluation.
     * This implies {@code disableBreaks} below.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param timeout Terminate execution after timing out (number of milliseconds).
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param disableBreaks Disable breakpoints during execution.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param replMode 
     * Setting this flag to true enables {@code let} re-declaration and top-level {@code await}.
     * Note that {@code let} variables can only be re-declared if they originate from
     * {@code replMode} themselves.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param allowUnsafeEvalBlockedByCSP 
     * The Content Security Policy (CSP) for the target might block 'unsafe-eval'
     * which includes eval(), Function(), setTimeout() and setInterval()
     * when called with non-callable arguments. This flag bypasses CSP for this
     * evaluation and allows unsafe-eval. Defaults to true.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param uniqueContextId 
     * An alternative way to specify the execution context to evaluate in.
     * Compared to contextId that may be reused across processes, this is guaranteed to be
     * system-unique, so it can be used to prevent accidental evaluation of the expression
     * in context different than intended (e.g. as a result of navigation across process
     * boundaries).
     * This is mutually exclusive with {@code contextId}.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param serializationOptions 
     * Specifies the result serialization. If provided, overrides
     * {@code generatePreview} and {@code returnByValue}.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret2}&gt;</CODE>
     *
     * <BR /><BR />This {@link Script} may be <B STYLE='color:red'>executed</B> (using 
     * {@link Script#exec()}), and a {@link Promise} returned.
     *
     * <BR /><BR />When the {@code Promise} is <B STYLE='color: red'>awaited</B>
     * (using {@link Promise#await()}), the {@code Ret2} will subsequently
     * be returned from that call.
     * 
     * <BR /><BR />The <B STYLE='color: red'>returned</B> values are encapsulated
     * in an instance of <B>{@link Ret2}</B>
     *
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE><B>Ret2.a:</B> {@link RunTime.RemoteObject} (<B>result</B>)</CODE>
     *     <BR />Evaluation result.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret2.b:</B> {@link RunTime.ExceptionDetails} (<B>exceptionDetails</B>)</CODE>
     *     <BR />Exception details.
     *     </LI>
     * </UL>
     */
    public static Script<String, JsonObject, Ret2<RunTime.RemoteObject, RunTime.ExceptionDetails>> evaluate(
            String expression, String objectGroup, Boolean includeCommandLineAPI, Boolean silent, 
            Integer contextId, Boolean returnByValue, Boolean generatePreview, Boolean userGesture, 
            Boolean awaitPromise, Boolean throwOnSideEffect, Number timeout, Boolean disableBreaks, 
            Boolean replMode, Boolean allowUnsafeEvalBlockedByCSP, String uniqueContextId, 
            RunTime.SerializationOptions serializationOptions
        )
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (expression == null) THROWS.throwNPE("expression");
        
        final int       webSocketID = 5006000 + counter++;
        final boolean[] optionals   = { false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("evaluate"),
            parameterNames.get("evaluate"),
            optionals, webSocketID,
            "Runtime.evaluate",
            expression, objectGroup, includeCommandLineAPI, silent, contextId, returnByValue,
            generatePreview, userGesture, awaitPromise, throwOnSideEffect, timeout, disableBreaks,
            replMode, allowUnsafeEvalBlockedByCSP, uniqueContextId, serializationOptions
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON into Java-Type 'Ret2'
        Function<JsonObject, Ret2<RunTime.RemoteObject, RunTime.ExceptionDetails>> 
            responseProcessor = (JsonObject jo) -> new Ret2<>(
                ReadJSON.getObject(jo, "result", RunTime.RemoteObject.class, false, true),
                ReadJSON.getObject(jo, "exceptionDetails", RunTime.ExceptionDetails.class, true, false)
            );
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * Returns the isolate id.
     * <BR /><B CLASS=Exp-Top>EXPERIMENTAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * String&gt;</CODE>
     * 
     * <BR /><BR />This <B>script</B> may be <B STYLE='color: red'>executed</B>, using
     * {@link Script#exec()}, and afterwards, a {@link Promise}<CODE>&lt;JsonObject,
     * String&gt;</CODE> will be returned.
     *
     * <BR /><BR />Finally, the <B>{@code Promise}</B> may be <B STYLE='color: red'>awaited</B>,
     * using {@link Promise#await()}, <I>and the returned result of this Browser Function may
      * may be retrieved.</I>
     *
     * <BR /><BR />This Browser Function <B STYLE='color: red'>returns</B>
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE>String (<B>id</B></CODE>)
     *     <BR />The isolate id.
     * </LI>
     * </UL> */
    public static Script<String, JsonObject, String> getIsolateId()
    {
        final int          webSocketID = 5007000 + counter++;
        final boolean[]    optionals   = new boolean[0];
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("getIsolateId"),
            parameterNames.get("getIsolateId"),
            optionals, webSocketID,
            "Runtime.getIsolateId"
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON to 'String'
        Function<JsonObject, String> responseProcessor = (JsonObject jo) ->
            ReadJSON.getString(jo, "id", false, true);
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * Returns the JavaScript heap usage.
     * It is the total usage of the corresponding isolate not scoped to a particular RunTime.
     * <BR /><B CLASS=Exp-Top>EXPERIMENTAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret4}&gt;</CODE>
     *
     * <BR /><BR />This {@link Script} may be <B STYLE='color:red'>executed</B> (using 
     * {@link Script#exec()}), and a {@link Promise} returned.
     *
     * <BR /><BR />When the {@code Promise} is <B STYLE='color: red'>awaited</B>
     * (using {@link Promise#await()}), the {@code Ret4} will subsequently
     * be returned from that call.
     * 
     * <BR /><BR />The <B STYLE='color: red'>returned</B> values are encapsulated
     * in an instance of <B>{@link Ret4}</B>
     *
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE><B>Ret4.a:</B> Number (<B>usedSize</B>)</CODE>
     *     <BR />Used JavaScript heap size in bytes.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret4.b:</B> Number (<B>totalSize</B>)</CODE>
     *     <BR />Allocated JavaScript heap size in bytes.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret4.c:</B> Number (<B>embedderHeapUsedSize</B>)</CODE>
     *     <BR />Used size in bytes in the embedder's garbage-collected heap.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret4.d:</B> Number (<B>backingStorageSize</B>)</CODE>
     *     <BR />Size in bytes of backing storage for array buffers and external strings.
     *     </LI>
     * </UL>
     */
    public static Script<String, JsonObject, Ret4<Number, Number, Number, Number>> getHeapUsage()
    {
        final int          webSocketID = 5008000 + counter++;
        final boolean[]    optionals   = new boolean[0];
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("getHeapUsage"),
            parameterNames.get("getHeapUsage"),
            optionals, webSocketID,
            "Runtime.getHeapUsage"
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON into Java-Type 'Ret4'
        Function<JsonObject, Ret4<Number, Number, Number, Number>> 
            responseProcessor = (JsonObject jo) -> new Ret4<>(
                ReadNumberJSON.get(jo, "usedSize", false, true),
                ReadNumberJSON.get(jo, "totalSize", false, true),
                ReadNumberJSON.get(jo, "embedderHeapUsedSize", false, true),
                ReadNumberJSON.get(jo, "backingStorageSize", false, true)
            );
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * Returns properties of a given object. Object group of the result is inherited from the target
     * object.
     * 
     * @param objectId Identifier of the object to return properties for.
     * 
     * @param ownProperties 
     * If true, returns properties belonging only to the element itself, not to its prototype
     * chain.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param accessorPropertiesOnly 
     * If true, returns accessor properties (with getter/setter) only; internal properties are not
     * returned either.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param generatePreview Whether preview should be generated for the results.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @param nonIndexedPropertiesOnly If true, returns non-indexed properties only.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret4}&gt;</CODE>
     *
     * <BR /><BR />This {@link Script} may be <B STYLE='color:red'>executed</B> (using 
     * {@link Script#exec()}), and a {@link Promise} returned.
     *
     * <BR /><BR />When the {@code Promise} is <B STYLE='color: red'>awaited</B>
     * (using {@link Promise#await()}), the {@code Ret4} will subsequently
     * be returned from that call.
     * 
     * <BR /><BR />The <B STYLE='color: red'>returned</B> values are encapsulated
     * in an instance of <B>{@link Ret4}</B>
     *
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE><B>Ret4.a:</B> {@link RunTime.PropertyDescriptor}[] (<B>result</B>)</CODE>
     *     <BR />Object properties.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret4.b:</B> {@link RunTime.InternalPropertyDescriptor}[] (<B>internalProperties</B>)</CODE>
     *     <BR />Internal object properties (only of the element itself).
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret4.c:</B> {@link RunTime.PrivatePropertyDescriptor}[] (<B>privateProperties</B>)</CODE>
     *     <BR />Object private properties.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret4.d:</B> {@link RunTime.ExceptionDetails} (<B>exceptionDetails</B>)</CODE>
     *     <BR />Exception details.
     *     </LI>
     * </UL>
     */
    public static Script<String, JsonObject, Ret4<RunTime.PropertyDescriptor[], RunTime.InternalPropertyDescriptor[], RunTime.PrivatePropertyDescriptor[], RunTime.ExceptionDetails>> 
        getProperties(
            String objectId, Boolean ownProperties, Boolean accessorPropertiesOnly, 
            Boolean generatePreview, Boolean nonIndexedPropertiesOnly
        )
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (objectId == null) THROWS.throwNPE("objectId");
        
        final int       webSocketID = 5009000 + counter++;
        final boolean[] optionals   = { false, true, true, true, true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("getProperties"),
            parameterNames.get("getProperties"),
            optionals, webSocketID,
            "Runtime.getProperties",
            objectId, ownProperties, accessorPropertiesOnly, generatePreview,
            nonIndexedPropertiesOnly
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON into Java-Type 'Ret4'
        Function<JsonObject, Ret4<RunTime.PropertyDescriptor[], RunTime.InternalPropertyDescriptor[], RunTime.PrivatePropertyDescriptor[], RunTime.ExceptionDetails>> 
            responseProcessor = (JsonObject jo) -> new Ret4<>(
                (jo.getJsonArray("result") == null)
                    ? null
                    : RJArrIntoStream.objArr(jo.getJsonArray("result"), null, 0, RunTime.PropertyDescriptor.class).toArray(RunTime.PropertyDescriptor[]::new),
                (jo.getJsonArray("internalProperties") == null)
                    ? null
                    : RJArrIntoStream.objArr(jo.getJsonArray("internalProperties"), null, 0, RunTime.InternalPropertyDescriptor.class).toArray(RunTime.InternalPropertyDescriptor[]::new),
                (jo.getJsonArray("privateProperties") == null)
                    ? null
                    : RJArrIntoStream.objArr(jo.getJsonArray("privateProperties"), null, 0, RunTime.PrivatePropertyDescriptor.class).toArray(RunTime.PrivatePropertyDescriptor[]::new),
                ReadJSON.getObject(jo, "exceptionDetails", RunTime.ExceptionDetails.class, true, false)
            );
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * Returns all let, const and class variables from global scope.
     * 
     * @param executionContextId Specifies in which execution context to lookup global scope variables.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * String[]&gt;</CODE>
     * 
     * <BR /><BR />This <B>script</B> may be <B STYLE='color: red'>executed</B>, using
     * {@link Script#exec()}, and afterwards, a {@link Promise}<CODE>&lt;JsonObject,
     * String[]&gt;</CODE> will be returned.
     *
     * <BR /><BR />Finally, the <B>{@code Promise}</B> may be <B STYLE='color: red'>awaited</B>,
     * using {@link Promise#await()}, <I>and the returned result of this Browser Function may
      * may be retrieved.</I>
     *
     * <BR /><BR />This Browser Function <B STYLE='color: red'>returns</B>
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE>String[] (<B>names</B></CODE>)
     *     <BR />-
     * </LI>
     * </UL> */
    public static Script<String, JsonObject, String[]> globalLexicalScopeNames
        (Integer executionContextId)
    {
        final int       webSocketID = 5010000 + counter++;
        final boolean[] optionals   = { true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("globalLexicalScopeNames"),
            parameterNames.get("globalLexicalScopeNames"),
            optionals, webSocketID,
            "Runtime.globalLexicalScopeNames",
            executionContextId
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON to 'String[]'
        Function<JsonObject, String[]> responseProcessor = (JsonObject jo) ->
            (jo.getJsonArray("names") == null)
                ? null
                : RJArrIntoStream.strArr(jo.getJsonArray("names"), null, 0).toArray(String[]::new);
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * <CODE>[No Description Provided by Google]</CODE>
     * 
     * @param prototypeObjectId Identifier of the prototype to return objects for.
     * 
     * @param objectGroup Symbolic group name that can be used to release the results.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link RunTime.RemoteObject}&gt;</CODE>
     * 
     * <BR /><BR />This <B>script</B> may be <B STYLE='color: red'>executed</B>, using
     * {@link Script#exec()}, and afterwards, a {@link Promise}<CODE>&lt;JsonObject,
     * {@link RunTime.RemoteObject}&gt;</CODE> will be returned.
     *
     * <BR /><BR />Finally, the <B>{@code Promise}</B> may be <B STYLE='color: red'>awaited</B>,
     * using {@link Promise#await()}, <I>and the returned result of this Browser Function may
      * may be retrieved.</I>
     *
     * <BR /><BR />This Browser Function <B STYLE='color: red'>returns</B>
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE>{@link RunTime.RemoteObject} (<B>objects</B></CODE>)
     *     <BR />Array with objects.
     * </LI>
     * </UL> */
    public static Script<String, JsonObject, RunTime.RemoteObject> queryObjects
        (String prototypeObjectId, String objectGroup)
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (prototypeObjectId == null) THROWS.throwNPE("prototypeObjectId");
        
        final int       webSocketID = 5011000 + counter++;
        final boolean[] optionals   = { false, true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("queryObjects"),
            parameterNames.get("queryObjects"),
            optionals, webSocketID,
            "Runtime.queryObjects",
            prototypeObjectId, objectGroup
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON to 'RunTime.RemoteObject'
        Function<JsonObject, RunTime.RemoteObject> responseProcessor = (JsonObject jo) ->
            ReadJSON.getObject(jo, "objects", RunTime.RemoteObject.class, false, true);
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * Releases remote object with given id.
     * 
     * @param objectId Identifier of the object to release.
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> releaseObject(String objectId)
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (objectId == null) THROWS.throwNPE("objectId");
        
        final int       webSocketID = 5012000 + counter++;
        final boolean[] optionals   = { false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("releaseObject"),
            parameterNames.get("releaseObject"),
            optionals, webSocketID,
            "Runtime.releaseObject",
            objectId
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * Releases all remote objects that belong to a given group.
     * 
     * @param objectGroup Symbolic object group name.
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> releaseObjectGroup(String objectGroup)
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (objectGroup == null) THROWS.throwNPE("objectGroup");
        
        final int       webSocketID = 5013000 + counter++;
        final boolean[] optionals   = { false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("releaseObjectGroup"),
            parameterNames.get("releaseObjectGroup"),
            optionals, webSocketID,
            "Runtime.releaseObjectGroup",
            objectGroup
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * Tells inspected instance to run if it was waiting for debugger to attach.
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> runIfWaitingForDebugger()
    {
        final int          webSocketID = 5014000 + counter++;
        final boolean[]    optionals   = new boolean[0];
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("runIfWaitingForDebugger"),
            parameterNames.get("runIfWaitingForDebugger"),
            optionals, webSocketID,
            "Runtime.runIfWaitingForDebugger"
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * Runs script with given id in a given context.
     * 
     * @param scriptId Id of the script to run.
     * 
     * @param executionContextId 
     * Specifies in which execution context to perform script run. If the parameter is omitted the
     * evaluation will be performed in the context of the inspected page.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param objectGroup Symbolic group name that can be used to release multiple objects.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param silent 
     * In silent mode exceptions thrown during evaluation are not reported and do not pause
     * execution. Overrides {@code setPauseOnException} state.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param includeCommandLineAPI Determines whether Command Line API should be available during the evaluation.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param returnByValue Whether the result is expected to be a JSON object which should be sent by value.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param generatePreview Whether preview should be generated for the result.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @param awaitPromise 
     * Whether execution should {@code await} for resulting value and return once awaited promise is
     * resolved.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret2}&gt;</CODE>
     *
     * <BR /><BR />This {@link Script} may be <B STYLE='color:red'>executed</B> (using 
     * {@link Script#exec()}), and a {@link Promise} returned.
     *
     * <BR /><BR />When the {@code Promise} is <B STYLE='color: red'>awaited</B>
     * (using {@link Promise#await()}), the {@code Ret2} will subsequently
     * be returned from that call.
     * 
     * <BR /><BR />The <B STYLE='color: red'>returned</B> values are encapsulated
     * in an instance of <B>{@link Ret2}</B>
     *
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE><B>Ret2.a:</B> {@link RunTime.RemoteObject} (<B>result</B>)</CODE>
     *     <BR />Run result.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret2.b:</B> {@link RunTime.ExceptionDetails} (<B>exceptionDetails</B>)</CODE>
     *     <BR />Exception details.
     *     </LI>
     * </UL>
     */
    public static Script<String, JsonObject, Ret2<RunTime.RemoteObject, RunTime.ExceptionDetails>> runScript(
            String scriptId, Integer executionContextId, String objectGroup, Boolean silent, 
            Boolean includeCommandLineAPI, Boolean returnByValue, Boolean generatePreview, 
            Boolean awaitPromise
        )
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (scriptId == null) THROWS.throwNPE("scriptId");
        
        final int       webSocketID = 5015000 + counter++;
        final boolean[] optionals   = { false, true, true, true, true, true, true, true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("runScript"),
            parameterNames.get("runScript"),
            optionals, webSocketID,
            "Runtime.runScript",
            scriptId, executionContextId, objectGroup, silent, includeCommandLineAPI, returnByValue,
            generatePreview, awaitPromise
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON into Java-Type 'Ret2'
        Function<JsonObject, Ret2<RunTime.RemoteObject, RunTime.ExceptionDetails>> 
            responseProcessor = (JsonObject jo) -> new Ret2<>(
                ReadJSON.getObject(jo, "result", RunTime.RemoteObject.class, false, true),
                ReadJSON.getObject(jo, "exceptionDetails", RunTime.ExceptionDetails.class, true, false)
            );
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * Enables or disables async call stacks tracking.
     * 
     * @param maxDepth 
     * Maximum depth of async call stacks. Setting to {@code 0} will effectively disable collecting async
     * call stacks (default).
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> setAsyncCallStackDepth(int maxDepth)
    {
        final int       webSocketID = 5016000 + counter++;
        final boolean[] optionals   = { false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("setAsyncCallStackDepth"),
            parameterNames.get("setAsyncCallStackDepth"),
            optionals, webSocketID,
            "Runtime.setAsyncCallStackDepth",
            maxDepth
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * <CODE>[No Description Provided by Google]</CODE>
     * <BR /><B CLASS=Exp-Top>EXPERIMENTAL</B>
     * 
     * @param enabled -
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> setCustomObjectFormatterEnabled
        (boolean enabled)
    {
        final int       webSocketID = 5017000 + counter++;
        final boolean[] optionals   = { false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("setCustomObjectFormatterEnabled"),
            parameterNames.get("setCustomObjectFormatterEnabled"),
            optionals, webSocketID,
            "Runtime.setCustomObjectFormatterEnabled",
            enabled
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * <CODE>[No Description Provided by Google]</CODE>
     * <BR /><B CLASS=Exp-Top>EXPERIMENTAL</B>
     * 
     * @param size -
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> setMaxCallStackSizeToCapture(int size)
    {
        final int       webSocketID = 5018000 + counter++;
        final boolean[] optionals   = { false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("setMaxCallStackSizeToCapture"),
            parameterNames.get("setMaxCallStackSizeToCapture"),
            optionals, webSocketID,
            "Runtime.setMaxCallStackSizeToCapture",
            size
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * Terminate current or next JavaScript execution.
     * Will cancel the termination when the outer-most script execution ends.
     * <BR /><B CLASS=Exp-Top>EXPERIMENTAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> terminateExecution()
    {
        final int          webSocketID = 5019000 + counter++;
        final boolean[]    optionals   = new boolean[0];
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("terminateExecution"),
            parameterNames.get("terminateExecution"),
            optionals, webSocketID,
            "Runtime.terminateExecution"
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * If executionContextId is empty, adds binding with the given name on the
     * global objects of all inspected contexts, including those created later,
     * bindings survive reloads.
     * Binding function takes exactly one argument, this argument should be string,
     * in case of any other input, function throws an exception.
     * Each binding function call produces RunTime.bindingCalled notification.
     * 
     * @param name -
     * 
     * @param executionContextId 
     * If specified, the binding would only be exposed to the specified
     * execution context. If omitted and {@code executionContextName} is not set,
     * the binding is exposed to all execution contexts of the target.
     * This parameter is mutually exclusive with {@code executionContextName}.
     * Deprecated in favor of {@code executionContextName} due to an unclear use case
     * and bugs in implementation (crbug.com/1169639). {@code executionContextId} will be
     * removed in the future.
     * <BR /><B CLASS=Opt>OPTIONAL</B><B CLASS=Exp>EXPERIMENTAL</B><B CLASS=Dep>DEPRECATED</B>
     * 
     * @param executionContextName 
     * If specified, the binding is exposed to the executionContext with
     * matching name, even for contexts created after the binding is added.
     * See also {@code ExecutionContext.name} and {@code worldName} parameter to
     * {@code Page.addScriptToEvaluateOnNewDocument}.
     * This parameter is mutually exclusive with {@code executionContextId}.
     * <BR /><B CLASS=Opt>OPTIONAL</B>
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> addBinding
        (String name, Integer executionContextId, String executionContextName)
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (name == null) THROWS.throwNPE("name");
        
        final int       webSocketID = 5020000 + counter++;
        final boolean[] optionals   = { false, true, true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("addBinding"),
            parameterNames.get("addBinding"),
            optionals, webSocketID,
            "Runtime.addBinding",
            name, executionContextId, executionContextName
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * This method does not remove binding function from global object but
     * unsubscribes current runtime agent from RunTime.bindingCalled notifications.
     * 
     * @param name -
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link Ret0}&gt;</CODE>
     *
     * <BR /><BR />This {@code Script} instance must be <B STYLE='color:red'>executed</B> before the
     * browser receives the invocation-request.
     *
     * <BR /><BR />This Browser-Function <I>does not have</I> a return-value.  You may choose to
     * <B STYLE='color: red'>await</B> the {@link Promise}{@code <JsonObject,} {@link Ret0}
     * {@code >} to ensure the Browser Function has run to completion.
     */
    public static Script<String, JsonObject, Ret0> removeBinding(String name)
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (name == null) THROWS.throwNPE("name");
        
        final int       webSocketID = 5021000 + counter++;
        final boolean[] optionals   = { false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("removeBinding"),
            parameterNames.get("removeBinding"),
            optionals, webSocketID,
            "Runtime.removeBinding",
            name
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (webSocketID, requestJSON, VOID_RETURN.NoReturnValues);
    }
    
    /**
     * This method tries to lookup and populate exception details for a
     * JavaScript Error object.
     * Note that the stackTrace portion of the resulting exceptionDetails will
     * only be populated if the RunTime domain was enabled at the time when the
     * Error was thrown.
     * <BR /><B CLASS=Exp-Top>EXPERIMENTAL</B>
     * 
     * @param errorObjectId The error object for which to resolve the exception details.
     * 
     * @return An instance of <CODE>{@link Script}&lt;String, {@link JsonObject},
     * {@link RunTime.ExceptionDetails}&gt;</CODE>
     * 
     * <BR /><BR />This <B>script</B> may be <B STYLE='color: red'>executed</B>, using
     * {@link Script#exec()}, and afterwards, a {@link Promise}<CODE>&lt;JsonObject,
     * {@link RunTime.ExceptionDetails}&gt;</CODE> will be returned.
     *
     * <BR /><BR />Finally, the <B>{@code Promise}</B> may be <B STYLE='color: red'>awaited</B>,
     * using {@link Promise#await()}, <I>and the returned result of this Browser Function may
      * may be retrieved.</I>
     *
     * <BR /><BR />This Browser Function <B STYLE='color: red'>returns</B>
     * <BR /><BR /><UL CLASS=JDUL>
     * <LI><CODE>{@link RunTime.ExceptionDetails} (<B>exceptionDetails</B></CODE>)
     *     <BR />-
     * </LI>
     * </UL> */
    public static Script<String, JsonObject, RunTime.ExceptionDetails> getExceptionDetails
        (String errorObjectId)
    {
        // Exception-Check(s) to ensure that if any parameters which are not declared as
        // 'Optional', but have a 'null' value anyway, that a NullPointerException shall throw.
        
        if (errorObjectId == null) THROWS.throwNPE("errorObjectId");
        
        final int       webSocketID = 5022000 + counter++;
        final boolean[] optionals   = { false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("getExceptionDetails"),
            parameterNames.get("getExceptionDetails"),
            optionals, webSocketID,
            "Runtime.getExceptionDetails",
            errorObjectId
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON to 'RunTime.ExceptionDetails'
        Function<JsonObject, RunTime.ExceptionDetails> responseProcessor = (JsonObject jo) ->
            ReadJSON.getObject(jo, "exceptionDetails", RunTime.ExceptionDetails.class, true, false);
        
        return new Script<>(webSocketID, requestJSON, responseProcessor);
    }
    
}