Interfaces.cs

// =============================================================================
// GPAL - Generally Positive Automation Library
// Copyright © 2026 Software Decisions, Inc. All rights reserved.
//
// This file is part of GPAL.
// Licensed under the Business Source License 1.1
//
// Primary development, architecture, and vision by Michael B. Vederman,
// CEO of Software Decisions, Inc., Texas.
//
// Internal development maintained privately.
// Public releases appear on GitHub: https://github.com/SoftwareDecisionsInc/GPAL.
//
// See LICENSE for full terms, including Additional Use Grant.
// =============================================================================
 
using DocumentFormat.OpenXml.Drawing;
using GenerallyPositive.Application;
using OpenQA.Selenium;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static GenerallyPositive.Browser.Browser;
using static GenerallyPositive.Enums;
using static GenerallyPositive.GPAL;

/*
var browser = 
    GPAL.Browser
    // optional from here
    .GlobalWaitOnDocumentReady(bool) // true - turn ON waiting for document.ready before returning from verb
    .WithBrowser(BrowserType enum) // default chrome
        .WithLoadImages(bool)   // default false
        .WithScrollIntoView(bool) // default false - follow each scraped element on screen
        .WithOpenPDFExternally(bool) // default true
        .WithDownloadFileTypes(string) // csv - defaults?
        .WithOpenFileTypes(string) // csv - defaults?
    // optional to here
    .GoTo(URL)
 
    // test document.ready()
    // do we ever deal with before/after/during events
    // on With, create Selector container for this UOW which ends in an action
    .WithSelector(searchSelector)
    .FillInFrom(string) /// WithHardware implies moving the mouse and clicks and enter text via keyboard emulation
 
    // test document.ready()
    // on With, create Selector container for this UOW which ends in an action
    .GlobalWaitOnDocumentReady(bool) // false - turn OFF waiting for document.ready before returning from verb
    .WithSelector(searchButtonSelector)
    .LeftClick() /// WithHardware implies moving the mouse and clicks
 
    // test document.ready()
    // on using, create Selector container for this UOW which ends in an action
    // TODO: how to say do not return sparesely populated arrays
    .WithSelector(colum1DataSelector)   // link .All at selector level
    .WithSelector(colum2DataSelector)   // description .All at selector level
    .WithSelector(colum3DataSelector)   // price .All at selector level
    .WithSelector(colum4DataSelector)   // image link .All at selector level
    .WithSelector(colum5DataSelector)   // repeat this one value in this column for all rows .Repeat at selector level
                                        // indicates above selectors are repeated and get all on the current page matching pattern
    .WithAll
    .WithNextPageButton(nextPageSelector)   // if not defined, only gets current page
    .WithPages(10)  // default is one page, but should be used in conjunction with above
    .GetGrid()  // change the return type to Tokens for manipulation/validation/saving
 
    // test document.ready()
    // tied to GPALGrid object
    .WithHeader(columnAString)
    .WithHeader(columnBString)
    .WithHeader(columnCString)
    .WithHeader(columnDString)
    .WithHeader(columnEString)
    .SaveToExcel(fileName)  // return type is GPAL.browser
 
    // the formal end of everything
    .Close()    // implies dispose, implement IDisposable on Browser
 
    // end of iterations
*/
namespace GenerallyPositive.Browser
{
    #region <BrowserInterfaces>
    public interface IBrowser :
        IAllowBrowserSettingsOrGoTo,
        IAllowWithAllThatMatch,
        IAllowWithNextPageButtonOrGetGrid,
        IAllowWithPagesAndGridActions,
        IAllowWithHeaderOrFileActions,
        IAllowBrowserActionOrAnySelector,
        IAllowCallTemplate,
        IAllowAfterAnySelector,
        IAllowAfterAnySelectorExceptWithAll,
        IAllowAfterWaitForAndSizeControl,
        IAllowAllBrowserAndAllSelector,
        IAllowBrowserSettingsOrSelectorAction,
        IAllowGetGridAndFillInFrom,
        IAllowWithPagesAndFetch,
        IAllowWithGridToSave,
        IAllowBrowserTypeOrGoto,
        IAllowWorkflowExecution,
        IAllowWorkflow,
        IAllowRun,
        IAllowWindowActions,
        IAllowSelectorInFrameBrowserSettingsOrGoto,
        //        IAllowOCRSettingsOrExecute,
        IAllowStorageAction,
        IAllowStorageOptions,
        IAllowStorageData,
        IAllowStorageOutData,
        IAllowToGPALObject<IBrowser>
    {
        // Public properties
        bool? FileDownloaded { get; set; }
        BrowserType BrowserType { get; }
        IWebDriver BrowserDriver { get; }
        string RestApiBaseUrl { get; }
        int CurrentTabIdx { get; }
        string CurrentUrl { get; }
        string BrowserVersion { get; }
        object JavaScriptResultObj { get; }
        string JavaScriptResultStr { get; }
        PuppeteerCommunicator PuppeteerCommunicator { get; }
        IPuppeteerClient PuppeteerClient { get; }
        int ServerResponseCode { get; set; } // CAVEAT: public set: unsure why visual studio will not let me use internal set in Broser without set here, like everywhere else
        bool UseOttoMagic { get; }
        bool UsePuppeteer { get; }
        bool UseSelenium { get; }
        AutomationEngine AutomationEngine { get; }
        IRESTClient OttoMagicClient { get; }
        [Settings(Description = "The hidden desktop this browser is running on, or null when it is on the visible one.")]
        IHiddenDesktop HiddenDesktop { get; }
        bool IsEndOfPage();
        bool IsAlive { get; }
        // Public methods not covered by existing interfaces
        [Action(Description = "Remove the CallIf handler everywhere it has been set. Use this once you are done using the handler.")]
        void RemoveCallIfHandlerEverywhere(CallIfDelegate func);
        MagicHelper MagicHelper { get; }
    }

    public interface IHiddenDesktop
    {
        [Settings(Description = "What this desktop is called. Browsers naming the same one share it.")]
        string Name { get; }
        [Settings(Description = "How many visible top level windows are on it right now.")]
        int WindowCount { get; }
        [Browser(Description = "Put this desktop on the screen for the default time, then put yours back.")]
        string Peek();
        [Browser(Description = "Put this desktop on the screen for this many milliseconds, then put yours back.")]
        string Peek(int forMs);
        [Browser(Description = "Give up GPAL's handle on this desktop. Closes nothing running there.")]
        void Close();
    }

    public interface IHiddenDesktops
    {
        [Settings(Description = "Every desktop made so far, in the order they were made.")]
        IReadOnlyList<string> Names { get; }
        [Settings(Description = "One desktop by name, so a workflow that did not keep the browser can still reach it.")]
        IHiddenDesktop this[string desktopName] { get; }
        [Settings(Description = "Visible top level windows across every hidden desktop added up.")]
        int WindowCount { get; }
        [Settings(Description = "True while the screen is on a hidden desktop and has not been handed back.")]
        bool IsShowing { get; }
        [Browser(Description = "Walk every hidden desktop that has windows, the default time each.")]
        string Peek();
        [Browser(Description = "Walk every hidden desktop that has windows, this many milliseconds each.")]
        string Peek(int forMsEach);
        [Browser(Description = "Put one named desktop on the screen for the default time.")]
        string Peek(string desktopName);
        [Browser(Description = "Put the screen back on the desktop a peek took it from. Safe from any thread.")]
        bool Return();
        [Browser(Description = "Give up GPAL's handles on every hidden desktop. Closes nothing running on them.")]
        void CloseAll();
    }
 
    #region <BaseBrowserInterfaces>
    public interface IAllowGoToOrGet : IAllowGoTo, IAllowGet, IAllowToGPALObject<IBrowser>
    { }
    public interface IAllowBrowserTypeOrGoto : IAllowBrowserType, IAllowGoToOrGet, IAllowExistingBrowser, IAllowWithAutomationEngine // if we just want to use default browser
    { }
    public interface IAllowBrowserType { [Settings(Description = "Set which browser type to run: Chrome (default), Edge or Firefox.")]  IAllowBrowserSettingsOrGoTo WithBrowserType([BrowserType()] BrowserType browserType); }
 
