package Torello.Browser;

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.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>A domain for letting clients substitute browser's network layer with client code.</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 Fetch
{
    // ********************************************************************************************
    // ********************************************************************************************
    // Class Header Stuff
    // ********************************************************************************************
    // ********************************************************************************************


    // No Pubic Constructors
    private Fetch () { }

    // 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 : Fetch.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;

        parameterNames.put("disable", EMPTY_VEC_STR);

        v = new Vector<String>(2);
        parameterNames.put("enable", v);
        Collections.addAll(v, new String[]
        { "patterns", "handleAuthRequests", });

        v = new Vector<String>(2);
        parameterNames.put("failRequest", v);
        Collections.addAll(v, new String[]
        { "requestId", "errorReason", });

        v = new Vector<String>(6);
        parameterNames.put("fulfillRequest", v);
        Collections.addAll(v, new String[]
        { "requestId", "responseCode", "responseHeaders", "binaryResponseHeaders", "body", "responsePhrase", });

        v = new Vector<String>(6);
        parameterNames.put("continueRequest", v);
        Collections.addAll(v, new String[]
        { "requestId", "url", "method", "postData", "headers", "interceptResponse", });

        v = new Vector<String>(2);
        parameterNames.put("continueWithAuth", v);
        Collections.addAll(v, new String[]
        { "requestId", "authChallengeResponse", });

        v = new Vector<String>(5);
        parameterNames.put("continueResponse", v);
        Collections.addAll(v, new String[]
        { "requestId", "responseCode", "responsePhrase", "responseHeaders", "binaryResponseHeaders", });

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

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


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

    // public static class RequestId => String
    
    /**
     * Stages of the request to handle. Request will intercept before the request is
     * sent. Response will intercept after the response is received (but before response
     * body is received).
     */
    public static final String[] RequestStage =
    { "Request", "Response", };
    
    /** <CODE>[No Description Provided by Google]</CODE> */
    public static class RequestPattern
        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, }; }
        
        /**
         * Wildcards (<CODE>'*'</CODE> -&gt; zero or more, <CODE>'?'</CODE> -&gt; exactly one) are allowed. Escape character is
         * backslash. Omitting is equivalent to <CODE>"*"</CODE>.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final String urlPattern;
        
        /**
         * If set, only requests for matching resource types will be intercepted.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final String resourceType;
        
        /**
         * Stage at which to begin intercepting requests. Default is Request.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final String requestStage;
        
        /**
         * Constructor
         *
         * @param urlPattern 
         * Wildcards (<CODE>'*'</CODE> -&gt; zero or more, <CODE>'?'</CODE> -&gt; exactly one) are allowed. Escape character is
         * backslash. Omitting is equivalent to <CODE>"*"</CODE>.
         * <BR /><B>OPTIONAL</B>
         * 
         * @param resourceType If set, only requests for matching resource types will be intercepted.
         * <BR /><B>OPTIONAL</B>
         * 
         * @param requestStage Stage at which to begin intercepting requests. Default is Request.
         * <BR /><B>OPTIONAL</B>
         */
        public RequestPattern(String urlPattern, String resourceType, String requestStage)
        {
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            BRDPC.checkIAE("resourceType", resourceType, "Network.ResourceType", Network.ResourceType);
            BRDPC.checkIAE("requestStage", requestStage, "Fetch.RequestStage", Fetch.RequestStage);
            
            this.urlPattern    = urlPattern;
            this.resourceType  = resourceType;
            this.requestStage  = requestStage;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'RequestPattern'}.
         */
        public RequestPattern (JsonObject jo)
        {
            this.urlPattern    = ReadJSON.getString(jo, "urlPattern", true, false);
            this.resourceType  = ReadJSON.getString(jo, "resourceType", true, false);
            this.requestStage  = ReadJSON.getString(jo, "requestStage", true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            RequestPattern o = (RequestPattern) other;
        
            return
                    Objects.equals(this.urlPattern, o.urlPattern)
                &&  Objects.equals(this.resourceType, o.resourceType)
                &&  Objects.equals(this.requestStage, o.requestStage);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.urlPattern)
                +   Objects.hashCode(this.resourceType)
                +   Objects.hashCode(this.requestStage);
        }
    }
    
    /** Response HTTP header entry */
    public static class HeaderEntry
        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, }; }
        
        /** <CODE>[No Description Provided by Google]</CODE> */
        public final String name;
        
        /** <CODE>[No Description Provided by Google]</CODE> */
        public final String value;
        
        /**
         * Constructor
         *
         * @param name -
         * 
         * @param value -
         */
        public HeaderEntry(String name, String 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)  BRDPC.throwNPE("name");
            if (value == null) BRDPC.throwNPE("value");
            
            this.name   = name;
            this.value  = value;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'HeaderEntry'}.
         */
        public HeaderEntry (JsonObject jo)
        {
            this.name   = ReadJSON.getString(jo, "name", false, true);
            this.value  = ReadJSON.getString(jo, "value", false, true);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            HeaderEntry o = (HeaderEntry) 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)
                +   Objects.hashCode(this.value);
        }
    }
    
    /** Authorization challenge for HTTP status code 401 or 407. */
    public static class AuthChallenge
        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, false, false, }; }
        
        /**
         * Source of the authentication challenge.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final String source;
        
        /** Origin of the challenger. */
        public final String origin;
        
        /** The authentication scheme used, such as basic or digest */
        public final String scheme;
        
        /** The realm of the challenge. May be empty. */
        public final String realm;
        
        /**
         * Constructor
         *
         * @param source Source of the authentication challenge.
         * <BR />Acceptable Values: ["Server", "Proxy"]
         * <BR /><B>OPTIONAL</B>
         * 
         * @param origin Origin of the challenger.
         * 
         * @param scheme The authentication scheme used, such as basic or digest
         * 
         * @param realm The realm of the challenge. May be empty.
         */
        public AuthChallenge(String source, String origin, String scheme, String realm)
        {
            // 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) BRDPC.throwNPE("origin");
            if (scheme == null) BRDPC.throwNPE("scheme");
            if (realm == null)  BRDPC.throwNPE("realm");
            
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            BRDPC.checkIAE(
                "source", source,
                "Server", "Proxy"
            );
            
            this.source  = source;
            this.origin  = origin;
            this.scheme  = scheme;
            this.realm   = realm;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'AuthChallenge'}.
         */
        public AuthChallenge (JsonObject jo)
        {
            this.source  = ReadJSON.getString(jo, "source", true, false);
            this.origin  = ReadJSON.getString(jo, "origin", false, true);
            this.scheme  = ReadJSON.getString(jo, "scheme", false, true);
            this.realm   = ReadJSON.getString(jo, "realm", false, true);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            AuthChallenge o = (AuthChallenge) other;
        
            return
                    Objects.equals(this.source, o.source)
                &&  Objects.equals(this.origin, o.origin)
                &&  Objects.equals(this.scheme, o.scheme)
                &&  Objects.equals(this.realm, o.realm);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.source)
                +   Objects.hashCode(this.origin)
                +   Objects.hashCode(this.scheme)
                +   Objects.hashCode(this.realm);
        }
    }
    
    /** Response to an AuthChallenge. */
    public static class AuthChallengeResponse
        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, }; }
        
        /**
         * The decision on what to do in response to the authorization challenge.  Default means
         * deferring to the default behavior of the net stack, which will likely either the Cancel
         * authentication or display a popup dialog box.
         */
        public final String response;
        
        /**
         * The username to provide, possibly empty. Should only be set if response is
         * ProvideCredentials.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final String username;
        
        /**
         * The password to provide, possibly empty. Should only be set if response is
         * ProvideCredentials.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final String password;
        
        /**
         * Constructor
         *
         * @param response 
         * The decision on what to do in response to the authorization challenge.  Default means
         * deferring to the default behavior of the net stack, which will likely either the Cancel
         * authentication or display a popup dialog box.
         * <BR />Acceptable Values: ["Default", "CancelAuth", "ProvideCredentials"]
         * 
         * @param username 
         * The username to provide, possibly empty. Should only be set if response is
         * ProvideCredentials.
         * <BR /><B>OPTIONAL</B>
         * 
         * @param password 
         * The password to provide, possibly empty. Should only be set if response is
         * ProvideCredentials.
         * <BR /><B>OPTIONAL</B>
         */
        public AuthChallengeResponse(String response, String username, String password)
        {
            // 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 (response == null) BRDPC.throwNPE("response");
            
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            BRDPC.checkIAE(
                "response", response,
                "Default", "CancelAuth", "ProvideCredentials"
            );
            
            this.response  = response;
            this.username  = username;
            this.password  = password;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'AuthChallengeResponse'}.
         */
        public AuthChallengeResponse (JsonObject jo)
        {
            this.response  = ReadJSON.getString(jo, "response", false, true);
            this.username  = ReadJSON.getString(jo, "username", true, false);
            this.password  = ReadJSON.getString(jo, "password", true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            AuthChallengeResponse o = (AuthChallengeResponse) other;
        
            return
                    Objects.equals(this.response, o.response)
                &&  Objects.equals(this.username, o.username)
                &&  Objects.equals(this.password, o.password);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.response)
                +   Objects.hashCode(this.username)
                +   Objects.hashCode(this.password);
        }
    }
    
    /**
     * Issued when the domain is enabled and the request URL matches the
     * specified filter. The request is paused until the client responds
     * with one of continueRequest, failRequest or fulfillRequest.
     * The stage of the request can be determined by presence of responseErrorReason
     * and responseStatusCode -- the request is at the response stage if either
     * of these fields is present and in the request stage otherwise.
     */
    public static class requestPaused
        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, true, true, true, }; }
        
        /** Each request the page makes will have a unique id. */
        public final String requestId;
        
        /** The details of the request. */
        public final Network.Request request;
        
        /** The id of the frame that initiated the request. */
        public final String frameId;
        
        /** How the requested resource will be used. */
        public final String resourceType;
        
        /**
         * Response error if intercepted at response stage.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final String responseErrorReason;
        
        /**
         * Response code if intercepted at response stage.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final Integer responseStatusCode;
        
        /**
         * Response status text if intercepted at response stage.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final String responseStatusText;
        
        /**
         * Response headers if intercepted at the response stage.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final Fetch.HeaderEntry[] responseHeaders;
        
        /**
         * If the intercepted request had a corresponding Network.requestWillBeSent event fired for it,
         * then this networkId will be the same as the requestId present in the requestWillBeSent event.
         * <BR />
         * <BR /><B>OPTIONAL</B>
         */
        public final String networkId;
        
        /**
         * Constructor
         *
         * @param requestId Each request the page makes will have a unique id.
         * 
         * @param request The details of the request.
         * 
         * @param frameId The id of the frame that initiated the request.
         * 
         * @param resourceType How the requested resource will be used.
         * 
         * @param responseErrorReason Response error if intercepted at response stage.
         * <BR /><B>OPTIONAL</B>
         * 
         * @param responseStatusCode Response code if intercepted at response stage.
         * <BR /><B>OPTIONAL</B>
         * 
         * @param responseStatusText Response status text if intercepted at response stage.
         * <BR /><B>OPTIONAL</B>
         * 
         * @param responseHeaders Response headers if intercepted at the response stage.
         * <BR /><B>OPTIONAL</B>
         * 
         * @param networkId 
         * If the intercepted request had a corresponding Network.requestWillBeSent event fired for it,
         * then this networkId will be the same as the requestId present in the requestWillBeSent event.
         * <BR /><B>OPTIONAL</B>
         */
        public requestPaused(
                String requestId, Network.Request request, String frameId, String resourceType, 
                String responseErrorReason, Integer responseStatusCode, String responseStatusText, 
                Fetch.HeaderEntry[] responseHeaders, String networkId
            )
        {
            super("Fetch", "requestPaused", 9);
            
            // 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 (requestId == null)    BRDPC.throwNPE("requestId");
            if (request == null)      BRDPC.throwNPE("request");
            if (frameId == null)      BRDPC.throwNPE("frameId");
            if (resourceType == null) BRDPC.throwNPE("resourceType");
            
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            BRDPC.checkIAE("resourceType", resourceType, "Network.ResourceType", Network.ResourceType);
            BRDPC.checkIAE("responseErrorReason", responseErrorReason, "Network.ErrorReason", Network.ErrorReason);
            
            this.requestId            = requestId;
            this.request              = request;
            this.frameId              = frameId;
            this.resourceType         = resourceType;
            this.responseErrorReason  = responseErrorReason;
            this.responseStatusCode   = responseStatusCode;
            this.responseStatusText   = responseStatusText;
            this.responseHeaders      = responseHeaders;
            this.networkId            = networkId;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'requestPaused'}.
         */
        public requestPaused (JsonObject jo)
        {
            super("Fetch", "requestPaused", 9);
        
            this.requestId            = ReadJSON.getString(jo, "requestId", false, true);
            this.request              = ReadJSON.getObject(jo, "request", Network.Request.class, false, true);
            this.frameId              = ReadJSON.getString(jo, "frameId", false, true);
            this.resourceType         = ReadJSON.getString(jo, "resourceType", false, true);
            this.responseErrorReason  = ReadJSON.getString(jo, "responseErrorReason", true, false);
            this.responseStatusCode   = ReadBoxedJSON.getInteger(jo, "responseStatusCode", true);
            this.responseStatusText   = ReadJSON.getString(jo, "responseStatusText", true, false);
            this.responseHeaders = (jo.getJsonArray("responseHeaders") == null)
                ? null
                : ReadArrJSON.DimN.objArr(jo.getJsonArray("responseHeaders"), null, 0, Fetch.HeaderEntry[].class);
        
            this.networkId            = ReadJSON.getString(jo, "networkId", true, false);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            requestPaused o = (requestPaused) other;
        
            return
                    Objects.equals(this.requestId, o.requestId)
                &&  Objects.equals(this.request, o.request)
                &&  Objects.equals(this.frameId, o.frameId)
                &&  Objects.equals(this.resourceType, o.resourceType)
                &&  Objects.equals(this.responseErrorReason, o.responseErrorReason)
                &&  Objects.equals(this.responseStatusCode, o.responseStatusCode)
                &&  Objects.equals(this.responseStatusText, o.responseStatusText)
                &&  Arrays.deepEquals(this.responseHeaders, o.responseHeaders)
                &&  Objects.equals(this.networkId, o.networkId);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.requestId)
                +   this.request.hashCode()
                +   Objects.hashCode(this.frameId)
                +   Objects.hashCode(this.resourceType)
                +   Objects.hashCode(this.responseErrorReason)
                +   Objects.hashCode(this.responseStatusCode)
                +   Objects.hashCode(this.responseStatusText)
                +   Arrays.deepHashCode(this.responseHeaders)
                +   Objects.hashCode(this.networkId);
        }
    }
    
    /**
     * Issued when the domain is enabled with handleAuthRequests set to true.
     * The request is paused until client responds with continueWithAuth.
     */
    public static class authRequired
        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, false, }; }
        
        /** Each request the page makes will have a unique id. */
        public final String requestId;
        
        /** The details of the request. */
        public final Network.Request request;
        
        /** The id of the frame that initiated the request. */
        public final String frameId;
        
        /** How the requested resource will be used. */
        public final String resourceType;
        
        /**
         * Details of the Authorization Challenge encountered.
         * If this is set, client should respond with continueRequest that
         * contains AuthChallengeResponse.
         */
        public final Fetch.AuthChallenge authChallenge;
        
        /**
         * Constructor
         *
         * @param requestId Each request the page makes will have a unique id.
         * 
         * @param request The details of the request.
         * 
         * @param frameId The id of the frame that initiated the request.
         * 
         * @param resourceType How the requested resource will be used.
         * 
         * @param authChallenge 
         * Details of the Authorization Challenge encountered.
         * If this is set, client should respond with continueRequest that
         * contains AuthChallengeResponse.
         */
        public authRequired(
                String requestId, Network.Request request, String frameId, String resourceType, 
                Fetch.AuthChallenge authChallenge
            )
        {
            super("Fetch", "authRequired", 5);
            
            // 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 (requestId == null)     BRDPC.throwNPE("requestId");
            if (request == null)       BRDPC.throwNPE("request");
            if (frameId == null)       BRDPC.throwNPE("frameId");
            if (resourceType == null)  BRDPC.throwNPE("resourceType");
            if (authChallenge == null) BRDPC.throwNPE("authChallenge");
            
            // Exception-Check(s) to ensure that if any parameters which must adhere to a
            // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
            
            BRDPC.checkIAE("resourceType", resourceType, "Network.ResourceType", Network.ResourceType);
            
            this.requestId      = requestId;
            this.request        = request;
            this.frameId        = frameId;
            this.resourceType   = resourceType;
            this.authChallenge  = authChallenge;
        }
        
        /**
         * JSON Object Constructor
         * @param jo A Json-Object having data about an instance of {@code 'authRequired'}.
         */
        public authRequired (JsonObject jo)
        {
            super("Fetch", "authRequired", 5);
        
            this.requestId      = ReadJSON.getString(jo, "requestId", false, true);
            this.request        = ReadJSON.getObject(jo, "request", Network.Request.class, false, true);
            this.frameId        = ReadJSON.getString(jo, "frameId", false, true);
            this.resourceType   = ReadJSON.getString(jo, "resourceType", false, true);
            this.authChallenge  = ReadJSON.getObject(jo, "authChallenge", Fetch.AuthChallenge.class, false, true);
        }
        
        
        /** Checks whether {@code 'this'} equals an input Java-{@code Object} */
        public boolean equals(Object other)
        {
            if (other == null)                       return false;
            if (other.getClass() != this.getClass()) return false;
        
            authRequired o = (authRequired) other;
        
            return
                    Objects.equals(this.requestId, o.requestId)
                &&  Objects.equals(this.request, o.request)
                &&  Objects.equals(this.frameId, o.frameId)
                &&  Objects.equals(this.resourceType, o.resourceType)
                &&  Objects.equals(this.authChallenge, o.authChallenge);
        }
        
        /** Generates a Hash-Code for {@code 'this'} instance */
        public int hashCode()
        {
            return
                    Objects.hashCode(this.requestId)
                +   this.request.hashCode()
                +   Objects.hashCode(this.frameId)
                +   Objects.hashCode(this.resourceType)
                +   this.authChallenge.hashCode();
        }
    }
    
    
    // Counter for keeping the WebSocket Request ID's distinct.
    private static int counter = 1;
    
    /**
     * Disables the fetch domain.
     * 
     * @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 = 42000000 + 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,
            "Fetch.disable"
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (BRDPC.defaultSender, webSocketID, requestJSON, BRDPC.NoReturnValues);
    }
    
    /**
     * Enables issuing of requestPaused events. A request will be paused until client
     * calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.
     * 
     * @param patterns 
     * If specified, only requests matching any of these patterns will produce
     * fetchRequested event and will be paused until clients response. If not set,
     * all requests will be affected.
     * <BR /><B>OPTIONAL</B>
     * 
     * @param handleAuthRequests 
     * If true, authRequired events will be issued and requests will be paused
     * expecting a call to continueWithAuth.
     * <BR /><B>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> enable
        (Fetch.RequestPattern[] patterns, Boolean handleAuthRequests)
    {
        final int       webSocketID = 42001000 + counter++;
        final boolean[] optionals   = { true, true, };
        
        // 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,
            "Fetch.enable",
            patterns, handleAuthRequests
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (BRDPC.defaultSender, webSocketID, requestJSON, BRDPC.NoReturnValues);
    }
    
    /**
     * Causes the request to fail with specified reason.
     * 
     * @param requestId An id the client received in requestPaused event.
     * 
     * @param errorReason Causes the request to fail with the given reason.
     * 
     * @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> failRequest
        (String requestId, String errorReason)
    {
        // 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 (requestId == null)   BRDPC.throwNPE("requestId");
        if (errorReason == null) BRDPC.throwNPE("errorReason");
        
        // Exception-Check(s) to ensure that if any parameters which must adhere to a
        // provided List of Enumerated Values, fails, then IllegalArgumentException shall throw.
        
        BRDPC.checkIAE("errorReason", errorReason, "Network.ErrorReason", Network.ErrorReason);
        
        final int       webSocketID = 42002000 + counter++;
        final boolean[] optionals   = { false, false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("failRequest"),
            parameterNames.get("failRequest"),
            optionals, webSocketID,
            "Fetch.failRequest",
            requestId, errorReason
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (BRDPC.defaultSender, webSocketID, requestJSON, BRDPC.NoReturnValues);
    }
    
    /**
     * Provides response to the request.
     * 
     * @param requestId An id the client received in requestPaused event.
     * 
     * @param responseCode An HTTP response code.
     * 
     * @param responseHeaders Response headers.
     * <BR /><B>OPTIONAL</B>
     * 
     * @param binaryResponseHeaders 
     * Alternative way of specifying response headers as a \0-separated
     * series of name: value pairs. Prefer the above method unless you
     * need to represent some non-UTF8 values that can't be transmitted
     * over the protocol as text. (Encoded as a base64 string when passed over JSON)
     * <BR /><B>OPTIONAL</B>
     * 
     * @param body 
     * A response body. If absent, original response body will be used if
     * the request is intercepted at the response stage and empty body
     * will be used if the request is intercepted at the request stage. (Encoded as a base64 string when passed over JSON)
     * <BR /><B>OPTIONAL</B>
     * 
     * @param responsePhrase 
     * A textual representation of responseCode.
     * If absent, a standard phrase matching responseCode is used.
     * <BR /><B>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> fulfillRequest(
            String requestId, int responseCode, Fetch.HeaderEntry[] responseHeaders, 
            String binaryResponseHeaders, String body, String responsePhrase
        )
    {
        // 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 (requestId == null) BRDPC.throwNPE("requestId");
        
        final int       webSocketID = 42003000 + counter++;
        final boolean[] optionals   = { false, false, true, true, true, true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("fulfillRequest"),
            parameterNames.get("fulfillRequest"),
            optionals, webSocketID,
            "Fetch.fulfillRequest",
            requestId, responseCode, responseHeaders, binaryResponseHeaders, body, responsePhrase
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (BRDPC.defaultSender, webSocketID, requestJSON, BRDPC.NoReturnValues);
    }
    
    /**
     * Continues the request, optionally modifying some of its parameters.
     * 
     * @param requestId An id the client received in requestPaused event.
     * 
     * @param url If set, the request url will be modified in a way that's not observable by page.
     * <BR /><B>OPTIONAL</B>
     * 
     * @param method If set, the request method is overridden.
     * <BR /><B>OPTIONAL</B>
     * 
     * @param postData If set, overrides the post data in the request. (Encoded as a base64 string when passed over JSON)
     * <BR /><B>OPTIONAL</B>
     * 
     * @param headers If set, overrides the request headers.
     * <BR /><B>OPTIONAL</B>
     * 
     * @param interceptResponse If set, overrides response interception behavior for this request.
     * <BR /><B>OPTIONAL</B>
     * <BR /><B>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> continueRequest(
            String requestId, String url, String method, String postData, 
            Fetch.HeaderEntry[] headers, Boolean interceptResponse
        )
    {
        // 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 (requestId == null) BRDPC.throwNPE("requestId");
        
        final int       webSocketID = 42004000 + counter++;
        final boolean[] optionals   = { false, true, true, true, true, true, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("continueRequest"),
            parameterNames.get("continueRequest"),
            optionals, webSocketID,
            "Fetch.continueRequest",
            requestId, url, method, postData, headers, interceptResponse
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (BRDPC.defaultSender, webSocketID, requestJSON, BRDPC.NoReturnValues);
    }
    
    /**
     * Continues a request supplying authChallengeResponse following authRequired event.
     * 
     * @param requestId An id the client received in authRequired event.
     * 
     * @param authChallengeResponse Response to  with an authChallenge.
     * 
     * @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> continueWithAuth
        (String requestId, Fetch.AuthChallengeResponse authChallengeResponse)
    {
        // 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 (requestId == null)             BRDPC.throwNPE("requestId");
        if (authChallengeResponse == null) BRDPC.throwNPE("authChallengeResponse");
        
        final int       webSocketID = 42005000 + counter++;
        final boolean[] optionals   = { false, false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("continueWithAuth"),
            parameterNames.get("continueWithAuth"),
            optionals, webSocketID,
            "Fetch.continueWithAuth",
            requestId, authChallengeResponse
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (BRDPC.defaultSender, webSocketID, requestJSON, BRDPC.NoReturnValues);
    }
    
    /**
     * Continues loading of the paused response, optionally modifying the
     * response headers. If either responseCode or headers are modified, all of them
     * must be present.
     * <BR /><B>EXPERIMENTAL</B>
     * 
     * @param requestId An id the client received in requestPaused event.
     * 
     * @param responseCode An HTTP response code. If absent, original response code will be used.
     * <BR /><B>OPTIONAL</B>
     * 
     * @param responsePhrase 
     * A textual representation of responseCode.
     * If absent, a standard phrase matching responseCode is used.
     * <BR /><B>OPTIONAL</B>
     * 
     * @param responseHeaders Response headers. If absent, original response headers will be used.
     * <BR /><B>OPTIONAL</B>
     * 
     * @param binaryResponseHeaders 
     * Alternative way of specifying response headers as a \0-separated
     * series of name: value pairs. Prefer the above method unless you
     * need to represent some non-UTF8 values that can't be transmitted
     * over the protocol as text. (Encoded as a base64 string when passed over JSON)
     * <BR /><B>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> continueResponse(
            String requestId, Integer responseCode, String responsePhrase, 
            Fetch.HeaderEntry[] responseHeaders, String binaryResponseHeaders
        )
    {
        // 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 (requestId == null) BRDPC.throwNPE("requestId");
        
        final int       webSocketID = 42006000 + 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("continueResponse"),
            parameterNames.get("continueResponse"),
            optionals, webSocketID,
            "Fetch.continueResponse",
            requestId, responseCode, responsePhrase, responseHeaders, binaryResponseHeaders
        );
        
        // This Remote Command does not have a Return-Value.
        return new Script<>
            (BRDPC.defaultSender, webSocketID, requestJSON, BRDPC.NoReturnValues);
    }
    
    /**
     * Causes the body of the response to be received from the server and
     * returned as a single string. May only be issued for a request that
     * is paused in the Response stage and is mutually exclusive with
     * takeResponseBodyForInterceptionAsStream. Calling other methods that
     * affect the request or disabling fetch domain before body is received
     * results in an undefined behavior.
     * 
     * @param requestId Identifier for the intercepted request to get body for.
     * 
     * @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>body</B>)</CODE>
     *     <BR />Response body.
     *     <BR /><BR /></LI>
     * <LI><CODE><B>Ret2.b:</B> Boolean (<B>base64Encoded</B>)</CODE>
     *     <BR />True, if content was sent as base64.
     *     </LI>
     * </UL>
     */
    public static Script<String, JsonObject, Ret2<String, Boolean>> getResponseBody
        (String requestId)
    {
        // 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 (requestId == null) BRDPC.throwNPE("requestId");
        
        final int       webSocketID = 42007000 + counter++;
        final boolean[] optionals   = { false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("getResponseBody"),
            parameterNames.get("getResponseBody"),
            optionals, webSocketID,
            "Fetch.getResponseBody",
            requestId
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON into Java-Type 'Ret2'
        Function<JsonObject, Ret2<String, Boolean>> 
            responseProcessor = (JsonObject jo) -> new Ret2<>(
                ReadJSON.getString(jo, "body", false, true),
                ReadBoxedJSON.getBoolean(jo, "base64Encoded", true)
            );
        
        // Pass the 'defaultSender' to Script-Constructor
        // The sender that is used can be changed before executing script.
        return new Script<>(BRDPC.defaultSender, webSocketID, requestJSON, responseProcessor);
    }
    
    /**
     * Returns a handle to the stream representing the response body.
     * The request must be paused in the HeadersReceived stage.
     * Note that after this command the request can't be continued
     * as is -- client either needs to cancel it or to provide the
     * response body.
     * The stream only supports sequential read, IO.read will fail if the position
     * is specified.
     * This method is mutually exclusive with getResponseBody.
     * Calling other methods that affect the request or disabling fetch
     * domain before body is received results in an undefined behavior.
     * 
     * @param requestId -
     * 
     * @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>stream</B></CODE>)
     *     <BR />-
     * </LI>
     * </UL> */
    public static Script<String, JsonObject, String> takeResponseBodyAsStream(String requestId)
    {
        // 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 (requestId == null) BRDPC.throwNPE("requestId");
        
        final int       webSocketID = 42008000 + counter++;
        final boolean[] optionals   = { false, };
        
        // Convert Method Parameters into JSON.  Build the JSON Request-Object (as a String)
        String requestJSON = WriteJSON.get(
            parameterTypes.get("takeResponseBodyAsStream"),
            parameterNames.get("takeResponseBodyAsStream"),
            optionals, webSocketID,
            "Fetch.takeResponseBodyAsStream",
            requestId
        );
        
        // 'JSON Binding' ... Converts Browser Response-JSON to 'String'
        Function<JsonObject, String> responseProcessor = (JsonObject jo) ->
            ReadJSON.getString(jo, "stream", false, true);
        
        // Pass the 'defaultSender' to Script-Constructor
        // The sender that is used can be changed before executing script.
        return new Script<>(BRDPC.defaultSender, webSocketID, requestJSON, responseProcessor);
    }
    
}