    public interface IAllowWithAutomationEngine
    {
        [Settings(Description = "Set which engine to use to automate the browser: OttoMagic, Puppeteer (default) or Selenium.")]
        IAllowBrowserSettingsOrGoTo WithAutomationEngine(AutomationEngine automationEngine);
 
    }
    public interface IAllowDebugPort
    {
        [Settings(Description = "Set debug port to use [57005 (0xdead) default]. Specify to reconnect to a browser session using .WithExistingPort.  If both port and pipe are set, port is preferred.")]
        IAllowBrowserSettingsOrGoTo WithUseDebugPort(int debugPort = 0xdead);
        [Settings(Description = "Use debug pipe for puppeteer commmunications. If both port and pipe are set, port is preferred.")]
        IAllowBrowserSettingsOrGoTo WithUseDebugPipe(bool trueFalse = false);
        [Settings(Description = "Drive a browser whose GPALRestAPI is already running, here or on another machine, instead of launching one")]
        IAllowBrowserSettingsOrGoTo WithRestApiUrl(string restApiUrl);
    }
    public interface IAllowExistingBrowser
    {
        [Settings(Description = "")]
        IAllowBrowserActionOrAnySelector WithExistingBrowser(int debugPort = 6565);
    }
    public interface IAllowBrowserSettings : IAllowWithAutomationEngine, IAllowSizeControl, IAllowExistingBrowser, IAllowPersistentCallBack, IAllowWithPersistentSelector, IAllowNewTabOrWindow, IAllowNetworkIdleSettings, IAllowDebugPort
    {
        [Settings(Description = "Load images in the page, this can affect layout and object coordinates, if that matters.")]
        IAllowBrowserSettingsOrGoTo WithLoadImages(bool trueFalse = false);
        [Settings(Description = "Scroll each scraped element into view as it is read, so the page follows the workflow. For watching a run, not for correctness. Ignored in headless. [false default]")]
        IAllowBrowserSettingsOrGoTo WithScrollIntoView(bool trueFalse = true);
        [Settings(Description = "Open PDF files externally, not in the browser. So, download the pdf.")]
        IAllowBrowserSettingsOrGoTo WithOpenPDFExternally(bool trueFalse = false);
        [Settings(Description = "Prompt when downloading a file? [true default/false for headless]")]
        IAllowBrowserSettingsOrGoTo WithPromptForDownload(bool trueFalse = true);
        [Settings(Description = "Location of the browser driver and where automatically updating the driver will occur. Default is executable directory.")]
        IAllowBrowserSettingsOrGoTo WithDriverLocation([Directory(Description = "Location of browser driver for this instance. [./ (default)(same dir as exe)]")] string driverPath);
        [Settings(Description = "Control whether popups are blocked")]
        IAllowBrowserSettingsOrGoTo WithBlockPopUps(bool trueFalse = true);
        [Settings(Description = "Use javascript injection to interact with an element")]
        IAllowBrowserSettingsOrGoTo WithUseStealth(StealthType steathType);
        [Settings(Description = "Always overwrite a file if it exists")]
        IAllowBrowserSettingsOrGoTo WithOverwriteExistingFile(bool trueFalse = true);
        [Settings(Description = "Wait for browser page to finish loading")]
        IAllowBrowserSettingsOrGoTo WithWaitOnDocumentReady(int timeoutInMs);
        [Settings(Description = "How long a click waits to see whether it started a navigation. [250 (default)] 0 skips the check")]
        IAllowBrowserSettingsOrGoTo WithNavigationGrace(int graceInMs);
        [Settings(Description = "Run the browser on a Win32 desktop object of its own, headful but invisible, so the workflow does not take the screen. Hardware engines cannot reach a desktop nobody is on and step down to the protocol engine of their own family.")]
        IAllowBrowserSettingsOrGoTo WithHiddenDesktop(bool trueFalse = true);
        [Settings(Description = "Run the browser on the named Win32 desktop object. Browsers naming the same desktop share it, browsers naming different ones get one each.")]
        IAllowBrowserSettingsOrGoTo WithHiddenDesktop(string desktopName);
        [Settings(Description = "To change browser profiles, use this option to specify the data-dir path. If Directory and UserName are both defined, Directory will be used.")]
        IAllowBrowserSettingsOrGoTo WithProfileDataDirectory(string profilePath);
        [Settings(Description = "To change browser profiles, use this option to specify the username whose browser data-dir to use. If Directory and UserName are both defined, Directory will be used.")]
        IAllowBrowserSettingsOrGoTo WithProfileUserName(string profileUserName);
        [Settings(Description = "The name of the browser profile to use under the data-dir (sometime, might be same result as UserName)")]
        IAllowBrowserSettingsOrGoTo WithProfileName(string profileName);
        [Settings(Description = "Set the browser default download directory. Can be overriden with a fully qualified filename. [path/file/]")]
        IAllowBrowserSettingsOrGoTo WithDownloadLocation(string downloadPat);
        [Settings(Description = "Use websockets to download for Right Click and Download")]
        IAllowBrowserSettingsOrGoTo WithUseDirectDownload(bool trueFalse = false);
        [Settings(Description = "Set the time in seconds to wait for a download to finish before giving up.")]
        IAllowBrowserSettingsOrGoTo WithDownloadTimeoutInSec(int seconds = 60);
        [Settings(Description = "Set the HTTP referrer to use when navigating every subsequent Get/Goto. Use empty string to clear.")]
        IAllowBrowserSettingsOrGoTo WithUseReferrer(string referrer = "");
        IAllowBrowserSettingsOrGoTo WithUseUserAgent(string userAgent = "");
        [Settings(Description = "Launch a browser purely to read its real user agent. Off by default, in which case the user agent comes from WithUseUserAgent, then gpal.yaml, then the per-browser template with the installed version filled in")]
        IAllowBrowserSettingsOrGoTo WithUserAgentFromBrowser(bool userAgentFromBrowser = true);
        [Settings(Description = "Set whether or not to obey robots.txt (false - default).")]
        IAllowBrowserSettingsOrGoTo WithObeyRobotsTxt(bool trueFalse = false);
        [Settings(Description = "Set whether or not to respect robot meta tags noindex/nofollow/none (false - default).")]
        IAllowBrowserSettingsOrGoTo WithRespectRobotMetaTags(bool trueFalse = false);
    }
    public interface IAllowNewTabOrWindow
    {
        [Action(Description = "Open url in a new tab")]
        IAllowBrowserActionOrAnySelector NewTab(GPALUrl url = null);
        [Action(Description = "Open url in a new window")]
        IAllowBrowserActionOrAnySelector OpenWindow(GPALUrl url = null);
    }
    public interface IAllowPersistentCallBack
    {
        // return values
        // 0 = not handled
        // 1 = handled
        // -1 = error
        [Callback(Description = "GLOBAL based callback if any selector in any UOW is found")]
        IAllowBrowserSettingsOrGoTo PersistentCallIfFound(Browser.CallIfDelegate CallIfFound);
        [Callback(Description = "GLOBAL based callback if any selector in any UOW is NOT found")]
        IAllowBrowserSettingsOrGoTo PersistentCallIfNotFound(Browser.CallIfDelegate CallIfNotFound);
        [Callback(Description = "Callback when something fails that the workflow can decide about, a navigation that never loaded a page being the case today. Falls through to GPAL.CallOnFail when this browser has none")]
        IAllowBrowserSettingsOrGoTo CallOnFail(Browser.CallOnFailDelegate CallOnFail);
        [Settings(Description = "Who this browser is, for a site that asks. The credential's WebAuthType decides how it is presented, and it is presented once at the first navigation")]
        IAllowBrowserSettingsOrGoTo WithCredentials(ICredentials credentials);
    }
    public interface IAllowCallBack
    {
        // return values
        // 0 = not handled
        // 1 = handled
        // -1 = error
        [Callback(Description = "UOW based callback if any selector in the UOW is found")]
        IAllowAfterAnySelector CallIfFound(Browser.CallIfDelegate CallIfFound);
        [Callback(Description = "UOW based callback if any selector in the UOW is NOT found")]
        IAllowAfterAnySelector CallIfNotFound(Browser.CallIfDelegate CallIfNotFound);
        [Callback(Description = "UOW based callback when a row of input is consumed and entered.\nUseful for chaining to another workflow")]
        IAllowAfterAnySelector CallAfterFillIn(Browser.CallAfterFillInDelegate CallAfterFillIn);
    }
    public interface IAllowSizeControl : IAllowToGPALObject<IBrowser>
    {
        IAllowAllBrowserAndAllSelector Maximize { [Browser(Description = "Maximize the browser window")] get; }
        IAllowAllBrowserAndAllSelector Minimize { [Browser(Description = "Minimize the browser window")] get; }
        //        IAllowAllBrowserAndAllSelector Normal { [Browser(Description = "Restore the browser window after fullscreen.")] get; }
        IAllowAllBrowserAndAllSelector Restore { [Browser(Description = "Restore the browser window from maximize or full-screen.")] get; }
        IAllowAllBrowserAndAllSelector FullScreen { [Browser(Description = "Put the browser in full-screen mode.")] get; }
        [Browser(Description = "Set the desired browser window size.")]
        IAllowAllBrowserAndAllSelector WithWindowSize(System.Drawing.Rectangle windowSize);
    }
    public interface IAllowHideElement
    {
        [Action(Description = "Hide the found element")]
        IAllowBrowserActionOrAnySelector Hide(Selector selector = null);
    }
    public interface IAllowSetAttributeValue
    {
        [Action(Description = "Directly set a DOM attribute (named by the preceding WithAttribute call) to the given value on the found element(s). Does not simulate typing and does not honor GPAL.TypingDelay.")]
        IAllowBrowserActionOrAnySelector SetAttribute(string value);
    }
    public interface IAllowSetValueFromElement
    {
        [Action(Description = "Set the value of the element(s) matched by the preceding WithSelector call from the value of the element matched by the given selector.")]
        IAllowBrowserActionOrAnySelector SetValueFrom(Selector selector);
    }
    public interface IAllowWithAttribute
    {
        [Data(Description = "Names the attribute to set; must be followed by .SetAttribute(value) to specify the value and complete the action.")]
        IAllowSetAttributeValue WithAttribute(string attribute);
    }
    public interface IAllowClicks
    {
        [Action(Description = "Left click the found element.")]
        IAllowBrowserActionOrAnySelector LeftClick();
        [Action(Description = "Left click the found element.")]
        IAllowBrowserActionOrAnySelector LeftClick(Selector selector);
        [Action(Description = "M iddle click the found element.")]
        IAllowBrowserActionOrAnySelector MiddleClick();
        [Action(Description = "Left click the found select menu element.")]
        IAllowBrowserActionOrAnySelector SelectClick(SelectClickType selectClickType);
        [Action(Description = "Stealth (Runtime.disable before) Left click the found element.")]
        IAllowBrowserActionOrAnySelector StealthLeftClick(Selector selector);
        [Action(Description = "Left click the found element, pressing modifier key (none [default]) while clicking.")]
        IAllowBrowserActionOrAnySelector LeftClick(ModifierKeys modifierKeys);
        [Action(Description = "Left click the found element, handling a download dialog after clicking.")]
        IAllowBrowserActionOrAnySelector LeftClickAndDownload(GPALFile filenames);
        [Action(Description = "Left click the found element, handling an upload dialog after clicking.")]
        IAllowBrowserActionOrAnySelector LeftClickAndUpload(GPALFile filenames);
        [Action(Description = "Left double click the found element, pressing modifier key (none [default]) while clicking.")]
        IAllowBrowserActionOrAnySelector LeftDoubleClick();
        [Action(Description = "Right click the found element, pressing modifier key (none [default]) while clicking.")]
        IAllowBrowserActionOrAnySelector RightClick(Selector selector = null);
 
        // returns the file name(s) saved to by adding to the ReturnedFilenames list
        // if not overwriting files, then a timestamp is appended to the filename and returned
        // if overwriting, the same filename is added to the list
        // since we can iterate over multiple elements, this could right click and download multiple links, so filenames contains ALL expected filenames to save to
        [Action(Description = "Save the element (if WithSelector is specified) or page to the GPALFile.")]
        IAllowBrowserActionOrAnySelector RightClickAndDownload(GPALFile filenames);
    }
    public interface IAllowWaitForWindow
    {
        [Wait(Description = "After an action is called (ie, LeftClick), wait for a window to open with this name (title)")]
        IAllowAfterWaitForAndSizeControl WaitForWindow(string windowName);
        [Wait(Description = "After an action is called (ie, LeftClick), wait for a window to open which name (title) matches the regular expression")]
        IAllowAfterWaitForAndSizeControl WaitForWindowRegex(string windowNameRegex);
        [Wait(Description = "The time in seconds to wait for a window to appear before giving up")]
        IAllowAfterWaitForAndSizeControl WithWaitForWindowTimeout(int waitTimeInSeconds);
 
    }
    public interface IAllowFillInFrom
    {
        [Data(Description = "Send the specified string using the selector interaction type (selenium/javascript/hardware)")]
        IAllowBrowserActionOrAnySelector SendString(string textToSend);
        [Data(Description = "Send a control character specified by the VKCode (GPAL has some defined)")]
        IAllowBrowserActionOrAnySelector SendKey(byte VKCode);
        [Data(Description = "Press the modifier key specified (Control/Shift/Alt). NOTE: Be careful with Shift and sending mixed case strings after pressing Shift. Mixed case strings will release the Shift key.")]
        IAllowBrowserActionOrAnySelector PressModifierKey(ModifierKeys modifierKeys);
        [Data(Description = "Release the modifier key specified (Control/Shift/Alt) as previously pressed.")]
        IAllowBrowserActionOrAnySelector ReleaseModifierKey(ModifierKeys modifierKeys);
 
        [Data(Description = "Fill in [overwrite] text from a string")]
        IAllowBrowserActionOrAnySelector FillInFrom(string textToUse);
        [Data(Description = "Append to the end text from a string")]
        IAllowBrowserActionOrAnySelector AppendFrom(string textToUse);
        [Data(Description = "Insert text (wherever the cursor is) from a string")]
        IAllowBrowserActionOrAnySelector InsertFrom(string textToUse);
 
        [Data(Description = "Fill in [overwrite] text from a file. CSV values per line takenized for each input selector")]
        IAllowBrowserActionOrAnySelector FillInFrom(GPALFile inputFile);
        [Data(Description = "Append to the end text from a file. CSV values per line takenized for each input selector")]
        IAllowBrowserActionOrAnySelector AppendFrom(GPALFile inputFile);
        [Data(Description = "Insert text (wherever the cursor is) from a file. CSV values per line takenized for each input selector")]
        IAllowBrowserActionOrAnySelector InsertFrom(GPALFile inputFile);
 
        [Data(Description = "Fill in [overwrite] text from a database query. Tokenized by each column per input per row")]
        IAllowBrowserActionOrAnySelector FillInFrom(GPALDatabase inpuDatabase);
        [Data(Description = "Append to the end text from a database query. Tokenized by each column per input per row")]
        IAllowBrowserActionOrAnySelector AppendFrom(GPALDatabase inpuDatabase);
        [Data(Description = "Insert text (wherever the cursor is) from a database query. Tokenized by each column per input per row")]
        IAllowBrowserActionOrAnySelector InsertFrom(GPALDatabase inpuDatabase);
        [Data(Description = "Fill in [overwrite] text from a data grid. Tokenized List<List<string>> each string per input per list entry")]
        IAllowBrowserActionOrAnySelector FillInFrom(IGPALGrid<string> inputGrid);
        [Data(Description = "Append to the end  text from a data grid. Tokenized List<List<string>> each string per input per list entry")]
        IAllowBrowserActionOrAnySelector AppendFrom(IGPALGrid<string> inputGrid);
        [Data(Description = "Insert text (wherever the cursor is) from a data grid. Tokenized List<List<string>> each string per input per list entry")]
        IAllowBrowserActionOrAnySelector InsertFrom(IGPALGrid<string> inputGrid);
        [Data(Description = "Set the value of an input range element")]
        IAllowBrowserActionOrAnySelector SetRange(int rangeValue);
    };
    public interface IAllowTabActions
    {
        [Browser(Description = "Close the current tab [no URL], or the tab with URL")]
        IAllowBrowserActionOrAnySelector CloseTab(dynamic URLorTabId = null);
        IAllowBrowserActionOrAnySelector NextTab { [Browser(Description = "Move to the next tab (to the right)")] get; }
        IAllowBrowserActionOrAnySelector PreviousTab { [Browser(Description = "Move to the previous tab (to the left)")] get; }
        [Browser(Description = "Go to tab with URL")]
        IAllowBrowserActionOrAnySelector GoToTab(dynamic URLorTabTuple = null);
    }
    public interface IAllowInSelector
    {
        [Selector(Description = "Subsequent withselector searches are for elements nested under this element. Nesting is possible.")]
        IAllowAfterAnySelector InElement(Selector selector);
        [Selector(Description = "Subsequent withselector searches are for elements nested under this iframe. Nesting is possible.")]
        IAllowAfterAnySelector InFrame(Selector selector);

        [Selector(Description = "Subsequent selector are for elements in a shadowdom specified by the shadowdom selector. Nesting is possible.")]
        IAllowAfterAnySelector InShadowDom(Selector shadowDomSelector);
        [Selector(Description = "Reset back to the top level dom document for finding elements")]
        IAllowAfterAnySelector InMainDom();
    }
    public interface IAllowScrolling
    {
        [Action(Description = "Use javsacript injection to scroll the specified web element n pixels horizontally")]
        IAllowBrowserActionOrAnySelector ScrollElementHorizontalByPixels(int scrollAmountInPixels);
        [Action(Description = "Use javascript injection to scroll the specified web element n pixels vertically")]
        IAllowBrowserActionOrAnySelector ScrollElementVerticalByPixels(int scrollAmountInPixels);
    }
    public interface IAllowWindowScrollBy
    {
        [Browser(Description = "Scroll the browser window horizontally by scrollAmount pixels")]
        IAllowBrowserActionOrAnySelector ScrollWindowByHorizontal(int scrollAmount);
        [Browser(Description = "Scroll the browser window veritcally by scrollAmount pixels")]
        IAllowBrowserActionOrAnySelector ScrollWindowByVertical(int scrollAmount);
    }
    public interface IAllowWindowActions
    {
        [Browser(Description = "Close the current window [no URL], or the window with URL")]
        IAllowBrowserActionOrAnySelector CloseWindow(dynamic URLorId = null);
        IAllowBrowserActionOrAnySelector NextWindow { [Browser(Description = "Move to the next window (to the right)")] get; }
        IAllowBrowserActionOrAnySelector PreviousWindow { [Browser(Description = "Move to the previous window (to the left)")] get; }
        [Browser(Description = "Go to window with URL")]
        IAllowBrowserActionOrAnySelector GoToWindow(dynamic URLorId = null);
    }
    public interface IAllowPageControl
    {
        IAllowBrowserActionOrAnySelector Back { [Browser(Description = "Move back one entry in the browser history")] get; }
        IAllowBrowserActionOrAnySelector Forward { [Browser(Description = "Move forward one entry in the browser history")] get; }
        IAllowBrowserActionOrAnySelector PageDown { [Browser(Description = "Scroll one page down")] get; }
        IAllowBrowserActionOrAnySelector PageEnd { [Browser(Description = "Scroll to page bottom")] get; }
        IAllowBrowserActionOrAnySelector PageTop { [Browser(Description = "Scroll to page top")] get; }
        IAllowBrowserActionOrAnySelector PageUp { [Browser(Description = "Scroll one page up")] get; }
        IAllowBrowserActionOrAnySelector Refresh { [Browser(Description = "Refresh the current page")] get; }
    }
    public interface IAllowExecuteJavaScript
    {
        [Browser(Description = "Execute the supplied javascript in the browser and return an integer in browser.JavaScriptResultObj")]
        IAllowBrowserActionOrAnySelector ExecuteJavaScriptObj(string javascript);
        [Browser(Description = "Execute the supplied javascript in the browser and return an integer in browser.JavaScriptResultStr")]
        IAllowBrowserActionOrAnySelector ExecuteJavaScriptStr(string javascript);
    }
    public interface IAllowDialogHandling
    {
        [Browser(Description = "Answer the alert, confirm and prompt dialogs the page raises, instead of letting them open and block. True accepts (OK, and confirm returns true), false dismisses (Cancel, and confirm returns false). Set it before the browser launches.")]
        IAllowBrowserActionOrAnySelector WithDialogsAccepted(bool accept);
        [Browser(Description = "What a prompt hands back when dialogs are accepted. Not available on Selenium, where the driver answers the dialog itself.")]
        IAllowBrowserActionOrAnySelector WithDialogText(string text);
        [Browser(Description = "Stop answering dialogs, so they open and block again. Different from WithDialogsAccepted(false), which answers Cancel.")]
        IAllowBrowserActionOrAnySelector ClearDialogHandling();
    }
    public interface IAllowGetWindowRectangle
    {
        [Browser(Description = "Where this browser's window is and how big it is, in screen coordinates, chrome included. Answered by whichever engine is driving, so a workflow does not have to know which one that is.")]
        IAllowBrowserActionOrAnySelector GetWindowRectangle(out System.Drawing.Rectangle window);
    }
    public interface IAllowInjectScript
    {
        [Browser(Description = "Inject a script (raw JS string, or GPALFile - if multiple files are specified, all are loaded and injected as separate scripts) to run on every new document load. Callable before the first .GoTo()/.Get() (active from the first page load) or at any later point (applies to subsequent navigations). Persists until .ClearInjectedScripts() is called.")]
        IAllowBrowserActionOrAnySelector InjectScript(string script);
        [Browser(Description = "Inject script(s) loaded from a GPALFile - if multiple filenames are specified (e.g. via wildcard), all are loaded and injected as separate scripts.")]
        IAllowBrowserActionOrAnySelector InjectScript(GPALFile scriptFile);
        [Browser(Description = "Remove all scripts previously registered via InjectScript.")]
        IAllowBrowserActionOrAnySelector ClearInjectedScripts();
    }
    public interface IAllowNetworkIdleSettings
    {
        [Settings(Description = "Wait for browser network activity to idles. Defauilt is 0 connections.")]
        IAllowBrowserSettingsOrGoTo WithWaitOnIdleConnection(bool trueFalse = true);
        [Settings(Description = "Timeout to wait for network idle = true. Defauilt is 500 ms.")]
        IAllowNetworkIdleSettings WithNetworkIdleTimeoutMs(int networkIdleTimeoutMs = 500);
        [Settings(Description = "Timeout to wait for network idle = true. Defauilt is 500 ms.")]
        IAllowNetworkIdleSettings WithNetworkIdleMaxConnections(int maxConnections = 0);
        [Settings(Description = "Duration to maintain network stats before pruning old data. Default is 10 seconds (10_000 ms).")]
        IAllowNetworkIdleSettings WithNetworkIdlePruneMs(int networkIdlePruneMs = 10_000);
 
    }
    #endregion <BaseInterfaces>
 
    #region <Atoms>
    public interface IAllowToGPALObject<TResult>
    {
        [Fluent(Description = "Ends a declaration or workflow, returning a GPAL object which can be assigned. Use instead of an explicit cast. [ Selector mySel = GPAL.Selector.WithCSS(css).ToGPALObject() ]")]
        TResult ToGPALObject();
    }
    public interface IAllowWithPersistentSelector { [Settings()] IAllowSelectorInFrameBrowserSettingsOrGoto WithPersistentSelector(Selector persistentSelector); }
    public interface IAllowSelectorInFrameBrowserSettingsOrGoto : IAllowBrowserSettingsOrGoTo { [Settings()] IAllowBrowserSettingsOrGoTo InPersistentIframe(Selector iFrame); }
    public interface IAllowWithSelector : IAllowWithData { [Selector(Description = "Add a selector to this UOW")] IAllowAfterAnySelector WithSelector(Selector selector); }
    public interface IAllowWithData
    {
        [Selector(Description = "Add literal data to a grid when using .GetGrid")] IAllowAfterAnySelector WithSelector(string literalData);
        [Selector(Description = "Add literal data to a grid by invoking this function when using .GetGrid")] IAllowAfterAnySelector WithSelector(Func<string> dataFunction);
    }
    public interface IAllowSiteMapOperations
    {
        [Action("Get the current page source")]
        IAllowBrowserActionOrAnySelector GetPageSource(out string sitemapXML);
        [Action("Carry on without the browser: hand back a RESTClient holding this browser's origin, cookies, user agent, accept language and credential")]
        IAllowBrowserActionOrAnySelector ContinueAsRESTClient(out IRESTClient client);
        [Action("Get the raw sitemap XML")]
        IAllowBrowserActionOrAnySelector GetSiteMap(out string sitemapXML);
        [Action("Get the sitemap URLs as a List<string>")]
        IAllowBrowserActionOrAnySelector GetSiteMapUrls(out List<string> sitemapXML);
        [Action("Save the sitemap URLs to a file, format chosen by the file extension")]
        IAllowBrowserActionOrAnySelector SaveSiteMapUrls(GPALFile sitemapUrlsFile);
        [Action("Clear cached sitemap / LLM digest / hydration results, forcing the next Get/Save to refetch")]
        IAllowBrowserActionOrAnySelector ClearResultCache();
        [Action("Get the current page source as an LLM digest")]
        IAllowBrowserActionOrAnySelector GetLLMDigest(out LLMDigestResult digestResult, string ruleSetName = null);
        [Action("Save to file, the current page source as an LLM digest")]
        IAllowBrowserActionOrAnySelector SaveLLMDigest(GPALFile llmDigestFile, string ruleSetName = null);
        [Action("Get the current page next.js hydrated data")]
        IAllowBrowserActionOrAnySelector GetHydratedData(out NextJsHydrationResult hydrationResult);
        [Action("Save to file, the current page next.js hydrated data")]
        IAllowBrowserActionOrAnySelector SaveHydratedData(GPALFile hydrationFile);
    }
    public interface IAllowStorageAction
    {
        [Action("Run the get storage actions for storageType")]
        IAllowStorageOutData RunGet(WebsiteStorageType storageType);
        [Action("Run the set storage actions for storageType")]
        IAllowBrowserActionOrAnySelector RunSet(WebsiteStorageType storageType);
        [Action("Run the delete storage actions for storageType")]
        IAllowBrowserActionOrAnySelector RunDelete(WebsiteStorageType storageType);
    }
    public interface IAllowStorageOptions : IAllowStorageAction, IAllowStorageData
    {
        [Browser(Description = "The domain for the storage action")]
        IAllowStorageOptions WithStorageDomain(string domain);
        [Browser(Description = "The path for the storage action")]
        IAllowStorageOptions WithStoragePath(string path);
        [Browser(Description = "The key for the storage action")]
        IAllowStorageOptions WithStorageKey(string key);
        [Browser(Description = "The store name for the indexedDb action")]
        IAllowStorageOptions WithStorageStoreName(string storeName);
        [Browser(Description = "The user defined filter to help select wildcard storage actions")]
        IAllowStorageOptions WithUserDefinedFilter(string userDefined);
 
    }
    public interface IAllowStorageData { [Browser(Description = "The data for storage set operations")] IAllowStorageOptions WithStorageData(string data); }
    public interface IAllowStorageOutData { [Browser(Description = "The data for storage get operations")] IAllowBrowserActionOrAnySelector GetStorageData(out string data); }
    public interface IAllowGoTo { [Browser(Description = "Go to the specified URL")] IAllowBrowserActionOrAnySelector GoTo([URL()] GPALUrl URL); }
    public interface IAllowGet { [Browser(Description = "Navigate to the URL headless, launching a headless browser when none is open. Same navigation as GoTo, with the headless download options set first")] IAllowBrowserActionOrAnySelector Get([URL()] GPALUrl URL); }
    public interface IAllowClose { [Browser(Description = "Close the current browser session. True [default] to kill web drivers running.")] void Close(bool killWebDrivers = false); }
    public interface IAllowFocus { [Action(Description = "Bring the current element (specified by .WithSelector) into focus.")] IAllowBrowserActionOrAnySelector Focus(Selector selector = null); }
    public interface IAllowHover { [Action(Description = "Hover the mouse over the current element (specified by .WithSelector). [hardware emulation (see .WithSimulateMouse)]")] IAllowBrowserActionOrAnySelector Hover(Selector selector = null); }
    public interface IAllowMoveTo { [Action(Description = "Move the cursor (focus) to the current element (specified by .WithSelector).")] IAllowBrowserActionOrAnySelector MoveTo(Selector selector = null); }
    public interface IAllowWithNextPageButton { [Data(Description = "When retrieving multiple pages of results, this is the button to click to get more results.")] IAllowWithPagesAndGridActions WithNextPageButton(Selector selector); }
    public interface IAllowWithInfiniteScroll { IAllowWithPagesAndGridActions WithInfiniteScroll { [Data(Description = "When retrieving multiple pages of results, this imdocates scroll to page bottom to get more results.")] get; } }
    public interface IAllowWithPages { [Data(Description = "Number of result pages to retrieve when retrieving multiple pages of results.")] IAllowGetGridAndFillInFrom WithPages(int numberOfPages); }
    public interface IAllowWithTokensFrom
    {
        [Data(Description = "Values .Fetch drops into its request's numbered tokens, one row per set of requests. Column 0 fills {0}, column 1 fills {1}, and so on")]
        IAllowWithPagesAndFetch WithTokensFrom(IGPALGrid<string> inputGrid);
        [Data(Description = "Values .Fetch drops into its request's numbered tokens, from a file. CSV values per line, one line per set of requests")]
        IAllowWithPagesAndFetch WithTokensFrom(GPALFile inputFile);
        [Data(Description = "Values .Fetch drops into its request's numbered tokens, from a database query. One column per token, one row per set of requests")]
        IAllowWithPagesAndFetch WithTokensFrom(GPALDatabase inputDatabase);
        [Data(Description = "Values .Fetch drops into its request's numbered tokens, as a single row of comma separated values")]
        IAllowWithPagesAndFetch WithTokensFrom(string tokens);
    }
    public interface IAllowGetGrid { [Data(Description = "Retrieve data and add it into this GPALGrid. Pass a grid configured with .WithDedupeData(true) to skip duplicate rows. GPAL keeps one internally for a workflow if you pass null.")] IAllowWithHeaderOrFileActions GetGrid(ref IGPALGrid<string> returnGrid); }
    public interface IAllowGetElements { [Data(Description = "Find elements for all selectors in this UOW and return them as a unified List<GPALElement>. Results are also available per-selector via selector.WebSelectorFoundResults.")] IAllowBrowserActionOrAnySelector GetElements(out List<GPALElement> elements); }
    public interface IAllowWithHeader { [Data(Description = "Column header for exported data. If a selector is not given a new (.WithName), use this. Or use this instead of the name when used on a Selector.")] IAllowWithHeaderOrFileActions WithHeader(string header); }
    public interface IAllowWithAllThatMatch { [Data(Description = "How many items per page to retrieve OR total items to retrieve. Defaults to int.MaxValue, get all items that match. If less than returns on a page, retrieve only rowCount, rows of results per page. If greater than the number of results on a page, this is the total number of results to return.")] IAllowAfterAnySelectorExceptWithAll WithAllThatMatch(int rowCount = int.MaxValue); }
    public interface IAllowWithHardware { IAllowAfterAnySelector WithHardware { [Settings(Description = "Use hardwre emulation to interact with this element")] get; } }
    public interface IAllowWithJavaScript { IAllowAfterAnySelector WithJavaScript { [Settings(Description = "Use javascript injection to interact with this element")] get; } }
    public interface IAllowWaitFor
    {
        [Wait(Description = "IF after an action is called, this is a sleep timer. If used after adding selectors (.WithSelector) [before calling an action], this is the time to wait to find elements for .WithSelectors before continuing the workflow (can cause to invoke CallIfNotFound handler)")]
        IAllowAfterWaitFor WaitFor(WaitTime waitForTimeInMs);
        [Wait(Description = "Wait for the Selector before proceeding with the workflow. Use WaitFor(timeInMs) or use the default of three [3] seconds. Similar to .WithSelector.WaitFor.Action (can cause to invoke CallIfNotFound handler)")]
        IAllowAfterWaitFor WaitFor(Selector waitForSelector);
        [Wait(Description = "Wait for the element(s) defined using .WithSelector to enter the specified state.")]
        IAllowAfterWaitFor WaitFor(ElementState elementState);
    }
    public interface IAllowWithGridToSave { [Data(Description = "Data GPALGrid used to save results, could be created in another/sub-workflow")] IAllowWithHeaderOrFileActions WithGridToSave(IGPALGrid<string> filename); }
    public interface IAllowStartWorkflow { [Fluent(Description = "Start the workflow if no action is used to start the workflow. Perhaps your logic is in the CallIf handlers, so this will kick off finding the selector elements, thus calling Found/NotFound handlers")] IAllowBrowserActionOrAnySelector StartWorkflow(); }
    public interface IAllowDragAndDrop
    {
        [Fluent(Description = "Perform a drag-and-drop operation. OffsetX/Y is the grab point, DeltaX/DeltaY is the drop offset. Uses native drag events for the current automation engine (Selenium Actions, CDP mouse events, or OttoMagic in-page events); falls back to smoothed hardware mouse emulation for image-matched/remote-desktop elements")]
        IAllowBrowserActionOrAnySelector DragAndDrop(Selector selector = null);
        [Fluent(Description = "Perform a drag-and-drop operation while pressing a modifier key. OffsetX/Y is the grab point, DeltaX/DeltaY is the drop offset. Uses native drag events for the current automation engine (Selenium Actions, CDP mouse events, or OttoMagic in-page events); falls back to smoothed hardware mouse emulation for image-matched/remote-desktop elements")]
        IAllowBrowserActionOrAnySelector DragAndDrop(ModifierKeys modifierKeys);
    }
    public interface IAllowPrintDomElement
    {
        [Fluent(Description = "Print the element defined by .withselector/page (if no selector set) to PDF file.")]
        IAllowBrowserActionOrAnySelector PrintToPDF(GPALFile gpalFile);
        [Fluent(Description = "Print orientation for PrintToPDF - use before calling PrintToPDF")]
        IAllowBrowserActionOrAnySelector WithPageOrientation(PageOrientation pageOrientation);
    }
    public interface IAllowCasting
    {
        [Fluent(Description = "Cast the current tab to the specified device")]
        IAllowBrowserActionOrAnySelector CastTab(string deviceNameOrId);
        [Fluent(Description = "Cast the desktop to the specified device")]
        IAllowBrowserActionOrAnySelector CastDesktop(string deviceNameOrId);
        [Fluent(Description = "Stop casting to device")]
        IAllowBrowserActionOrAnySelector StopCasting();
    }
    #endregion <Atoms>
 
    #region <DerivedInterfaces>
    // An emergent rule of thumb...
    // If the word "Or" appears more than once, invent an umbrella term.
    // And then derive stuff... from the derived stuff.
    // Because nobody wants to look at IAllowGoToOrGlobalWaitOnDocumentReadyOrClose.
    // .WithTokensFrom and .WithPages both feed .Fetch, so either can come first
    public interface IAllowWithPagesAndFetch
        : IAllowWithPages
        , IAllowFetch
    { }
    public interface IAllowGetGridAndFillInFrom
        : IAllowGetGrid
        , IAllowGetElements
        , IAllowFillInFrom
        , IAllowFetch
        , IAllowWithTokensFrom
        , IAllowStartWorkflow
    { }
    public interface IAllowAnySelector
        : IAllowWithSelector
        , IAllowInSelector
    { }
    public interface IAllowBrowserSettingsOrSelectorAction
        : IAllowBrowserSettings
        , IAllowSelectorAction
    { }

    public interface IAllowBrowserSettingsOrGoTo
        : IAllowBrowserSettings
        , IAllowGoToOrGet
        , IAllowWithAllThatMatch
    { }

    public interface IAllowCallTemplate
        : IAllowBrowserActionOrAnySelector
    {
        [Action(Description = "Wait for the page to make a matching call and hand it back as a request ready to issue")]
        IAllowBrowserActionOrAnySelector CaptureCallTemplate(out GPALRequest template);
    }
 
    public interface IAllowBrowserActionOrAnySelector
        : IAllowBrowserAction
        , IAllowAnySelector
        , IAllowSelectorAction
        , IAllowWaitFor
        , IAllowWaitForWindow
        , IAllowNewTabOrWindow
        , IAllowToGPALObject<IBrowser>
        , IAllowWorkflow
        , IAllowStorageOptions
    { }
    public interface IAllowBrowserAction
        : IAllowGoToOrGet
        , IAllowClose
        , IAllowTabActions
        , IAllowSizeControl
        , IAllowWindowScrollBy
        , IAllowPageControl
        , IAllowExecuteJavaScript
        , IAllowInjectScript
        , IAllowGetWindowRectangle
        , IAllowDialogHandling
        , IAllowSiteMapOperations
        , IAllowCasting
        , IAllowFetch
        , IAllowWithTokensFrom
    { }
    public interface IAllowFetch
    {
        [Fluent(Description = "Issue an API request from inside the page, so it carries the session the browser already earned: its cookies, TLS fingerprint, header order and any anti-bot clearance. Honors .WithPages and .WithTokensFrom. The response bodies are handed back with .SaveTo(ref string)")]
        IAllowWithHeaderOrFileActions Fetch(GPALRequest request);
        [Action(Description = "Record what the page asks for, so an endpoint can be read off a site")]
        IAllowBrowserActionOrAnySelector CaptureCalls(bool capture = true);
        [Action(Description = "Record what the page asks for and hand back everything recorded so far")]
        IAllowBrowserActionOrAnySelector CaptureCalls(out List<GPALCall> calls);
        [Action(Description = "Forget everything recorded so far, so what comes next is what happens next")]
        IAllowBrowserActionOrAnySelector ClearCapturedCalls();
        [Settings(Description = "Only record calls whose url holds this")]
        IAllowCallTemplate WithCallFilter(string urlFragment);
    }
    public interface IAllowAllBrowserAndAllSelector
        : IAllowBrowserAction
        , IAllowAnySelector
        , IAllowAfterAnySelector
        , IAllowBrowserSettingsOrGoTo
    { }
    public interface IAllowSelectorAction
        : IAllowClicks
        , IAllowFillInFrom
        , IAllowFocus
        , IAllowHover
        , IAllowMoveTo
        , IAllowScrolling
        , IAllowWithGridToSave
        , IAllowDragAndDrop
        , IAllowPrintDomElement
        , IAllowHideElement
        , IAllowWithAttribute
        , IAllowSetAttributeValue
        , IAllowSetValueFromElement
    { }
    public interface IAllowAfterWaitFor
        : IAllowCallBack
        , IAllowWithNextPageButtonOrGetGrid
        , IAllowWithInfiniteScroll
        , IAllowWithPages
        , IAllowSelectorAction
        , IAllowAnySelector
        , IAllowClicks
        , IAllowWaitForWindow
        , IAllowFillInFrom
        , IAllowTabActions
        , IAllowBrowserAction
        , IAllowToGPALObject<IBrowser>
        , IAllowStartWorkflow
        , IAllowWithAllThatMatch
    { }
    public interface IAllowAfterImageSelector
        : IAllowWithNextPageButtonOrGetGrid
        , IAllowWithInfiniteScroll
        , IAllowWithPages
        , IAllowSelectorAction
        , IAllowWithHardware
        , IAllowWaitFor
        , IAllowCallBack
        , IAllowFillInFrom
    { }
    // NOTE: Add to BELOW LIST what is added here
    public interface IAllowAfterAnySelector
        : IAllowWithNextPageButtonOrGetGrid
        , IAllowWithInfiniteScroll
        , IAllowWithPages
        , IAllowGetElements
        , IAllowSelectorAction
        , IAllowAnySelector
        , IAllowWithAllThatMatch
        , IAllowWithHardware
        , IAllowWithJavaScript
        , IAllowWaitFor
        , IAllowCallBack
        , IAllowClicks
        , IAllowFillInFrom
        , IAllowStartWorkflow
        , IAllowToGPALObject<IBrowser>
    { }
    // NOTE: Add to this list what is added above
    public interface IAllowAfterAnySelectorExceptWithAll
        : IAllowWithNextPageButtonOrGetGrid
        , IAllowWithInfiniteScroll
        , IAllowWithPages
        , IAllowGetElements
        , IAllowSelectorAction
        , IAllowAnySelector
        , IAllowWithHardware
        , IAllowWithJavaScript
        , IAllowWaitFor
        , IAllowCallBack
        , IAllowClicks
        , IAllowFillInFrom
        , IAllowStartWorkflow
        , IAllowBrowserSettings
    { }
    public interface IAllowAfterWaitForAndSizeControl
        : IAllowAfterWaitFor
        , IAllowSizeControl
        , IAllowCallBack
    { }
    public interface IAllowWithNextPageButtonOrGetGrid
        : IAllowWithNextPageButton
        , IAllowGetGrid
    { }
    public interface IAllowWithPagesAndGridActions
        : IAllowWithPages
        , IAllowGetGrid
        , IAllowWithHardware
        , IAllowWithJavaScript
    { }
    public interface IAllowWithHeaderOrFileActions
        : IAllowWithHeader
        , IAllowFileActions
        , IAllowTabActions
        , IAllowClose
    //        , IAllowBrowserActionOrAnySelector
    { }
    #endregion <DerivedInterfaces>
    #region Workflow Interfaces
    public interface IAllowRun
    {
        [Workflow(Description = "Runs the workflows added to this browser, in the order they were added.")]
        IAllowBrowserActionOrAnySelector Run();
    }
    public interface IAllowWorkflowExecution : IAllowRun
    {
        [Workflow(Description = "Executes the workflow while the predicate returns true.")]
        IAllowBrowserActionOrAnySelector While(Func<Browser, bool> predicate);
 
        [Workflow(Description = "Executes the workflow until the specified selector finds at least one element.")]
        IAllowBrowserActionOrAnySelector Until(Selector selector);
 
        [Workflow(Description = "Executes the workflow until the predicate returns true.")]
        IAllowBrowserActionOrAnySelector Until(Func<Browser, bool> predicate);
 
        [Workflow(Description = "Sets the timeout in milliseconds for While or Until loops.")]
        IAllowWorkflowExecution WhileLoopTimeout(int timeoutMs);
 
        [Workflow(Description = "Sets the maximum number of iterations for While or Until loops.")]
        IAllowWorkflowExecution WhileLoopMaxIterations(int maxIterations);
    }
    public interface IAllowScheduledWorkflow
    {
        [Workflow(Description = "Adds a workflow to be scheduled. It builds and owns whatever it drives.")]
        IAllowScheduledWorkflowExecution WithWorkflow(Action workflow);
    }
    public interface IAllowScheduledWorkflowExecution : IAllowScheduledWorkflow
    {
        [Settings(Description = "How many workflows may be in flight at once. One, the default, runs them one after another.")]
        IAllowScheduledWorkflowExecution WithMaxAtOnce(int howMany);
        [Settings(Description = "The least time between two workflows starting. [250ms (default)] 0 starts them together.")]
        IAllowScheduledWorkflowExecution WithStaggerStart(int delayInMs);
        [Settings(Description = "How long to wait for them all before giving up and reporting the unfinished ones as failed. [no limit (default)]")]
        IAllowScheduledWorkflowExecution WithTimeout(int timeoutInMs);
        [Workflow(Description = "Runs every workflow added and waits for them all.")]
        IAllowScheduledWorkflowExecution Run();
        [Workflow(Description = "Runs every workflow added and hands back what happened to each.")]
        IAllowScheduledWorkflowExecution Run(out List<WorkflowRun> runs);
    }
    public interface IAllowWorkflow
    {
        [Workflow(Description = "Defines a workflow to be executed repeatedly based on While or Until conditions.")]
        IAllowWorkflowExecution WithWorkflow(Action<IBrowser> workflow);
    }
    #endregion Workflow Interfaces
    #endregion <BrowserInterfaces>
    #region <Element Assistant Interfaces>
    public interface IAllowElementSettingsAndActions
        : IAllowElementSetting
        , IAllowElementActions
    { }
    public interface IAllowElementActions
    {
        [Action(Description = "Left click the specified element, pressing modifier key (none [default]) while clicking.")]
        IAllowElementSettingsAndActions LeftClick(IGPALElement webElement);
        [Action(Description = "Left click the specified element.")]
        IAllowElementSettingsAndActions LeftClick();
        [Action(Description = "Left click the specified element, pressing modifier key (none [default]) while clicking.")]
        IAllowElementSettingsAndActions LeftClick(ModifierKeys modifierKeys);
        [Action(Description = "Left double click the specified element, pressing modifier key (none [default]) while clicking.")]
        IAllowElementSettingsAndActions LeftDoubleClick(IGPALElement webElement);
        [Action(Description = "M iddle click the found element.")]
        IAllowElementSettingsAndActions MiddleClick();
        [Action(Description = "Right click the specified element, pressing modifier key (none [default]) while clicking.")]
        IAllowElementSettingsAndActions RightClick(IGPALElement webElement);
        [Data(Description = "Fill in [overwrite] text from a string")]
        IAllowElementSettingsAndActions FillInFrom(string textToUse);
        [Data(Description = "Insert text (wherever the cursor is) from a string")]
        IAllowElementSettingsAndActions InsertFrom(string textToUse);
        [Data(Description = "Append to the end text from a string")]
        IAllowElementSettingsAndActions AppendFrom(string textToUse);
        [Data(Description = "Send a control character specified by the VKCode (GPAL has some defined)")]
        IAllowElementSettingsAndActions SendKey(byte VKCode);
        [Data(Description = "Send the specified string using the selector interaction type (selenium/javascript/hardware)")]
        IAllowElementSettingsAndActions SendString(string textToSend);
        [Data(Description = "Press the modifier key specified (Control/Shift/Alt). NOTE: Be careful with Shift and sending mixed case strings after pressing Shift. Mixed case strings will release the Shift key.")]
        IAllowElementSettingsAndActions PressModifierKey(ModifierKeys modifierKeys);
        [Data(Description = "Release the modifier key specified (Control/Shift/Alt) as previously pressed.")]
        IAllowElementSettingsAndActions ReleaseModifierKey(ModifierKeys modifierKeys);
        [Action(Description = "Use javascript injection to scroll the specified web element n pixels horizontally")]
        IAllowElementSettingsAndActions ScrollHorizontalPixels(int scrollAmount);
        [Action(Description = "Use javascript injection to scroll the specified web element n pixels vertically")]
        IAllowElementSettingsAndActions ScrollVerticalPixels(int scrollAmount);
    }
    public interface IAllowElementSetting : IAllowToGPALObject<ElementAssistant>
    {
        [ElementAssitant(Description = "Declare the element to interact with using the ElementAssistant")]
        IAllowElementSettingsAndActions WithElement(IGPALElement GPALElement);
        IAllowElementSettingsAndActions WithJavaScript { [Settings(Description = "Use javascript injection to interact with this element")] get; }
        IAllowElementSettingsAndActions WithHardware { [Settings(Description = "Use hardwre emulation to interact with this element")] get; }
    }
 
    #endregion <\Element Interfaces>
    #region <File Interface>
    public interface IAllowFileActions
    {
        // One save/append syntax. Output format and delimiter come from the GPALFile: its extension
        // (.csv, .tsv/.txt, .xlsx, .json, .xml, .yaml, ...) or its explicit .WithDelimiter settings.
        [File(Description = "Save the retrieved grid. Output format and delimiter are determined by the GPALFile (its extension, or explicit file settings).")]
        IAllowBrowserActionOrAnySelector SaveTo(GPALFile file);
        [File(Description = "Append the retrieved grid. Output format and delimiter are determined by the GPALFile (its extension, or explicit file settings).")]
        IAllowBrowserActionOrAnySelector AppendTo(GPALFile file);
        [File(Description = "Hand back what .Fetch retrieved, as a JSON array holding one response body per page requested.")]
        IAllowBrowserActionOrAnySelector SaveTo(ref string data);
    }
    #endregion
    #region Graphics Interface
    public interface IAllowScreenshot
    {
        [GPAL(Description = "Capture a screenshot")]
        IAllowGraphicSettings CaptureScreen(object ApplicationOrBrowser = null);
 
    }
    // NOTE: TODO: might these be used in Convertor class?
    public interface IAllowGraphicSettings
    {
        [GPAL(Description = "Save to BASE64 string")]
        IAllowGraphicSettings ToBase64String(out string base64String);
        IAllowGraphicSettings ToBitmap(out Bitmap base64String);
        [File(Description = "Save to file (overwrite)")]
        IAllowGraphicSettings SaveTo(GPALFile File);
 
    }
    public interface IImageHelper : IAllowGraphicSettings, IAllowScreenshot, IAllowToGPALObject<IImageHelper>
    {
 
    }
    #endregion Graphics Interface
    #region MagicHelper
    public interface IMagicHelper
    {
        // CalculateHash, GetFullUrl, GetRandomStarWarsQuery and LaunchBrowser are static on MagicHelper: they need no
        // browser, so they must not require one to exist. Reaching them through an instance did
        void Back();
        string CaptureVisibleTab();
        string CheckNetworkIdle(int? maxConnections = null, int? timeoutMs = null, int? pruneMs = null);
        TabTuple CloseTab(dynamic URLorTabId = null);
        bool DeleteStorage(WebsiteStorageType storageType, bool deleteAcrossOrigins = false, string domain = null, string path = null, string key = null, string storeName = null);
        void Forward();
        void FullScreen();
        string Get(GPALUrl URL); // NOTE: CAVEAT: not sure this makes sense, goto will be the same action on the browser, how it is Launched makes it headless...
        string GetContentAndCss(string elementId);
        Dictionary<string, object> GetCssAttributes(string elementId);
        Dictionary<string, object> GetDomAttributes(string elementId);
        Dictionary<string, object> GetDomProperties(string elementId);
        string GetCurrentUrl();
        string GetReadyStatus(string sessionToken);
        GPALElement GetShadowRoot(string Css);
        string GetStorage(WebsiteStorageType storageType, string domain = null, string path = null, string key = null, string storeName = null);
        TabTuple GoTo(GPALUrl URL);
        TabTuple GotoTab(dynamic URLorTabId);
        System.Drawing.Rectangle GetWindowRectangle();
        void SwitchToElement(string elementId);    // in element and in iframe are the same thing
        void InFrame(string elementId);    // in element and in iframe are the same thing
        void Minimize();
        void Maximize();
        void MoveTo(string elementiId);
        void Normal();
        TabTuple NewTab(GPALUrl URL = null);
        TabTuple NextTab();
        int TabCount();
        void OverrideReferrer(string referrer);
        void SetUserAgent(string userAgent);
        void PageDown();
        void PageEnd();
        void PageTop();
        void PageUp();
        void PressModifierKey(ModifierKeys modifierKeys);
        TabTuple PreviousTab();
        void Refresh();
        void ReleaseModifierKey(ModifierKeys modifierKeys);
        void Restore();
        void ScrollWindowByHorizontal(int pixels);
        void ScrollWindowByVertical(int pixels);
        void SetRange(string elementId, int rangeValue);
        bool SetStorage(WebsiteStorageType storageType, string data, string domain = null, string path = null, string key = null, string storeName = null);
        void StealthOverrideReferrer();
        void WithDownloadFile(string downloadPath);
        void Focus(string elementId);
        void FireChangeEvent(string elementId);
        void ScrollIntoView(string elementId);
        void ScrollElement(string elementId, int hPixels, int vPixels);
        string GetElementAttributeHash(string elementId);
        string GetPageSource();
        GPALElement GetParentNode(string elementId);
        string GetAttribute(string elementId, string attribute);
        void SetAttribute(string elementId, string attribute, string value);
        void SetValueFromElement(string srcSelector, string destElementId);
        void LeftClick(string elementId);
        void LeftDoubleClick(string elementId);
        void MiddleClick(string elementId);
        void RightClick(string elementId);
        void SelectClick(string elementId, dynamic indexOrValue);
        bool IsVisibleInViewport(string elementId);
        bool IsEndOfPage();
        void Hover(string elementId);
        void DragAndDrop(string elementId, int deltaX, int deltaY, int offsetX = 0, int offsetY = 0);
        int WindowInnerHeight();
        int WindowInnerWidth();
        int WindowOuterHeight();
        int WindowOuterWidth();
        string Fetch(string url, string method = null, string body = null, string contentType = null, string[] headers = null, bool asBytes = false);
        int WindowPageOffsetX();
        int WindowPageOffsetY();
        System.Drawing.Rectangle GetBoundingClientRect(string elementId);
        void HideElement(string elementId);
        void InjectScript(string script);
        void ClearInjectedScripts();
        bool IsClickAble(string elementId);
        void ClearReferrer();
        GPALElement Evaluate(string xpath);
        List<GPALElement> EvaluateAll(string xpath);
        GPALElement EvaluatePersistent(string xpath);
        List<GPALElement> EvaluateAllPersistent(string xpath);
        string GetLanguages();
        string GetUserAgent();
        List<GPALElement> GetOptions(string elementId);
        void FillInAppend(string elementId, string text);
        void FillInInsert(string elementId, string text);
        void FillInOverwrite(string elementId, string text);
        void LeftClickAndDownload(string elementId, string filenameAndPath);
        void LeftClickAndUpload(string elementId, string filenameAndPath);
        void LeftClickAndUpload(string elementId, GPALFile filenamesAndPaths);
        GPALElement QueryPersistentSelector(string css);
        List<GPALElement> QueryPersistentSelectors(string css);
        GPALElement QuerySelector(string css);
        List<GPALElement> QuerySelectors(string css);
        void ScrollWindow(int hPixels, int vPixels);
        void SendKey(byte vkcode);
        void SendString(string text, int delayMs = 0);
        void SubmitForm(string elementId);
        void SwitchToDefaultContent();
        // void SwitchToFrame(string elementId);    // there is no switch to frame, ottomagic runs in all frames
        void SwitchToShadowRoot(string elementId);
        string GetBrowserSettings();
        string GetGpalSettings();
        string GetSettings();
        string GetWorkflow();
        // Process LaunchBrowser(BrowserSettings browserSettings, string URL = "https://google.com", List<string> additionalArguments = null);
        bool TopBrowser(Process process);
        public WindowTuple OpenWindow(GPALUrl url = null);
        public WindowTuple GoToWindow(dynamic urlOrId);
        public WindowTuple CloseWindow(dynamic urlOrId);
        [Browser(Description = "Move to the next window (to the right)")]
        public WindowTuple NextWindow();
        [Browser(Description = "Move to the previous window (to the left)")]
        public WindowTuple PreviousWindow();
        public WindowTuple GetCurrentWindow();
        int WindowScreenLeft();
        int WindowScreenTop();
    }
    #endregion MagicHelper
    #region Google Sheets
    public interface IAllowSpreadsheetSelection : IAllowToGPALObject<IGoogleSheets>
    {
        IAllowSheetSelection WithSpreadsheet(string spreadsheetIdOrTitle);
    }
 
    public interface IAllowSheetSelection : IAllowDataOperations, IAllowSheetOperations, IAllowToGPALObject<IGoogleSheets>
    {
        IAllowInDataOperations WithSheet(object sheetNameOrId);
        IAllowSheetSelection ListSheets(out IEnumerable<(string name, int sheetId)> sheets);
        IAllowSheetSelection SetSpreadsheetTitle(string title);
    }
 
    public interface IAllowInDataOperations : IAllowSheetOperations, IAllowWithTriggerFunction
    {
        IAllowSheetSelection SetSheetName(string sheetName);
        IAllowDataOperations WithReadRange(string range);
        IAllowDataOperations WithData(IGPALGrid<string> data);
        IAllowFormatSettings WithFormatType(FormatType formatType);
    }
 
    public interface IAllowDataOperations : IAllowInsertSettings, IAllowSheetOperations
    {
        IAllowDataOperations AppendToCell(string cell);
        IAllowDataOperations PrependToCell(string cell);
        IAllowSheetOperations WithWriteRange(string range);
        IAllowDataOperations CalculateSum(out string result);
        IAllowDataOperations CalculateCount(out string result);
    }
 
    public interface IAllowSheetOperations : IAllowGoogleSheetsSaveTo
    {
        IAllowSheetSelection DeleteSheet(object sheetNameOrId);
        IAllowDataOperations WriteToSheet(object sheetNameOrId);
    }
 
    public interface IAllowInsertSettings
    {
        IAllowInsertSettings WithInsertPosition(int position);
        IAllowInsertSettings WithInsertSeparator(string separator);
        IAllowDataOperations InsertAtCell(string cell);
    }
 
    public interface IAllowFormatSettings
    {
        IAllowFormatRange WithFormatValue(object formatValue);
        IAllowFormatRange WithAlignmentFormatValue(HorizontalAlignmentType alignment);
        IAllowFormatRange WithAlignmentFormatValue(VerticalAlignmentType alignment);
        IAllowFormatRange WithNumberFormatValue(NumberFormatType numberFormat);
        IAllowFormatRange WithTextRotationFormatValue(TextRotationType rotation);
        IAllowFormatRange WithColorFormatValue(Color color);
    }
    public interface IAllowFormatRange
    {
        IAllowInDataOperations FormatRange(string range);
    }
    public interface IAllowWithTriggerFunction
    {
        IAllowTriggerSettings WithTriggerFunction(string functionName);
 
    }
    public interface IAllowTriggerSettings : IAllowWithTriggerFunction, IAllowToGPALObject<IGoogleSheets>
    {
        IAllowTriggerSettings WithTriggerSchedule(TriggerScheduleType schedule);
        IAllowDataOperations CreateTrigger(GoogleTriggerType triggerType);
    }
    public interface IAllowScriptOperations : IAllowToGPALObject<IGoogleSheets>
    {
        IAllowScriptOperations WithProjectId(string projectId);
        IAllowScriptOperations WithScriptName(string scriptName);
        IAllowScriptOperations WithScriptAccess(ScriptAccessType access);
        IAllowScriptOperations WithExecuteAs(ExecuteAsType executeAs);
        IAllowScriptOperations WithDeploymentDescription(string description);
        IAllowScriptOperations WithVersionNumber(int versionNumber);
        IAllowDeployWebApp UploadScript(string scriptContent);
        IAllowDeployWebApp UploadScript(GPALFile scriptFile);
    }
    public interface IAllowDeployWebApp : IAllowDataOperations
    {
        IAllowDataOperations DeployScriptAsWebApp(out string webAppUrl);
    }
    public interface IAllowGoogleSheetsSaveTo
    {
        IAllowSheetSelection SaveTo(out IGPALGrid<string> gPalGrid);
        IAllowSheetSelection SaveTo(GPALFile gPALFile);
    }
    public interface IGoogleSheets : IAllowSpreadsheetSelection, IAllowSheetSelection, IAllowSheetOperations, IAllowDataOperations, IAllowInDataOperations, IAllowDeployWebApp
        , IAllowFormatSettings, IAllowInsertSettings, IAllowTriggerSettings, IAllowScriptOperations, IAllowFormatRange, IAllowToGPALObject<IGoogleSheets>
    {
        IAllowSpreadsheetSelection WithCredentials(ICredentials credentials);
        [Settings(Description = "Drive sheets through an Apps Script web app deployed by hand, instead of the Sheets API. Takes the deployment url and needs no credentials.")]
        IAllowSpreadsheetSelection WithWebAppUrl(string webAppUrl);
    }
    #endregion Google Sheets
    #region PuppeteerClient / based entirely on restclient
    public interface IAllowPuppeteerEndpoint
    {
        IAllowPuppeteerCommunicator WithAPIBase(string url);
        IAllowPuppeteerCommunicator WithUsePipes();
    }
    public interface IAllowPuppeteerCommunicator
    {
        IAllowPuppeteerEndpointDetails WithPuppeteerCommunicator(PuppeteerCommunicator communicator);
    }
    public interface IAllowPuppeteerEndpointDetails : IAllowPuppeteerExecution, IAllowPuppeteerParameters, IAllowToGPALObject<IPuppeteerClient>
    {
        IAllowPuppeteerParametersOrExecution WithEndpoint(string endpoint);
        IAllowPuppeteerParametersOrExecution WithEndpoint(ApiEndpoint endpoint);
        IAllowPuppeteerParametersOrExecution WithResultName(string name);
        IAllowPuppeteerEndpointDetails WithSaveFile(GPALFile file);
        IAllowPuppeteerEndpointDetails WithName(string name);
    }
 
    public interface IAllowPuppeteerParametersOrExecution : IAllowPuppeteerParameters, IAllowPuppeteerExecution, IAllowPuppeteerScrollElement, IAllowPuppeteerCheckNetworkIdleOrExecution
    {
        IAllowPuppeteerParametersOrExecution WithUrl(string url);
        IAllowPuppeteerParametersOrExecution WithUrlFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithUrlFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithTabId(int tabId);
        IAllowPuppeteerParametersOrExecution WithTabIdFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithTabIdFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithWindowId(int windowId);
        IAllowPuppeteerParametersOrExecution WithWindowIdFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithWindowIdFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithKey(string key);
        IAllowPuppeteerParametersOrExecution WithKeyFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithKeyFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithCss(string css);
        IAllowPuppeteerParametersOrExecution WithCssFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithCssFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithElements(List<GPALElement> gpalElement);
        IAllowPuppeteerParametersOrExecution WithElementFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithElementFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithXPath(string xpath);
        IAllowPuppeteerParametersOrExecution WithXPathFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithXPathFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithPixels(int pixels);
        IAllowPuppeteerParametersOrExecution WithPixelsFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithPixelsFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithReferrer(string referrer);
        IAllowPuppeteerParametersOrExecution WithReferrerFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithReferrerFromResult(string name);
        IAllowPuppeteerExecution WithText(string text);
        IAllowPuppeteerExecution WithTextFromResult(int resultIndex);
        IAllowPuppeteerExecution WithTextFromResult(string name);
        IAllowPuppeteerParametersOrExecution DownloadTo(GPALFile file);
        IAllowPuppeteerParametersOrExecution UploadFrom(GPALFile file);
        IAllowPuppeteerParametersOrExecution WithElementId(string elementId);
        IAllowPuppeteerParametersOrExecution WithElementIdFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithElementIdFromResult(string name);
        IAllowPuppeteerExecution SetValueFrom(string destSelector);
        IAllowPuppeteerParametersOrExecution WithHPixelsFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithHPixelsFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithVPixelsFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithVPixelsFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithModifiers(ModifierKeys modifierKeys);
        IAllowPuppeteerParametersOrExecution WithSessionToken(string sessionToken);
        IAllowPuppeteerExecution WithDeviceName(string deviceNameOrId);
    }
    public interface IAllowPuppeteerExecution : IAllowPuppeteerActions
    {
        string Execute();
        T Execute<T>();
        IAllowPuppeteerParametersOrExecution AndThen();
        IAllowPuppeteerParametersOrExecution AndThen<T>();
        Task<string> ExecuteAsync();
        Task<T> ExecuteAsync<T>();
        ResultCollection GetExecutionResults();
        IAllowPuppeteerExecution WithHeader(string name, string value);
    }
 
    public interface IAllowPuppeteerParameters : IAllowPuppeteerExecution
    {
        IAllowPuppeteerParametersOrExecution WithParameters(params object[] parameters);
        IAllowPuppeteerParametersOrExecution WithParameters(object parameters);
        IAllowPuppeteerParametersOrExecution WithParametersFromResult(int resultIndex);
        IAllowPuppeteerParametersOrExecution WithParametersFromResult(string name);
        IAllowPuppeteerParametersOrExecution WithEncoding(Enums.ContentEncoding encoding);
    }
 
    public interface IAllowPuppeteerWorkflow
    {
        IAllowPuppeteerWorkflow WithWorkflow(Action<RESTClient> workflow);
        [Workflow(Description = "Sets the timeout in milliseconds for While or Until loops.")]
        IAllowPuppeteerWorkflow WhileLoopTimeout(int timeoutMs);
 
        [Workflow(Description = "Sets the maximum number of iterations for While or Until loops.")]
        IAllowPuppeteerWorkflow WhileLoopMaxIterations(int maxIterations);
        IAllowPuppeteerParametersOrExecution While(Func<bool> condition);
        IAllowPuppeteerParametersOrExecution Until(Func<bool> condition);
    }
 
    public interface IAllowPuppeteerCheckNetworkIdleOrExecution : IAllowPuppeteerExecution
    {
        IAllowPuppeteerCheckNetworkIdleOrExecution WithTimeoutMs(int timeoutMs);
        IAllowPuppeteerCheckNetworkIdleOrExecution WithPruneMs(int pruneMs);
        IAllowPuppeteerCheckNetworkIdleOrExecution WithMaxConnections(int maxConnections);
    }
 
    public interface IAllowPuppeteerScrollElement : IAllowPuppeteerExecution
    {
        IAllowPuppeteerScrollElement WithHPixels(int hPixels);
        IAllowPuppeteerScrollElement WithVPixels(int vPixels);
    }
 
    public interface IAllowPuppeteerDragAndDrop : IAllowPuppeteerExecution
    {
        IAllowPuppeteerDragAndDrop WithDeltaX(int deltaX);
        IAllowPuppeteerDragAndDrop WithDeltaY(int deltaY);
        IAllowPuppeteerDragAndDrop WithOffsetX(int offsetX);
        IAllowPuppeteerDragAndDrop WithOffsetY(int offsetY);
    }
 
    public interface IAllowPuppeteerAttribute : IAllowPuppeteerExecution
    {
        IAllowPuppeteerAttribute WithAttribute(string attribute);
        IAllowPuppeteerAttribute WithValue(string value);
    }
 
    public interface IAllowPuppeteerSelectOptions
    {
        IAllowPuppeteerExecution WithSelectValue(string value);
        IAllowPuppeteerExecution WithSelectIndex(int index);
    }
    public interface IAllowPuppeteerInputText
    {
        IAllowPuppeteerExecution WithText(string text);
    }
    public interface IAllowPuppeteerStorageOptions : IAllowPuppeteerExecution
    {
        IAllowPuppeteerStorageOptions WithStorageDomain(string domain);
        IAllowPuppeteerStorageOptions WithStoragePath(string path);
        IAllowPuppeteerStorageOptions WithStorageKey(string key);
        IAllowPuppeteerStorageOptions WithStorageStoreName(string storeName);
        IAllowPuppeteerStorageOptions WithStorageData(string data);
        IAllowPuppeteerStorageOptions WithDeleteAcrossOrigins(bool trueFalse);
    }
 
    public interface IAllowPuppeteerRangeValue
    {
        IAllowPuppeteerExecution WithRangeValue(int rangeValue);
    }
 
    public interface IAllowPuppeteerActions
    {
        IAllowPuppeteerExecution Back();
        IAllowPuppeteerExecution CaptureVisibleTab(ImageFormat imageFormat = ImageFormat.JPEG);
        IAllowPuppeteerExecution CastDesktop(string deviceNameOrId);
        IAllowPuppeteerExecution CastTab(string deviceNameOrId);
        IAllowPuppeteerExecution CloseTab(GPALUrl url = null);
        IAllowPuppeteerExecution CloseTab(int tabId);
        IAllowPuppeteerExecution CloseWindow(GPALUrl url = null);
        IAllowPuppeteerExecution CloseWindow(int tabId);
        IAllowPuppeteerStorageOptions DeleteStorage(WebsiteStorageType storageType);
        IAllowPuppeteerParameters ExecuteJavaScript(string script); // Removed params version as noted
        [Fluent(Description = "Issue an API request from inside the page, so it carries the session the browser already earned: its cookies, TLS fingerprint, header order and any anti-bot clearance. A relative url resolves against wherever the browser currently is")]
        IAllowPuppeteerParametersOrExecution Fetch(string url);
        IAllowPuppeteerParametersOrExecution WithVerb(string method);
        IAllowPuppeteerParametersOrExecution WithBody(string body);
        IAllowPuppeteerParametersOrExecution WithContentType(string contentType);
        IAllowPuppeteerParametersOrExecution WithHeaders(string[] headers);
        IAllowPuppeteerParametersOrExecution WithBytes(bool asBytes);
        IAllowPuppeteerInputText FillInAppend(dynamic elementOrelementId, int delayMs = 0);
        IAllowPuppeteerInputText FillInInsert(dynamic elementOrelementId, int delayMs = 0);
        IAllowPuppeteerInputText FillInOverwrite(dynamic elementOrelementId, int delayMs = 0);
        IAllowPuppeteerExecution Forward();
        IAllowPuppeteerExecution FullScreen();
        IAllowPuppeteerExecution GetReadyStatus(string sessionToken);
        IAllowPuppeteerParametersOrExecution CheckNetworkIdle(int maxConnections = 0);
        IAllowPuppeteerExecution GetShadowRoot(string css);
        IAllowPuppeteerExecution GetCurrentUrl();
        IAllowPuppeteerExecution GetCurrentWindow();
        IAllowPuppeteerStorageOptions GetStorage(WebsiteStorageType storageType);
        IAllowPuppeteerExecution GetLanguages();
        IAllowPuppeteerExecution GetUserAgent();
        IAllowPuppeteerExecution GoTo(GPALUrl url);
        IAllowPuppeteerExecution GoToTab(GPALUrl url);
        IAllowPuppeteerExecution GoToTab(int tabId);
        IAllowPuppeteerExecution GoToWindow(GPALUrl url);
        IAllowPuppeteerExecution GoToWindow(int tabId);
        IAllowPuppeteerExecution InElement(string elementId);
        IAllowPuppeteerExecution InjectScript(string script);
        IAllowPuppeteerExecution ClearInjectedScripts();
        IAllowPuppeteerExecution InMainDom();
        IAllowPuppeteerExecution InShadowDom(string elementId);
        IAllowPuppeteerExecution Maximize();
        IAllowPuppeteerExecution Minimize();
        IAllowPuppeteerExecution MoveTo(string elementId);
        IAllowPuppeteerExecution MoveTo(System.Drawing.Point point);
        IAllowPuppeteerExecution NewTab(GPALUrl url = null);
        IAllowPuppeteerExecution NextTab();
        IAllowPuppeteerExecution NextWindow();
        IAllowPuppeteerExecution Normal();
        IAllowPuppeteerExecution OpenWindow(GPALUrl url);
        IAllowPuppeteerExecution OverrideReferrer(string referrer);
        IAllowPuppeteerExecution PageDown(int pagesToScroll = 1);
        IAllowPuppeteerExecution PageEnd();
        IAllowPuppeteerExecution PageTop();
        IAllowPuppeteerExecution PageUp(int pagesToScroll = 1);
        IAllowPuppeteerExecution PressModifierKey(ModifierKeys modifierKeys);
        IAllowPuppeteerExecution PreviousTab();
        IAllowPuppeteerExecution PreviousWindow();
        IAllowPuppeteerExecution Refresh();
        IAllowPuppeteerExecution ReleaseModifierKey(ModifierKeys modifierKeys);
        IAllowPuppeteerExecution Restore();
        IAllowPuppeteerParametersOrExecution RightClickAndDownload(string elementId);
        IAllowPuppeteerParametersOrExecution LeftClickAndDownload(string elementId);
        IAllowPuppeteerParametersOrExecution LeftClickAndUpload(dynamic elementOrelementId);
        IAllowPuppeteerExecution ScrollWindowByHorizontal(int pixels);
        IAllowPuppeteerExecution ScrollWindowByVertical(int pixels);
        IAllowPuppeteerExecution SendString(string text, int delayMs = 0);
        IAllowPuppeteerExecution SendKey(byte vkcode);
        IAllowPuppeteerStorageOptions SetStorage(WebsiteStorageType storageType);
        IAllowPuppeteerExecution SetUserAgent(string userAgent);
        IAllowPuppeteerExecution StealthOverrideReferrer();
        IAllowPuppeteerExecution StopCasting();
        IAllowPuppeteerExecution SubmitForm(string elementId);
        IAllowPuppeteerExecution SwitchToDefaultContent();
        IAllowPuppeteerExecution SwitchToElement(string elementId);
        IAllowPuppeteerExecution SwitchToFrame(string elementId);
        IAllowPuppeteerExecution SwitchToShadowRoot(string elementId);
        IAllowPuppeteerExecution DownloadTo(string downloadPath);
        IAllowPuppeteerExecution FireChangeEvent(string elementId);
        IAllowPuppeteerExecution Focus(string elementId);
        IAllowPuppeteerExecution GetBoundingClientRect(string backendNodeId);
        IAllowPuppeteerExecution GetElementAttributeHash(string elementId);
        IAllowPuppeteerExecution GetPageSource();
        IAllowPuppeteerExecution GetParentNode(string elementId);
        IAllowPuppeteerExecution GetContentAndCss(string selectorPath);
        IAllowPuppeteerExecution GetCssAttributes(string elementId);
        IAllowPuppeteerExecution GetDomAttributes(string nodeId);
        IAllowPuppeteerExecution GetDomProperties(string backendNodeId);
        IAllowPuppeteerExecution HideElement(string elementId);
        IAllowPuppeteerExecution IsClickable(string elementId);
        IAllowPuppeteerExecution IsDisplayed(string elementId);
        IAllowPuppeteerExecution IsEnabled(string elementId);
        IAllowPuppeteerExecution IsEndOfPage();
        IAllowPuppeteerExecution IsVisibleInViewport(IGPALElement element);
        IAllowPuppeteerExecution IsVisibleInViewport(string elementId);
        IAllowPuppeteerParametersOrExecution LeftClick(dynamic elementOrelementId);
        IAllowPuppeteerParametersOrExecution LeftDoubleClick(dynamic elementOrelementId);
        IAllowPuppeteerParametersOrExecution MiddleClick(dynamic elementOrelementId);
        IAllowPuppeteerParametersOrExecution RightClick(dynamic elementOrelementId);
        IAllowPuppeteerSelectOptions SelectClick(string elementHandle);     // objectid
        IAllowPuppeteerExecution ScrollIntoView(dynamic elementOrelementId);
        IAllowPuppeteerExecution WindowInnerHeight();
        IAllowPuppeteerExecution WindowInnerWidth();
        IAllowPuppeteerExecution WindowOuterHeight();
        IAllowPuppeteerExecution WindowOuterWidth();
        IAllowPuppeteerExecution WindowPageOffsetX();
        IAllowPuppeteerExecution WindowPageOffsetY();
        IAllowPuppeteerExecution WindowScreenLeft();
        IAllowPuppeteerExecution WindowScreenTop();
        IAllowPuppeteerExecution Hover(string elementId);
        IAllowPuppeteerExecution Evaluate(string xpath);
        IAllowPuppeteerExecution EvaluateAll(string xpath);
        IAllowPuppeteerExecution QuerySelector(string css);
        IAllowPuppeteerExecution QuerySelectors(string css);
        IAllowPuppeteerExecution ScrollWindow(int hPixels, int vPixels);
        IAllowPuppeteerExecution ClearReferrer();
        IAllowPuppeteerExecution TopBrowser();
 
 
        // Multi-parameter methods with fluent steps
        IAllowPuppeteerExecution ScrollElement(int hPixels, int vPixels);
        IAllowPuppeteerAttribute SetAttribute(string elementId);
        IAllowPuppeteerRangeValue SetRange(string elementId);
        IAllowPuppeteerScrollElement ScrollElement(string elementId);
        IAllowPuppeteerDragAndDrop DragAndDrop(string elementId);
        IAllowPuppeteerAttribute GetAttribute(string elementId); // Returns IAllowRESTAttribute, skips WithValue}
    }
    public interface IPuppeteerClient : IAllowPuppeteerEndpoint, IAllowPuppeteerEndpointDetails, IAllowPuppeteerScrollElement, IAllowPuppeteerDragAndDrop, IAllowPuppeteerExecution, IAllowPuppeteerParametersOrExecution
        , IAllowPuppeteerCheckNetworkIdleOrExecution, IAllowPuppeteerAttribute, IAllowPuppeteerParameters, IAllowPuppeteerInputText, IAllowPuppeteerWorkflow
        , IAllowPuppeteerCommunicator, IAllowPuppeteerSelectOptions, IAllowPuppeteerStorageOptions, IAllowPuppeteerRangeValue, IAllowToGPALObject<IPuppeteerClient>
    {
        string Name { get; }
    }
    #endregion Puppeteer
    #region GPAL URL
    public interface IAllowGPALUrlForUrl : IAllowToGPALObject<IGPALUrl>
    {
        IAllowGPALUrlStorageType ForUrl(string url);
    }

    public interface IAllowGPALUrlStorageType : IAllowToGPALObject<IGPALUrl>
    {
        IAllowGPALUrlStorageItemConfig WithStorageType(WebsiteStorageType type);
    }

    public interface IAllowGPALUrlStorageItemConfig : IAllowGPALUrlStorageType, IAllowToGPALObject<IGPALUrl>
    {
        IAllowGPALUrlStorageItemConfig WithStorageDomain(string domain);

        IAllowGPALUrlStorageItemConfig WithStorageStoreName(string storeName);

        IAllowGPALUrlStorageItemConfig WithStoragePath(string path);

        IAllowGPALUrlStorageItemConfig WithStorageKey(string key);

        IAllowGPALUrlStorageItemConfig WithUserDefined(string userDefined);
        IAllowGPALUrlStorageItemConfig WithDeleteAcrossOrigins(bool trueFalse);
    }

    public interface IAllowGPALUrlStorageData
    {
        IAllowGPALUrlStorageItemConfig WithStorageData(string data);
    }

    public interface IGPALUrl :
        IAllowGPALUrlForUrl,
        IAllowGPALUrlStorageType,
        IAllowGPALUrlStorageItemConfig,
        IAllowGPALUrlStorageData
    {
        string Url { get; }
 
        List<StorageAction> Add(StorageAction storageAction);
        List<StorageAction> Add(List<StorageAction> storageActions);

        IReadOnlyList<StorageAction> GetActions();
    }
    #endregion GPAL URL
}