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 GenerallyPositive.Browser;
using MimeKit;
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 System.Windows.Forms.DataVisualization.Charting;
using static GenerallyPositive.Enums;
using static GenerallyPositive.GPAL;
using static GenerallyPositive.GPALForm.GPALForm;
using static GenerallyPositive.GPALSettings;
using static GenerallyPositive.RESTClient;
 
namespace GenerallyPositive
{
    #region <Selector Settings>
    [Interface(Description = "Selector Settings")]
    public interface IAllowSelectorSettings : IAllowCallBack, IAllowToGPALObject<Selector>
    {
        [Selector(Description = "Locate element with OCR using the text to find")]
        IAllowSelectorSettings WithOCR(string textToFind);
        [Selector(Description = "Locate element using a CSS path (browser only)")]
        IAllowSelectorSettings WithCSS(string CSS);
        [Selector(Description = "Locate element matching a partial or full HRef (browser only)")]
        IAllowSelectorSettings WithHRef(string HRefFullOrPartial);
        [Selector(Description = "Locate element using an XPath")]
        IAllowSelectorSettings WithXPath(string xpath);
        [Selector(Description = "Locate element searching visible text to find")]
        IAllowSelectorSettings WithText(string textToFind);
        [Selector(Description = "Locate element with the given value")]
        IAllowSelectorSettings WithValue(string valueToFind);
        [Selector(Description = "Locate element with the given name")]
        IAllowSelectorSettings WithName(string nameToFind);
        [Selector(Description = "Locate element with the given class name")]
        IAllowSelectorSettings WithClassName(string nameToFind);
        [Selector(Description = "Locate element using an AutomationID (application only)")]
        IAllowSelectorSettings WithAutomationID(string nameToFind);
        [Selector(Description = "Locate element loading the given image file to match")]
        IAllowSelectorSettings WithImage(GPALFile imageToFindPath);
        [Selector(Description = "Locate element loading the given image file to match")]
        IAllowSelectorSettings WithImage(string dataURL);
        [Selector(Description = "Locate element using the supplied image to match")]
        IAllowSelectorSettings WithImage(Image imageToFine);
        [Settings(Description = "Name of selector (used in messages and column names)")]
        IAllowSelectorSettings WithSelectorName(string name);
        [Settings(Description = "X offset to click inside element, also starting X location in element for drag-and-drop")]
        IAllowSelectorSettings WithOffsetX(int offsetX);
        [Settings(Description = "Y offset to click inside element, also starting X location in element for drag-and-drop")]
        IAllowSelectorSettings WithOffsetY(int offsetY);
        [Settings(Description = "X delta for drag-and-drop")]
        IAllowSelectorSettings WithDeltaX(int offsetX);
        [Settings(Description = "Y delta for drag-and-drop")]
        IAllowSelectorSettings WithDeltaY(int offsetY);
        [Settings(Description = "Scroll down a page to see if the selector comes into view [image/ocr]")]
        IAllowSelectorSettings WithSearchForSelector(bool trueFalse = true);
        IAllowSelectorSettings WithHardware { [Settings(Description = "Use hardware emulation to interact with this element [mouse/keyboard]")] get; }
        IAllowSelectorSettings WithJavaScript { [Settings(Description = "Use javascript injection to interact with this element")] get; }
        [Obsolete("This method is not preferred. Consider using WithJavaScript instead.", false)]
        IAllowSelectorSettings WithJavascript { [Settings(Description = "Use javascript injection to interact with this element")] get; }
        IAllowSelectorSettings WithSelenium { [Settings(Description = "Use selenium to interact with this element [default]")] get; }
        [Settings(Description = "Smoothly move mouse to interact with this element [instead of jump to]. Implies .WithHardware")]
        IAllowSelectorSettings WithSimulateMouse(bool moveWithArc = false);
        [Settings(Description = "Stop the workflow if this selector is not found")]
        IAllowSelectorSettings WithStopOnNotFound(bool trueFalse = false);
        [Data(Description = "When retrieving data from the element, get data from the named attribute. [visible text is default]")]
        IAllowSelectorSettings UseAttribute(string attributeName);
        [Data(Description = "Located elements will match only if the text contains the supplied string")]
 
        IAllowSelectorSettings ContainsAttribute(string text);
        [Data(Description = "Located elements will match only if they have this named attribute")]
        IAllowSelectorSettings MatchAttribute(string href);
        [Data(Description = "Located elements will match only if the attribute name matches this regular expression")]
        IAllowSelectorSettings MatchAttributeRegex(string href);
        [Data(Description = "Located elements will match only if the text contains the supplied string")]
 
        IAllowSelectorSettings ContainsHRef(string text);
        [Data(Description = "Located elements will match only if they have this href")]
        IAllowSelectorSettings MatchHRef(string href);
        [Data(Description = "Located elements will match only if the href matches this regular expression")]
        IAllowSelectorSettings MatchHRefRegex(string href);
        [Data(Description = "Located elements will match only if the text contains the supplied string")]
 
        IAllowSelectorSettings ContainsPlaceholder(string text);
        [Data(Description = "Located elements will match only if the placeholder value matches the supplied string")]
        IAllowSelectorSettings MatchPlaceholder(string placeholder);
        [Data(Description = "Located elements will match only if the placebolder value matches this regular expression")]
        IAllowSelectorSettings MatchPlaceholderRegex(string placeholder);
        [Data(Description = "Located elements will match only if the text contains the supplied string")]
 
        IAllowSelectorSettings ContainsSrc(string text);
        [Data(Description = "Located elements will match only if the src matches the supplied string")]
        IAllowSelectorSettings MatchSrc(string src);
        [Data(Description = "Located elements will match only if the src matched the regular expression")]
        IAllowSelectorSettings MatchSrcRegex(string src);
        [Data(Description = "Located elements will match only if the text contains the supplied string")]
 
        IAllowSelectorSettings ContainsText(string text);
        [Data(Description = "Located elements will match only if the text matches the regular expression")]
        IAllowSelectorSettings MatchText(string text);
        [Data(Description = "Located elements will match only if the text matches the regular expression")]
        IAllowSelectorSettings MatchTextRegex(string text);
 
        [Data(Description = "Located elements will match only if the text contains the supplied string")]
        IAllowSelectorSettings ContainsValue(string text);
        [Data(Description = "Located elements will match only if the value matches the supplied string")]
        IAllowSelectorSettings MatchValue(string value);
        [Data(Description = "Located elements will match only if the value matches the regular expression")]
        IAllowSelectorSettings MatchValueRegex(string value);
        [Data(Description = "Custom Application UIAutomation Element matching method to examine and 'match' located elements using your algorithm.")]
        IAllowSelectorSettings MatchFunction(Selector.appMatchingFunction AppMatchingFunction);
        [Data(Description = "Custom browser webElement matching method to examine and 'match' located elements using your algorithm")]
        IAllowSelectorSettings MatchFunction(Selector.webMatchingFunction WebMatchingFunction);
    }
    public interface IAllowCallBack
    {
        // return values
        // 0 = not handled
        // 1 = handled
        // -1 = error
        [Callback(Description = "Selector based callback if this selector is found")]
        IAllowSelectorSettings CallIfFound(Browser.Browser.CallIfDelegate CallIfFound);
        [Callback(Description = "Selector based callback if this selector is NOT found")]
        IAllowSelectorSettings CallIfNotFound(Browser.Browser.CallIfDelegate CallIfNotFound);
        // TODO: might we want to have an element called directly after it is filled in rather than the whole row? NOT YET
        // IAllowAfterAnySelector CallAfterFillIn(Browser.Browser.CallAfterFillInDelegate CallAfterFillIn);
    }
 
    #endregion <Selector Settings>
    #region <GPAL Interfaces>
    [Interface(Description = "Global Settings")]
    public interface IAllowGPALSettings
    {
        [GPALSettings(Description = "Print GPAL published information or exception messages to the supplied database. One column for each GPALEventArgs property. ")]
        IAllowGPALSettings WithPublishToLogger(IGPALLogger logger);
        IAllowGPALSettings RemoveLogger(IGPALLogger logger);
        [GPALSettings(Description = "Print GPAL published information or exception messages to the output window in VisualStudio. [true (default)]")]
        IAllowGPALSettings WithPublishToDebug(GPALEventType eventTypes = GPALEventType.INFO | GPALEventType.WARNING | GPALEventType.ERROR | GPALEventType.EXCEPTION | GPALEventType.NOTICE | GPALEventType.CAUTION | GPALEventType.FAILURE);
        [GPALSettings(Description = "Indicate which published events to print to the console. [None (default)]")]
        IAllowGPALSettings WithPublishToConsole(GPALEventType eventTypes = GPALEventType.INFO | GPALEventType.WARNING | GPALEventType.ERROR | GPALEventType.EXCEPTION | GPALEventType.NOTICE | GPALEventType.CAUTION | GPALEventType.FAILURE);
        [GPALSettings(Description = "Print stack track when GPAL prints it's own published messages (PublishToConsole/PublishToDebug == true). [false (default)]")]
        IAllowGPALSettings WithPublishStackTrace(bool trueFalse = true);
        IAllowGPALSettings CallOnFail(Browser.Browser.CallOnFailDelegate callOnFail);
        [GPALSettings(Description = "Intercharacter typing delay [0ms (default), no pacing]")]
        IAllowGPALSettings WithTypingDelay(int delayInTicks = 0);
        [GPALSettings(Description = "Handler to receive GPAL Exception events")]
        IAllowGPALSettings WithExceptionHandler(EventHandler<GPALEventArgs> ExceptionEventHandler);
        [GPALSettings(Description = "Handler to receive GPAL Information events")]
        IAllowGPALSettings WithInformationHandler(EventHandler<GPALEventArgs> InformationEventHandler);
        [GPALSettings(Description = "Image matching similarity percentage. [80 (default)]")]
        IAllowGPALSettings WithImageMatchingPercentage(int matchPercent = 80);
        [GPALSettings(Description = "Simulate moving the mouse for every action (implies .WithHardware). [false (default)]")]
        IAllowGPALSettings WithSimulateMouseMovement(bool trueFalse = true);
        [GPALSettings(Description = "Stop workflow if any selector is not found")]
        IAllowGPALSettings WithStopOnNotFound(bool trueFalse = true);
        [GPALSettings(Description = "Global location for browser drivers. [./ (default)(same dir as exe)]")]
        IAllowGPALSettings WithDriverLocation([Directory(Description = "Global location for browser drivers. [./ (default)(same dir as exe)]")] string driverPath = "./");
        IAllowGPALSettings WithTempDirectory([Directory(Description = "Where GPAL writes files it created itself and nobody asked to keep. [GPALfilesSafeToDelete beside the exe (default)]")] string tempPath);
        [GPALSettings(Description = "Set the default location to store temporary profiles if WithDefaultDataDir is not used. default [C:\\profiles]. Also saved in GPAL.yaml that loads on startup.")]
        IAllowGPALSettings WithTempProfileDirectory([Directory(Description = "Global location for temp profiles. [c:\\profiles (default)(saved in GPAL.yaml that is loaded on startup)]")] string tempProfileDirectory);
        [GPALSettings(Description = "Substitue string when data cannot be retrieved for an element [##UNABLE TO GET## (default)]")]
        IAllowGPALSettings WithDefaultErrorPlaceholder(string message = "##UNABLE TO GET##");
        [GPALSettings(Description = "Automatically update the Chrome webdriver when running a GPAL application. Manually deploy first Chrome driver, tho.")]
        IAllowGPALSettings WithAutomationEngine(AutomationEngine automationEngine = AutomationEngine.PuppeteerPort);
        [GPALSettings(Description = "Automatically update the Chrome webdriver when running a GPAL application. Manually deploy first Chrome driver, tho.")]
        IAllowGPALSettings WithAutoUpdateWebDriver(bool trueFalse = true);
        [GPALSettings(Description = "Do not try alternate methods to interact with an element if an error occurs.")]
        IAllowGPALSettings WithNoFallbackActions(bool trueFalse = true);
        [GPALSettings(Description = "Ticks to wait for element to show up before continuing. Applies to every element in every workflow. Override in a Unit of Work with .WaitFor().")]
        IAllowGPALSettings WithWaitFor(int waitForInTicks);
        [GPALSettings(Description = "Global CallIfFound handler for all selectors in any Unit of Work")]
        IAllowGPALSettings CallIfFound(Browser.Browser.CallIfDelegate CallIfFound);
        [GPALSettings(Description = "Global CallIfFound handler for all selectors in any Unit of Work")]
        IAllowGPALSettings CallIfNotFound(Browser.Browser.CallIfDelegate CallIfNotFound);
        [GPALSettings(Description = "Global CallIfFound handler for all application selectors in any Unit of Work")]
        IAllowGPALSettings AppCallIfFound(Application.Application.CallIfDelegate CallIfFound);
        [GPALSettings(Description = "Global CallIfFound handler for all application selectors in any Unit of Work")]
        IAllowGPALSettings AppCallIfNotFound(Application.Application.CallIfDelegate CallIfNotFound);
    }
    #endregion <GPAL Interfaces>
    #region <Database Interfaces>
    public interface IGPALDatabase : IAllowDatabaseSettings, IAllowParameterLength, IAllowPrecsionScaleAndSettings, IAllowParametersAndActions
        , IAllowParametersAndUsing, IAllowParametersAndInto, IAllowDatabaseExecute, IAllowToGPALObject<IGPALDatabase>, System.IDisposable
    {
        IGPALGrid<string> Tokens { get; }
    }
    public interface IAllowParameterLength { IAllowDatabaseSettings WithParameterLength(int columnLength); };
    public interface IAllowColumnPrecision { IAllowPrecsionScaleAndSettings WithParameterPrecision(int columnPrecision); };
    public interface IAllowColumnScale { IAllowPrecsionScaleAndSettings WithParameterScale(int columnScale); };
    public interface IAllowPrecsionScaleAndSettings : IAllowDatabaseSettings
        , IAllowColumnPrecision
        , IAllowColumnScale
    { }
    public interface IAllowDatabaseExecute
    {
        IAllowParametersAndActions Execute(out int rowCount);
        IAllowParametersAndActions Execute(out List<int> rowCountsPerStatement);
    }

    public interface IAllowDatabaseGridSettings : IAllowDatabaseSettings
    {
        IAllowDatabaseSettings GetRowCount(out List<int> rowCountsPerTable);
    }
    public interface IAllowDatabaseSettings : IAllowToGPALObject<IGPALDatabase>
    {
        IAllowDatabaseSettings WithConnectionString(string connectionString);
        [Settings(Description = "How long a command may run before the provider gives up. [the provider's own default]")]
        IAllowDatabaseSettings WithCommandTimeout(int timeoutInSeconds);
        [Action(Description = "Close the connection and roll back a transaction still open on it. The database can be used again after.")]
        IAllowDatabaseSettings Close();
        IAllowDatabaseSettings WithUsername(string userName);
        IAllowDatabaseSettings WithPassword(string password);
        IAllowDatabaseSettings WithServerName(string serverName);
        IAllowDatabaseSettings WithDatabaseName(string databaseName);
        IAllowDatabaseSettings WithDatabaseType(DatabaseType databaseType);
        IAllowDatabaseSettings WithTableName(string tableName);
        IAllowDatabaseSettings WithSQLCommand(string sqlCommand);
        IAllowDatabaseSettings WithStoredProcedure(string storedProcedure);
        IAllowDatabaseSettings WithParameterName(string parameterName);
        IAllowDatabaseSettings WithDatetimeParameter(string parameterName);
        IAllowDatabaseSettings WithTimeParameter(string parameterName);
        IAllowDatabaseSettings WithTimestampParameter(string parameterName);
        IAllowPrecsionScaleAndSettings WithDecimalParameter(string parameterName);
        IAllowDatabaseSettings WithFloatParameter(string parameterName);
        IAllowDatabaseSettings WithImageParameter(string parameterName);
        IAllowDatabaseSettings WithIntegerParameter(string parameterName);
        IAllowDatabaseSettings WithMoneyParameter(string parameterName);
        IAllowParameterLength WithVarCharParameter(string parameterName);
        IAllowParameterLength WithNVarCharParameter(string parameterName);
        IAllowParameterLength WithCharParameter(string parameterName);
        IAllowParameterLength WithNCharParameter(string parameterName);
        IAllowParameterLength WithTextParameter(string parameterName);
        IAllowParameterLength WithNTextParameter(string parameterName);
        IAllowDatabaseSettings WithTableParameter(string parameterName); // Structured columns
        IAllowDatabaseSettings WithRowCount(int rowCount);
        IAllowDatabaseSettings WithCreateAs(string createSQL);
        IAllowDatabaseSettings WithReadAs(string selectSQL);
        IAllowDatabaseSettings WithUpdateAs(string updateSQL);
        IAllowDatabaseSettings WithDeleteAs(string deleteSQL);
        IAllowDatabaseSettings WithErrorCallback(GPALDatabase.CallOnError CallOnError);
        IAllowDatabaseSettings WithUDTTName(string typeName); // Structured column UDTT name
    }
    public interface IAllowDatabaseInto
    {
        IAllowDatabaseGridSettings SaveTo(out IGPALGrid<string> dataGrid);
        IAllowDatabaseSettings SaveTo(out System.Data.DataTable dataTable);
        IAllowDatabaseSettings SaveTo(out System.Data.DataSet dataSet);
        IAllowDatabaseSettings SaveTo(out string value);
    }
    public interface IAllowDatabaseUsing
    {
        IAllowDatabaseExecute Using(IGPALGrid<string> dataGrid);
        IAllowDatabaseExecute Using(System.Data.DataTable dataTable);
    }
    public interface IAllowParameters
    {
        IAllowParameters ClearParameters { get; }
        IAllowParametersAndActions WithParameter(string parameter);
        IAllowParametersAndActions WithParameterGrid(IGPALGrid<string> parameter);
    }
    public interface IAllowDatabaseActions : IAllowDatabaseExecute
    {
        IAllowParametersAndUsing Create { get; }
        IAllowParametersAndInto Read { get; }
        IAllowParametersAndUsing Update { get; }
        IAllowParametersAndUsing Delete { get; }
        IAllowParametersAndActions BeginTransaction { get; }
        IAllowDatabaseActions Rollback { get; }
        IAllowDatabaseActions Commit { get; }
 
    }
    public interface IAllowParametersAndActions
        : IAllowParameters
        , IAllowDatabaseActions
    { }
    public interface IAllowParametersAndUsing
        : IAllowParameters
        , IAllowDatabaseUsing
    { }
    public interface IAllowParametersAndInto
        : IAllowParameters
        , IAllowDatabaseInto
    { }
 
    #endregion <DatabaseInterfaces>
    #region Credentials
    public interface IAllowCredentialServiceType
    {
        IAllowCredentialsUsername WithService(CredentialServiceType serviceType);
    }
 
    public interface IAllowCredentialsUsername : IAllowToGPALObject<ICredentials>
    {
        IAllowCredentialsPassword WithUsername(string username);
 
        // Alternative to WithUsername/WithPassword/etc: supply the login (master) credentials for the
        // credential service itself (e.g. your Bitwarden/LastPass account), previously built with
        // GPAL.CredentialsFor(CredentialServiceType.None).WithUsername(...).WithPassword(...).
        IAllowCredentialsIntoCredentials WithCredentials(ICredentials credentials);
 
        // Static API key - supply the key directly, from an env variable, or from an internal REST endpoint:
        // GPAL.CredentialsFor(CredentialServiceType.StaticKey).WithServiceKey("sk-ant-...").ToGPALObject()
        IAllowCredentialsIntoCredentials WithServiceKey(string key);
 
        // Like WithServiceKey, but reads the key from an environment variable instead of a literal string:
        // GPAL.CredentialsFor(CredentialServiceType.StaticKey).WithKeyFromEnv("ANTKEY").ToGPALObject()
        IAllowCredentialsIntoCredentials WithKeyFromEnv(string envVariableName);
 
        // Like WithServiceKey, but fetches the key via a GET request made with an already-configured RESTClient.
        // Must be followed by .WithEndpoint(endpoint) to specify which endpoint returns the key:
        // GPAL.CredentialsFor(CredentialServiceType.StaticKey).WithKeyFromApi(restClient).WithEndpoint("ANTKEY").ToGPALObject()
        IAllowKeyFromApiEndpoint WithKeyFromApi(IRESTClient restClient);
    }
 
    public interface IAllowKeyFromApiEndpoint
    {
        IAllowCredentialsIntoCredentials WithEndpoint(string endpoint);
    }
 
    public interface IAllowCredentialsPassword : IAllowToGPALObject<ICredentials>
    {
        IAllowCredentialsServiceKeyWithCredentials WithPassword(string password);
    }
    public interface IAllowClientId
    {
        IAllowClientSecret WithClientId(string clientId);
        IAllowCredentialsIntoCredentials WithServiceAccountKey(GPALFile serviceAccountKeyFile);
        IAllowCredentialsIntoCredentials WithServiceAccountKey(string serviceAccountKey);
        IAllowCredentialsIntoCredentials WithServiceAccountKey(GoogleServiceAccountKey serviceAccountKey);
    }
    public interface IAllowClientSecret
    {
        IAllowCredentialsIntoCredentials WithClientSecret(string clientSecret);
    }
    public interface IAllowCredentialsServiceKeyWithCredentials : IAllowClientId, IAllowToGPALObject<ICredentials>
    {
        // does this make sense? if loading form a db or file we can cast to this type and use it?
        // IAllowCredentialsIntoCredentials WithCredentials(ICredentials credentials);
        [Settings(Description = "How the site expects to be told who you are, which decides what a browser given this credential does with it")]
        IAllowCredentialsServiceKeyWithCredentials WithWebAuth(WebAuthType webAuthType);
        [Settings(Description = "A token the workflow already holds, presented according to the WebAuthType")]
        IAllowCredentialsServiceKeyWithCredentials WithAccessToken(string accessToken);
        [Settings(Description = "Where the OAuth redirect lands, which has to be the URI registered with the provider")]
        IAllowCredentialsServiceKeyWithCredentials WithAuthRedirectUrl(string redirectUrl);
    }
 
    public interface IAllowCredentialsIntoCredentials : IAllowGetCredentials, IAllowToGPALObject<ICredentials>
    {
        IAllowCredentialsIntoCredentials GetCredentialsFor(string target);
        IAllowCredentialsIntoCredentials WithDomain(string domain);
        IAllowGetCredentials SaveTo(IGPALGrid<string> grid);
        IAllowCredentialsIntoCredentials WithAuthCode(string authCode);
        IAllowCredentialsIntoCredentials WithRefreshToken(string refreshToken);
        IAllowCredentialsIntoCredentials WithScope(OAuthScope scope);
    }
 
    public interface IAllowGetCredentials
    {
        // No methods, placeholder for Into completion
        void FetchAccessToken(out string accessToken);
    }
 
    public interface ICredentials : IAllowCredentialServiceType, IAllowClientSecret, IAllowCredentialsUsername, IAllowCredentialsPassword, IAllowCredentialsServiceKeyWithCredentials, IAllowCredentialsIntoCredentials, IAllowGetCredentials, IAllowKeyFromApiEndpoint
    {
        // Unifies all fluent interfaces
    }
    #endregion Credentials
    #region AI
    public interface IAllowAICredentials
    {
        IAllowAITask WithCredentials(ICredentials credentials);
        IAllowAITask WithCredentials(string staticApiKey);
    }
    public interface IAllowAIModel
    {
        // Accepts AIModel.ClaudeSonnet46 etc, or any freehand model ID string via implicit conversion.
        IAllowAITask WithModel(AIModel model);
    }
    public interface IAllowAITaskConfig
    {
        IAllowAIConfig WithTask(AITask task);
        IAllowAIConfig WithTaskConfig(ClassificationConfig config);
        IAllowAIConfig WithClassificationType(AIClassificationType type);
        IAllowAIConfig WithCustomClassification(ClassificationConfig config);
    }
    public interface IAllowAIOutput
    {
        IAllowAIExecution WithOutputTo(out IGPALGrid<string> target);
        IAllowAIExecution WithOutputTo(object target);
    }
    public interface IAllowAIConfig : IAllowAITaskConfig, IAllowAIOutput, IAllowToGPALObject<IGPALAI>
    {
        IAllowAIOutput WithInputFrom(object source);
        IAllowAIOutput WithLiveInputFrom(GPALForm.GPALInput input, int debounceMilliseconds = 500);
        IAllowAIOutput WithLiveInputFrom(GPALForm.GPALTextArea textArea, int debounceMilliseconds = 500);
    }
    public interface IAllowAIExecution : IAllowToGPALObject<IGPALAI>
    {
        IAllowAIConfig CallAfterAIResponse(AIResponseDelegate callback);
        IAllowAIConfig Execute();
 
        // Reports "Sending request...", "Waiting for response...", "Response received", and any
        // error encountered, to the given status strip while the AI task runs.
        IAllowAIExecution WithStatusTo(GPALForm.GPALStatusStrip statusStrip);
    }
    public interface IAllowAITask : IAllowAICredentials, IAllowAIModel, IAllowToGPALObject<IGPALAI>
    {
        IAllowAIConfig WithTask(AITask task);
    }
    public interface IAllowAIProvider : IAllowToGPALObject<IGPALAI>
    {
        IAllowAITask WithProvider(AIProviderType provider);
    }
    public interface IGPALAI : IAllowAICredentials, IAllowAIExecution, IAllowAIOutput, IAllowAIConfig, IAllowAITask, IAllowAIProvider
    {
    }
    #endregion AI
    #region <Converter Interfaces>
    public interface IGPALConverter : IAllowConverterInput, IAllowConverterSettings, IAllowConverterActions, IAllowToGPALObject<IGPALConverter>
        , IAllowConverterSettingsAndActions, IAllowConverterInputAndActions
    {
        //        internal ConverterSettings ConverterSettings { get; set; }
    }
    public interface IAllowConverterInput : IAllowToGPALObject<IGPALConverter>
    {
        [Settings(Description = "Get input data to convert using the Database object")]
        IAllowConverterSettingsAndActions WithInput(IGPALDatabase inputDatabase);
        [Settings(Description = "Input data is contained in this GPALGrid")]
        IAllowConverterSettingsAndActions WithInput(IGPALGrid<string> inputGrid);
        [Settings(Description = "Input data is in this string")]
        IAllowConverterSettingsAndActions WithInput(string inputData);
        [Settings(Description = "Input data file (extension denotes type, override using WithInputType)")]
        IAllowConverterSettingsAndActions WithInput(GPALFile inputFile);
        [Settings(Description = "Input class, uses reflection to map to output format")]
        IAllowConverterSettingsAndActions WithInput(dynamic inputClass);
        [Settings(Description = "[Global] Register a custom struct type for the converter to recognize. Structs cannot be reliably determined. If you have a custom struct to convert, register it first.")]
        IAllowConverterInput RegisterKnownStructType(Type knownStructType);
    }
    public interface IAllowConverterSettings : IAllowToGPALObject<IGPALConverter>
    {
        [Settings(Description = "Specify input data format")]
        IAllowConverterSettingsAndActions WithInputType(DataFormat inDataType);
        [Settings(Description = "Specify output data format")]
        IAllowConverterSettingsAndActions WithOutputType(DataFormat outDataType);
        [Settings(Description = "[Global] First line is a column name list (for flat files: csv, txt, prn)")]
        IAllowConverterSettingsAndActions WithFirstLineHasColumnNames(bool firstLineHeaders = true);
        [Settings(Description = "[Global] Ignore first line column name list (for flat files: csv, txt, prn)")]
        IAllowConverterSettingsAndActions WithIgnoreFirstLineColumnNames(bool ignoreFirstLine = true);
        [Settings(Description = "[Global] Each field is contained in quotes (for flat files: csv, txt, prn)")]
        IAllowConverterSettingsAndActions WithColumnsEnclosedInQuotes(bool fieldsEnclosedInQuote = true);
        [Settings(Description = "Column names for this conversion. Overrides the input source's own columns positionally; unsupplied columns are backfilled from the source.")]
        IAllowConverterSettingsAndActions WithColumnNames(List<string> columnNames);
        [Settings(Description = "Append a single column name for this conversion. Repeated calls build the list in order.")]
        IAllowConverterSettingsAndActions WithColumnName(string parameterName);
    }
    public interface IAllowConverterActions
    {
        [Action(Description = "")]
        IAllowConverterInputAndActions SaveTo(IGPALDatabase outputDatabase);
        [Action(Description = "")]
        IAllowConverterInputAndActions SaveTo(ref IGPALGrid<string> outputGrid);
        [Action(Description = "")]
        IAllowConverterInputAndActions SaveTo(string outputData);
        [Action(Description = "")]
        IAllowConverterInputAndActions AppendTo(GPALFile outputFile);
        [Action(Description = "")]
        IAllowConverterInputAndActions SaveTo(GPALFile outputFile);
        [Action(Description = "")]
        IAllowConverterInputAndActions SaveTo<T>(ref T outputClass);
        [Action(Description = "")]
        IAllowConverterInputAndActions RenderTo(IGPALDatabase outputDatabase);
        [Action(Description = "")]
        IAllowConverterInputAndActions RenderTo(string outputData);
        [Action(Description = "")]
        IAllowConverterInputAndActions RenderTo(GPALFile outputFile);
        [Action(Description = "")]
        IAllowConverterInputAndActions RenderToClass(out dynamic outputClass);
        [Action(Description ="Pretty print the input to a new string.")]
        IAllowConverterInputAndActions PrettyPrintTo(out string outputData);
    }
    public interface IAllowBase64Save
    {
        [Action("Save to a string the decoded Base64 content")]
        IAllowBase64SaveOrInput SaveTo(string base64Output);
        [Action("Save to a file based upon content type")]
        IAllowBase64SaveOrInput SaveTo(GPALFile base64OutputFile);
    }
 
    public interface IAllowBase64SaveOrInput : IAllowBase64Save
        , IAllowConverterInput
    { }
    public interface IAllowConverterSettingsAndActions : IAllowConverterActions
        , IAllowConverterSettings
    { }
    public interface IAllowConverterInputAndActions : IAllowConverterActions
        , IAllowConverterInput
    { }
 
    #endregion <Converter Interfaces>
    #region <File Interfaces>
    public interface IGPALFile : IAllowFileSettings, IAllowFileActions, IAllowFileName
    {
        string First { get; }
        string Last { get; }
        GPALFile Next { get; }
        string Filename { get; }
        List<string> Filenames { get; }
        string DirectoryPart { get; }
        string FilePart { get; }
        List<string> DirectoryParts { get; }
        List<string> FileParts { get; }
        List<string> ReturnFilenames { get; }
        string SourceUrl { get; }
        int Count { get; }
 
    }
    internal interface IGPALFileInternal
    {
        internal GPALFileSettings FileSettings { get; set; }
        internal List<IGPALGrid<string>> TokenList { get; set; }
        internal List<string> FileData { get; set; }
        internal List<char?> Delimiter { get; set; }
        internal List<bool> FieldsEnclosedInQuotes { get; set; }
        internal List<bool> FirstLineIsColumnNames { get; set; }
        internal List<bool> IgnoreFirstLineColumnNames { get; set; }
        internal bool UseOneHeaderForAllFiles { get; set; }
        internal List<Dictionary<object, dynamic>> FileDictionary { get; set; }
        internal List<IGPALGrid<string>> FileGrid { get; set; }
        internal bool AlreadyTokenized { get; set; }
    }
    public interface IAllowFileSettings : IAllowFileName, IAllowToGPALObject<GPALFile>
    {
        [Settings(Description = "IF this file is delimited, the delimiter used.")]
        IAllowFileSettings WithDelimiter(char delimiter);
        [Settings(Description = "Add a column name to the column name list. (If no header in file or to override.)")]
        IAllowFileSettings WithColumnName(string parameterName);
        [Settings(Description = "Add column names to the column name list using the .WithDelimiter. Use this to add headers for multiple files.")]
        IAllowFileSettings WithColumnNames(string columnNames);
        [Settings(Description = "Add column names to the column name list using the supplied array. One column per element. Use this to add headers for multiple files.")]
        IAllowFileSettings WithColumnNames(string[] columnNames);
        [Settings(Description = "Each field is contained in quotes (for flat files: csv, txt, prn)")]
        IAllowFileSettings WithColumnsEnclosedInQuotes(bool fieldsEnclosedInQuote = true);
        [Settings(Description = "First line is a column name list (for flat files: csv, txt, prn)")]
        IAllowFileSettings WithFirstLineIsColumnNames(bool firstLineIsHeader = true);
        [Settings(Description = "Ignore first line header list")]
        IAllowFileSettings WithIgnoreFirstLineColumnNames(bool ignoreFirstLine = true);
        [Settings(Description = "Overwrite the file or generate a new filename. Overwrite is default.")]
        IAllowFileSettings WithOverwriteFile(bool overwriteFile = false);
        [Settings(Description = "One column list is defined, use it for all files in the file list.")]
        IAllowFileSettings WithUseSameColumnNamesForAllFiles(bool useHeaderForAllFiles = true);
        [Settings(Description = "Order in which files matched by a wildcard (e.g. *.csv) are added to the file list. Default is Name (alphabetical).")]
        IAllowFileSettings WithFileSortOrder(Enums.FileSortOrder fileSortOrder);
        [Settings(Description = "How Next builds a new unique filename (timestamp, date, or an incrementing counter). Default is CounterPadded.")]
        IAllowFileSettings WithNextFilePattern(Enums.NextFilePattern nextFilePattern = Enums.NextFilePattern.CounterPadded);
    }
    public interface IAllowFileActions
    {
        [Action(Description = "Copy the defined GPALFile(s) to a destination file or directory")]
        void CopyTo(string destination);
        [Action(Description = "Move the defined GPALFile(s) to a destination file or directory")]
        void MoveTo(string destination);
        [Action(Description = "Delete the destination file or files (wildcard) or all in the directory (no filename)")]
        void Delete(string destination);
        [Action(Description = "Delete the defined GPALFile underlying file(s)")]
        void Delete();
    }
    public interface IAllowFileName : IAllowToGPALObject<GPALFile>
    {
        [Settings(Description = "Add a filename to the GPALFile list. Actual output filenames added to end.")]
        IAllowFileSettings WithFileName(string filename);   // a wildcard pattern expands to the matching files; an http/https url is fetched to a local file and used from there
        [Settings(Description = "A browser already holding the session a url needs. Set before .WithFileName. GPAL tries its own connection first and falls back to this browser, downloading in a new tab.")]
        IAllowFileSettings WithBrowser(Browser.IBrowser browser);
    }
    #endregion <File Interfaces>
    #region Grid
    public interface IGPALGrid<T> : IAllowGridActions<T>, IEnumerable<List<T>> // , ICloneable
    {
        List<T> ToList();
        [Settings(Description = "Enable duplicate-row detection for this grid when it is passed into GetGrid (off by default).")]
        IGPALGrid<T> WithDedupeData(bool useDedupe = true);
    }
    public interface IAllowGridActions<T> : IAllowToGPALObject<IGPALGrid<T>>
    {
        IAllowGridActions<T> Add(IGPALGrid<T> grid);
        IAllowGridActions<T> AddRow(List<T> row);
        IAllowGridActions<T> AddColumn(List<T> column);
        int Rows { get; }
        int Columns { get; }
        IAllowGridActions<T> AddCell(T value, int row, int column);
        T GetCell(int row, int column);
        IAllowGridActions<T> Clear();
        IAllowGridActions<T> DeleteRow(RowPosition rowPosition = RowPosition.Last);
        IAllowGridActions<T> InputFrom(GPALFile input);
        IAllowGridActions<T> SaveTo(GPALFile output);
        IAllowGridActions<T> InputFrom(IGPALDatabase input);
        IAllowGridActions<T> SaveTo(IGPALDatabase output);
        List<T> this[int index] { get; set; }
        T this[int row, int column] { get; set; }
        int Count();
        bool Contains(T value);
        public object Clone();
    }
    #endregion
    #region <Email Interfaces>
    public interface IGPALMail : IAllowEmailEnvelopeAndActions, IAllowEmailServerSettingsAndName, IAllowNameEnvelopeAndActions, IAllowEmailEnvelope, IAllowToGPALObject<IGPALMail>
    {
        // what a settings file holds, readable so a form can show what LoadSettings brought in
        string SMTPServerName { get; }
        int SMTPPortNum { get; }
        string IMAPServerName { get; }
        int IMAPPortNum { get; }
        string POPServerName { get; }
        int POPPortNum { get; }
        string FromAddress { get; }
    }
    public interface IAllowEmailServerSettings : IAllowToGPALObject<IGPALMail>
    {
        [Settings(Description = "")]
        IAllowEmailServerSettingsAndName WithIMAPServerName(string serverName);
        [Settings(Description = "")]
        IAllowEmailServerSettingsAndName WithIMAPPortNum(int portNum);
        [Settings(Description = "")]
        IAllowEmailServerSettingsAndName WithPOPServerName(string serverName);
        [Settings(Description = "")]
        IAllowEmailServerSettingsAndName WithPOPPortNum(int portNum);
        [Settings(Description = "")]
        IAllowEmailServerSettingsAndName WithSMTPServerName(string serverName);
        [Settings(Description = "")]
        IAllowEmailServerSettingsAndName WithSMTPPortNum(int portNum);
        [Settings(Description = "The credential to authenticate with, whose username and password win over WithUserName and WithPassword")]
        IAllowEmailServerSettingsAndName WithCredentials(ICredentials credentials);
        [Settings(Description = "")]
        IAllowEmailServerSettingsAndName WithUserName(string userName);
        [Settings(Description = "")]
        IAllowEmailServerSettingsAndName WithPassword(string password);
    }
    public interface IAllowEmailActions
    {
        [Action(Description = "")]
        IAllowEmailEnvelopeAndActions Send();
        [Action(Description = "")]
        IAllowEmailEnvelopeAndActions Receive();
        [Action(Description = "Read the mail and hand back the messages")]
        IAllowEmailEnvelopeAndActions Receive(out List<ReceivedEmail> receivedEmails);
        [Action(Description = "Write every attachment on every message received into the given directory")]
        IAllowEmailEnvelopeAndActions SaveTo(GPALFile directory);
        [Action(Description = "Mark every message Receive collected as read on the server, in one connection. IMAP only.")]
        IAllowEmailEnvelopeAndActions MarkAllAsRead();
        [Action(Description = "Delete every message Receive collected from the server, in one connection. IMAP only.")]
        IAllowEmailEnvelopeAndActions DeleteAll();
        [Action(Description = "")]
        IAllowEmailEnvelopeAndActions Clear();
        [Action(Description = "")]
        IAllowEmailEnvelopeAndActions LoadSettings(GPALFile mailSettingsFile = null);
        [Action(Description = "")]
        IAllowEmailEnvelopeAndActions SaveSettings(GPALFile mailSettingsFile = null);
    }
    public interface IAllowEmailEnvelope
    {
        IAllowNameEnvelopeAndActions WithFromEmailAddress(string mailAddress);
        [Settings(Description = "")]
        IAllowNameEnvelopeAndActions WithToEmailAddress(string mailAddress);
        [Settings(Description = "")]
        IAllowNameEnvelopeAndActions WithCcEmailAddress(string mailAddress);
        [Settings(Description = "")]
        IAllowNameEnvelopeAndActions WithBccEmailAddress(string mailAddress);
        [Settings(Description = "")]
        IAllowNameEnvelopeAndActions WithToEmailAddress(string[] emailParts);
        [Settings(Description = "")]
        IAllowNameEnvelopeAndActions WithCcEmailAddress(string[] emailParts);
        [Settings(Description = "")]
        IAllowNameEnvelopeAndActions WithBccEmailAddress(string[] emailParts);
        [Settings(Description = "")]
        IAllowEmailEnvelopeAndActions WithAttachment(GPALFile attachmentFile);
        [Settings(Description = "")]
        IAllowEmailEnvelopeAndActions WithBody(string bodyText);
        [Settings(Description = "")]
        IAllowEmailEnvelopeAndActions WithSubject(string subject);
    }
    public interface IAllowEmailReceiveOptions
    {
        [Settings(Description = "Fetch only the messages the server still has as unread. Every message when false, which is the default.")]
        IAllowEmailEnvelopeAndActions WithUnreadOnly(bool unreadOnly);
        [Settings(Description = "The most messages one Receive may fetch, newest first. Every message by default.")]
        IAllowEmailEnvelopeAndActions WithMaxMessages(int maxMessages);
    }
    public interface IAllowName { IAllowEmailEnvelopeAndActions WithName(string name); }
    public interface IAllowNameEnvelopeAndActions : IAllowName
        , IAllowEmailEnvelope
        , IAllowEmailReceiveOptions
        , IAllowEmailActions
        , IAllowToGPALObject<IGPALMail>
    { }
    public interface IAllowEmailEnvelopeAndActions : IAllowEmailEnvelope
        , IAllowEmailReceiveOptions
        , IAllowEmailActions
        , IAllowToGPALObject<IGPALMail>
    { }
    public interface IAllowEmailServerSettingsAndName : IAllowToGPALObject<IGPALMail>
        , IAllowEmailServerSettings
        , IAllowEmailEnvelope
        , IAllowEmailReceiveOptions
    { }
    #endregion <Email Interfaces>
    #region Logger
    public interface IGPALLogger : IAllowLoggingSettings, IAllowLoggingAndSetting, IAllowToGPALObject<IGPALLogger>
    {
        // where the last entry was written, which is the logger's answer rather than the workflow's guess
        string LogDirectory { get; }
        string LogFilename { get; }
        string LogFullPath { get; }
    }
    public interface IAllowLoggingSettings : IAllowToGPALObject<IGPALLogger>
    {
        [Settings(Description = "")]
        IAllowLoggingSettings WithDatabase(GPALDatabase database);
        [Settings(Description = "")]
        IAllowLoggingSettings WithRootDirectory(string path);
        [Settings(Description = "")]
        IAllowLoggingSettings WithDirectoryStructure(DirectoryStructure type);
        [Settings(Description = "")]
        IAllowLoggingSettings WithFilename(string name);
        [Settings(Description = "")]
        IAllowLoggingSettings WithFilenamePattern(FilenamePattern pattern);
        [Settings(Description = "Which event types this logger writes, published or called directly. Defaults to all")]
        IAllowLoggingAndSetting WithLogEventTypes(GPALEventType logEventTypes);
        [Settings(Description = "")]
        IAllowLoggingAndSetting WithLogType(Enums.LogType logType);
        [Settings(Description = "")]
        IAllowLoggingAndSetting WithDelimiter(char delimiter);
        [Settings(Description = "")]
        IAllowLoggingAndSetting WithLoggingFormat(LogDateFormat logDateFormat);
        [Settings(Description = "")]
        IAllowLoggingAndSetting WithLogDateAsAttribute(bool logDateAsAttribute);
    }
    // no Log here any more: an entry is raised by publishing an event, and a logger is where events land
    public interface IAllowLoggingAndSetting : IAllowLoggingSettings
    { }
    #endregion Logger
    #region Excel
    // Core operations
    public interface IAllowExcelCore
    {
        IAllowExcelOperations SaveTo(GPALFile gpalFile);
        IAllowExcelOperations SaveTo(IGPALGrid<string> grid);
        IAllowExcelOperations SaveTo(int sheetIndex);
        IAllowExcelOperations SaveTo(string sheetName);
        void Close(bool saveOnClose);
    }
 
    // File selection state
    public interface IAllowExcelFileSelection : IAllowExcelCore
    {
        IAllowExcelSheetSelection WithFile(GPALFile gpalFile);
    }
 
    // Sheet selection state
    public interface IAllowExcelSheetSelection : IAllowExcelCore, IAllowToGPALObject<IGPALExcel>
    {
        IAllowExcelOperations WithSheet(int sheetIndex);
        IAllowExcelOperations WithSheet(string sheetName);
    }
 
    // Comparison results state
    public interface IAllowExcelCompareSettings
    {
        IAllowExcelOperations CompareToGrid(IGPALGrid<string> grid);
        IAllowExcelOperations CompareToFile(GPALFile gpalFile);
        IAllowExcelOperations CompareToRange(string range);
    }
 
    // General operations state
    public interface IAllowExcelOperations : IAllowExcelSheetSelection, IAllowExcelCompareSettings
    {
        IAllowExcelOperations WithRange(string range);
        IAllowExcelOperations WriteRange(string range);
        IAllowExcelOperations ClearRanges();
        IAllowExcelCellSettings WithCell(string cell);
        IAllowExcelSearchAndReplaceSettings WithSearchValue(string value);
        IAllowExcelOperations WithColumn(string column);
        IAllowExcelOperations WithRowNumber(int rowNumber);
        IAllowExcelOperations CalculateSum(out string result);
        IAllowExcelOperations CalculateCount(out string result);
        IAllowExcelOperations GetCompareResults(out IGPALGrid<string> results);
    }
 
    // Cell operations state
    public interface IAllowExcelCellSettings : IAllowExcelCore
    {
        IAllowExcelCellSettings WithInsertPosition(int position);
        IAllowExcelCellSettings WithInsertSeparator(string separator);
        IAllowExcelOperations InsertValue(string value);
        IAllowExcelOperations SetValue(string value);
        IAllowExcelOperations AppendValue(string value);
        IAllowExcelOperations PrependValue(string value);
    }
 
    // Search and replace settings state
    public interface IAllowExcelSearchAndReplaceSettings
    {
        IAllowExcelOperations ReplaceWith(string value);
    }
 
    // Unified interface
    public interface IGPALExcel : IAllowExcelFileSelection, IAllowExcelSheetSelection, IAllowExcelOperations, IAllowExcelCellSettings, IAllowExcelSearchAndReplaceSettings, IAllowExcelCompareSettings, IAllowToGPALObject<IGPALExcel>
    {
    }
    #endregion Excel
    #region Launcher
    // written by Grok
    public interface IAllowExecutableSetup : IAllowToGPALObject<Launcher>
    {
        IAllowExecutableSetup WithExecutable(string executable);
        IAllowExecutableSetup WithArgument(string argument);
        IAllowExecutableSetup WithName(string argument);
        IAllowRunningExecutable Launch();
    }
 
    // Post-launch: Running state
    public interface IAllowRunningExecutable : IAllowToGPALObject<Launcher>, IAllowWaitingExecutable
    {
        IAllowRunningExecutable RedirectOutput(Action<string> outputHandler);
        IAllowRunningExecutable RedirectError(Action<string> errorHandler);
        IAllowRunningExecutable SetWorkingDirectory(string directory);
        IAllowRunningExecutable SetEnvironmentVariable(string name, string value);
        IAllowRunningExecutable IsRunning();
        IAllowWaitingExecutable WaitForExit(int milliseconds);
    }
 
    // Post-wait/exit: Limited to termination
    public interface IAllowWaitingExecutable
    {
        void Kill();
        void KillTree();
    }
    #endregion Launcher
    #region REST
    // generated by grok
    public interface IAllowRESTEndpoint
    {
        IAllowRESTEndpointDetails WithAPIBase(string url);
        IAllowRESTEndpointDetails WithAPIBase(string url, TimeSpan httpTimeout);
        IAllowRESTEndpointDetails LoadOpenAPIMap(string yamlOrUrl);
        IAllowRESTEndpointDetails LoadOpenAPIMap(GPALFile openSpiMapFile);
    }
 
    public interface IAllowRESTEndpointDetails : IAllowRESTExecution, IAllowRESTParameters, IAllowToGPALObject<IRESTClient>
    {
        IAllowRESTParametersOrExecution WithEndpoint(string endpoint);
        IAllowRESTParametersOrExecution WithEndpoint(ApiEndpoint endpoint);
        IAllowRESTParametersOrExecution WithResultName(string name);
        IAllowRESTEndpointDetails WithName(string name);
        IAllowRESTEndpointDetails ListOpenAPIEndPoints();
    }
 
    public interface IAllowRESTParametersOrExecution : IAllowRESTParameters, IAllowRESTExecution, IAllowRESTScrollElement, IAllowCheckNetworkIdleOrExecution, IAllowRestMethods
    {
        IAllowRESTParametersOrExecution WithUrl(string url);
        IAllowRESTParametersOrExecution WithUrlFromResult(int resultIndex);
        IAllowRESTParametersOrExecution WithUrlFromResult(string name);
        IAllowRESTParametersOrExecution WithTabId(int tabId);
        IAllowRESTParametersOrExecution WithTabIdFromResult(int resultIndex);
        IAllowRESTParametersOrExecution WithTabIdFromResult(string name);
        IAllowRESTParametersOrExecution WithWindowId(int windowId);
        IAllowRESTParametersOrExecution WithWindowIdFromResult(int resultIndex);
        IAllowRESTParametersOrExecution WithWindowIdFromResult(string name);
        IAllowRESTStorageOptions WithStorageType(WebsiteStorageType storageType);
        IAllowRESTParametersOrExecution WithKey(string key);
        IAllowRESTParametersOrExecution WithKeyFromResult(int resultIndex);
        IAllowRESTParametersOrExecution WithKeyFromResult(string name);
        IAllowRESTParametersOrExecution WithCss(string css);
        IAllowRESTParametersOrExecution WithCssFromResult(int resultIndex);
        IAllowRESTParametersOrExecution WithCssFromResult(string name);
        IAllowRESTParametersOrExecution WithElement(IGPALElement gPALElement);
        IAllowRESTParametersOrExecution WithXPath(string xpath);
        IAllowRESTParametersOrExecution WithXPathFromResult(int resultIndex);
        IAllowRESTParametersOrExecution WithXPathFromResult(string name);
        IAllowRESTParametersOrExecution WithPixels(int pixels);
        IAllowRESTParametersOrExecution WithPixelsFromResult(int resultIndex);
        IAllowRESTParametersOrExecution WithPixelsFromResult(string name);
        IAllowRESTParametersOrExecution WithReferrer(string referrer);
        IAllowRESTParametersOrExecution WithReferrerFromResult(int resultIndex);
        IAllowRESTParametersOrExecution WithReferrerFromResult(string name);
        IAllowRESTExecution WithText(string text);
        IAllowRESTExecution WithTextFromResult(int resultIndex);
        IAllowRESTExecution WithTextFromResult(string name);
        IAllowRESTParametersOrExecution DownloadTo(GPALFile file);
        IAllowRESTParametersOrExecution SaveResultsTo(GPALFile file);
        IAllowRESTParametersOrExecution WithElementId(string elementId);
        IAllowRESTParametersOrExecution WithElementIdFromResult(int resultIndex);
        IAllowRESTParametersOrExecution WithElementIdFromResult(string name);
        IAllowRESTExecution SetValueFrom(string destSelector);
        IAllowRESTScrollElement WithHPixelsFromResult(int resultIndex);
        IAllowRESTScrollElement WithHPixelsFromResult(string name);
        IAllowRESTScrollElement WithVPixelsFromResult(int resultIndex);
        IAllowRESTScrollElement WithVPixelsFromResult(string name);
        IAllowRESTExecution WithDeviceName(string deviceNameOrId);
 
    }
    public interface IAllowRESTMethod
    {
        IAllowRESTExecution WithHttpMethod(string method);
    }
 
    public interface IAllowRangeValue
    {
        IAllowRESTExecution WithRangeValue(int rangeValue);
    }
    public interface IAllowRESTExecution : IAllowRESTMethod
    {
        string Execute(bool publishEvent = true);
        T Execute<T>(bool publishEvent = true);
        IRESTClient AndThen(bool publishEvent = true);
        IRESTClient AndThen<T>(bool publishEvent = true);
        Task<string> ExecuteAsync(bool publishEvent = true);
        Task<T> ExecuteAsync<T>(bool publishEvent = true);
        ResultCollection GetExecutionResults();
        IAllowRESTExecution WithHeader(string name, string value);
    }
 
    public interface IAllowRESTParameters : IAllowRESTExecution
    {
        IAllowRESTParametersOrExecution WithParameters(params object[] parameters);
        IAllowRESTParametersOrExecution WithParameters(object parameters);
        IAllowRESTParametersOrExecution WithParametersFromResult(int resultIndex);
        IAllowRESTParametersOrExecution WithParametersFromResult(string name);
        IAllowRESTParametersOrExecution WithEncoding(Enums.ContentEncoding encoding);
    }
 
    public interface IAllowRESTWorkflow
    {
        IAllowRESTWorkflow WithWorkflow(Action<RESTClient> workflow);
        IAllowRESTParametersOrExecution While(Func<bool> condition);
        IAllowRESTParametersOrExecution Until(Func<bool> condition);
    }
 
    public interface IAllowCheckNetworkIdleOrExecution : IAllowRESTExecution
    {
        IAllowCheckNetworkIdleOrExecution WithTimeoutMs(int timeoutMs);
        IAllowCheckNetworkIdleOrExecution WithPruneMs(int pruneMs);
        IAllowCheckNetworkIdleOrExecution WithMaxConnections(int maxConnections);
    }
 
    public interface IAllowRESTScrollElement : IAllowRESTExecution
    {
        IAllowRESTScrollElement WithHPixels(int hPixels);
        IAllowRESTScrollElement WithVPixels(int vPixels);
    }
 
    public interface IAllowRESTDragAndDrop : IAllowRESTExecution
    {
        IAllowRESTDragAndDrop WithDeltaX(int deltaX);
        IAllowRESTDragAndDrop WithDeltaY(int deltaY);
        IAllowRESTDragAndDrop WithOffsetX(int offsetX);
        IAllowRESTDragAndDrop WithOffsetY(int offsetY);
    }
 
    public interface IAllowRESTAttribute : IAllowRESTExecution
    {
        IAllowRESTAttribute WithAttribute(string attribute);
        IAllowRESTAttribute WithValue(string value);
    }
 
    public interface IAllowRESTInputText
    {
        IAllowRESTExecution WithText(string text);
    }
 
    public interface IAllowSelectOptions
    {
        IAllowRESTExecution WithSelectValue(string value);
        IAllowRESTExecution WithSelectIndex(int index);
    }
    public interface IAllowRESTWithDownloadFilename
    {
        IAllowRESTExecution WithDownloadFile(string downloadPath);
    }
    public interface IAllowRESTWithUploadFilename
    {
        IAllowRESTExecution WithUploadFile(string uploadFilenameAndPath);
        IAllowRESTExecution WithUploadFiles(GPALFile uploadFilenamesAndPaths);
    }
 
    public interface IAllowRESTCaptureOptions : IAllowRESTExecution
    {
        IAllowRESTCaptureOptions WithCallFilter(string urlFragment);
        IAllowRESTCaptureOptions WithClearCalls(bool clear = true);
    }
 
    public interface IAllowRESTStorageOptions : IAllowRESTExecution
    {
        IAllowRESTStorageOptions WithStorageDomain(string domain);
        IAllowRESTStorageOptions WithStoragePath(string path);
        IAllowRESTStorageOptions WithStorageKey(string key);
        IAllowRESTStorageOptions WithStorageStoreName(string storeName);
        IAllowRESTStorageOptions WithData(string data);
        IAllowRESTStorageOptions WithDeleteAcrossOrigins(bool trueFalse);
    }
 
    public interface IAllowRestMethods
    {
        // Single-parameter methods with direct Execute
        IAllowRESTExecution Back();
        IAllowRESTExecution CaptureVisibleTab(ImageFormat imageFormat = ImageFormat.JPEG);
        IAllowRESTExecution CloseTab(GPALUrl url = null);
        IAllowRESTExecution CloseTab(int tabId);
        IAllowRESTExecution CloseWindow(GPALUrl url = null);
        IAllowRESTExecution CloseBrowser();
        IAllowRESTExecution CloseWindow(int tabId);
        IAllowRESTStorageOptions DeleteStorage(WebsiteStorageType storageType);
        IAllowRESTParameters ExecuteJavaScript(string script); // Removed params version as noted
        IAllowRESTParameters InjectScript(string script);
        IAllowRESTParameters ClearInjectedScripts();
        IAllowRESTInputText FillInAppend(string elementId);
        IAllowRESTInputText FillInInsert(string elementId);
        IAllowRESTInputText FillInOverwrite(string elementId);
        IAllowRESTExecution Forward();
        IAllowRESTExecution FullScreen();
        IAllowRESTExecution GetReadyStatus();
        IAllowRESTExecution CheckNetworkIdle(int maxConnections = 0);
        IAllowRESTExecution GetShadowRoot(string css);
        IAllowRESTStorageOptions GetStorage(WebsiteStorageType storageType);
        IAllowRESTExecution GetCurrentUrl();
        IAllowRESTExecution GetCurrentWindow();
        IAllowRESTExecution GetOptions(string elementId);
        IAllowRESTExecution GetLanguages();
        IAllowRESTCaptureOptions CaptureCalls(bool capture = true);
        IAllowRESTExecution GetCapturedCalls();
        IAllowRESTExecution GetUserAgent();
        IAllowRESTExecution GoTo(GPALUrl url);
        IAllowRESTExecution GoToTab(GPALUrl url);
        IAllowRESTExecution GoToTab(int tabId);
        IAllowRESTExecution GoToWindow(GPALUrl url);
        IAllowRESTExecution GoToWindow(int tabId);
        IAllowRESTExecution Maximize();
        IAllowRESTExecution Minimize();
        IAllowRESTExecution MoveTo(string elementId);
        IAllowRESTExecution NewTab(GPALUrl url = null);
        IAllowRESTExecution NextTab();
        IAllowRESTExecution TabCount();
        IAllowRESTExecution NextWindow();
        IAllowRESTExecution Normal();
        IAllowRESTExecution OpenWindow(GPALUrl url = null);
        IAllowRESTExecution OverrideReferrer(string referrer);
        IAllowRESTExecution PageDown(int pagesToScroll = 1);
        IAllowRESTExecution PageEnd();
        IAllowRESTExecution PageTop();
        IAllowRESTExecution PageUp(int pagesToScroll = 1);
        IAllowRESTExecution PressModifierKey(ModifierKeys modifierKeys);
        IAllowRESTExecution PreviousTab();
        IAllowRESTExecution PreviousWindow();
        IAllowRESTExecution Refresh();
        IAllowRESTExecution ReleaseModifierKey(ModifierKeys modifierKeys);
        IAllowRESTExecution Restore();
        IAllowRESTExecution ScrollWindowByHorizontal(int pixels);
        IAllowRESTExecution ScrollWindowByVertical(int pixels);
        IAllowRESTExecution SendString(string text, int delayMs = 0);
        IAllowRESTExecution SendKey(byte vkcode);
        IAllowRangeValue SetRange(string elementId);
        IAllowRESTStorageOptions SetStorage(WebsiteStorageType storageType);
        IAllowRESTExecution SetUserAgent(string userAgent);
        IAllowRESTExecution StealthOverrideReferrer();
        IAllowRESTExecution SubmitForm(string elementId);
        IAllowRESTExecution SwitchToDefaultContent();
        IAllowRESTExecution SwitchToElement(string elementId);  // same as switch to iframe
        IAllowRESTExecution SwitchToFrame(string elementId);    // same as switch to element
        IAllowRESTExecution SwitchToShadowRoot(string elementId);
        IAllowRESTExecution GetWorkflow();
        IAllowRESTExecution GetSettings();
        IAllowRESTExecution GetGpalSettings();
        IAllowRESTExecution GetBrowserSettings();
        IAllowRESTExecution FireChangeEvent(string elementId);
        IAllowRESTExecution Focus(string elementId);
        IAllowRESTExecution GetBoundingClientRect(string elementId);
        IAllowRESTExecution ElementFromPoint(string elementId, int x, int y);
        IAllowRESTExecution GetElementAttributeHash(string elementId);
        IAllowRESTExecution GetPageSource();
        IAllowRESTExecution GetParentNode(string elementId);
        IAllowRESTExecution GetContentAndCss(string selector);
        IAllowRESTExecution GetCssAttributes(string selector);
        IAllowRESTExecution GetDomAttributes(string selector);
        IAllowRESTExecution GetDomProperties(string selector);
        IAllowRESTExecution GetWindowRectangle();
        IAllowRESTExecution HideElement(string elementId);
        IAllowRESTExecution IsClickable(string elementId);
        IAllowRESTExecution IsDisplayed(string elementId);
        IAllowRESTExecution IsEnabled(string elementId);
        IAllowRESTExecution IsEndOfPage();
        IAllowRESTExecution IsVisibleInViewport(string elementId);
        IAllowRESTExecution LeftClick(string elementId);
        IAllowRESTWithDownloadFilename RightClickAndDownload(string elementId);
        IAllowRESTWithDownloadFilename LeftClickAndDownload(string elementId);
        IAllowRESTExecution SetDownloadFilename(string downloadPath);
        IAllowRESTWithUploadFilename LeftClickAndUpload(string elementId);
        IAllowRESTExecution LeftDoubleClick(string elementId);
        IAllowRESTExecution MiddleClick(string elementId);
        IAllowRESTExecution RightClick(string elementId);
        IAllowRESTExecution ScrollIntoView(string elementId);
        IAllowRESTExecution WindowInnerHeight();
        IAllowRESTExecution WindowInnerWidth();
        IAllowRESTExecution WindowOuterHeight();
        IAllowRESTExecution WindowOuterWidth();
        IAllowRESTParametersOrExecution Fetch(string url);
        IAllowRESTParametersOrExecution WithVerb(string method);
        IAllowRESTParametersOrExecution WithBody(string body);
        IAllowRESTParametersOrExecution WithContentType(string contentType);
        IAllowRESTParametersOrExecution WithHeaders(string[] headers);
        IAllowRESTParametersOrExecution WithBytes(bool bytes);
        IAllowRESTExecution WindowPageOffsetX();
        IAllowRESTExecution WindowPageOffsetY();
        IAllowRESTExecution WindowScreenLeft();
        IAllowRESTExecution WindowScreenTop();
        IAllowRESTExecution Hover(string elementId);
        IAllowRESTExecution EvaluatePersistent(string xpath);
        IAllowRESTExecution EvaluateAllPersistent(string xpath);
        IAllowRESTExecution QueryPersistentSelector(string css);
        IAllowRESTExecution QueryPersistentSelectors(string css);
        IAllowRESTExecution Evaluate(string xpath);
        IAllowRESTExecution EvaluateAll(string xpath);
        IAllowRESTExecution QuerySelector(string css);
        IAllowRESTExecution QuerySelectors(string css);
        IAllowRESTExecution ScrollWindow(int hPixels, int vPixels);
        IAllowRESTExecution TopBrowser();
        IAllowRESTExecution ClearReferrer();
 
 
        // Multi-parameter methods with fluent steps
        IAllowSelectOptions SelectClick(string elementId);
        IAllowRESTAttribute SetAttribute(string elementId);
        IAllowRESTScrollElement ScrollElement(string elementId);
        IAllowRESTExecution ScrollElement(int hPixels, int vPixels);
        IAllowRESTDragAndDrop DragAndDrop(string elementId);
        IAllowRESTAttribute GetAttribute(string elementId); // Returns IAllowRESTAttribute, skips WithValue
    }
 
    public interface IRESTClient : IAllowRESTEndpoint, IAllowRESTEndpointDetails, IAllowRESTMethod, IAllowRESTScrollElement, IAllowRESTDragAndDrop, IAllowRESTExecution, IAllowRESTParametersOrExecution
        , IAllowCheckNetworkIdleOrExecution, IAllowRESTAttribute, IAllowRESTParameters, IAllowRESTInputText, IAllowRESTWorkflow, IAllowSelectOptions
        , IAllowRESTWithDownloadFilename, IAllowRESTWithUploadFilename, IAllowRESTStorageOptions, IAllowRESTCaptureOptions, IAllowRangeValue, IAllowRestMethods, IAllowToGPALObject<IRESTClient>
    {
        string Name { get; }
    }
    #endregion REST
    #region GPALElement
    public interface IGPALElement
    {
        // Complete element contract. These were previously reached only by inheriting Selenium's
        // IWebElement, which leaked a Selenium reference onto every consumer. GPALElement implements
        // all of them natively, and every signature uses GPAL/BCL types only, never a Selenium type.
        // Consumers program against IGPALElement and cast to GPALElement only for the plumbing
        // (WrappedDriver, WebElement, node ids, ToDictionary, Dispose).
        string TagName { get; }
        string Text { get; }
        bool Enabled { get; }
        bool Selected { get; }
        bool Displayed { get; }
        Point Location { get; }
        Size Size { get; }
        string GetAttribute(string attributeName);
        void SetAttribute(string attributeName, string value);
        string GetCssValue(string propertyName);
        string GetDomAttribute(string attributeName);
        string GetDomProperty(string propertyName);
        void Click();
        void Click(ModifierKeys modifierKeys);
        void MiddleClick(ModifierKeys modifierKeys = ModifierKeys.NONE);
        void Clear();
        void SendKeys(string text);
        void Submit();
        void Hide();
        Dictionary<string, object> Attributes { get; }
        Dictionary<string, object> CssAttributes { get; }
        Dictionary<string, object> DomAttributes { get; }
        Dictionary<string, object> DomProperties{ get; }
        string AttributeName { get; }
        string Href { get; }
        string Src { get; }
        string Value { get; }
        string Placeholder { get; }
        string Xpath { get; }
        XPathInfo[] Xpaths { get; }
        string Css { get; }
        string FullXPath { get; }
        //string SelectorName { get; set; }
        //int OffsetX { get; set; }
        //int OffsetY { get; set; }
        //int DeltaX { get; set; }
        //int DeltaY { get; set; }
        //string ImageData { get; set; }
        ClientRectangle BoundingRect { get; }
        string PageURL { get;  }
        GPALElement ShadowRoot { get; }
        dynamic WebElement { get; }
        bool IsClickable(bool publishEvent = true);
        bool IsDisabled();
        bool IsEnabled();
 
    }
    #endregion GPALElement
    #region Cryptography
    public interface IAllowCryptoGenerateIV
    {
        IAllowCryptoConfig GenerateIV(out byte[] iv);
    }
 
    public interface IAllowCryptoInput
    {
        IAllowCryptoAction WithInputData(byte[] data);
    }
 
    public interface IAllowCryptoEncrypt
    {
        IAllowCryptoConfig Encrypt(out byte[] encryptedData);
    }
 
    public interface IAllowCryptoDecrypt
    {
        IAllowCryptoConfig Decrypt(out string decryptedValue);
    }
 
    public interface IAllowCryptoSign
    {
        IAllowCryptoConfig Sign(out byte[] signature);
    }
 
    public interface IAllowCryptoVerify
    {
        IAllowCryptoConfig Verify(out bool isValid);
    }
 
    public interface IAllowCryptoHash
    {
        IAllowCryptoConfig Hash(out byte[] hash);
    }
 
    public interface IAllowCryptoGenerateKey
    {
        IAllowCryptoConfig GenerateKey(out byte[] key);
    }
 
    public interface IAllowCryptoConfig :
        IAllowCryptoInput,
        IAllowCryptoGenerateIV,
        IAllowCryptoGenerateKey,
        IAllowCryptoAction
    {
        IAllowCryptoConfig WithAlgorithm(CryptoAlgorithm alg);
        IAllowCryptoConfig WithKey(byte[] key);
        IAllowCryptoConfig WithIV(byte[] iv);
        IAllowCryptoConfig WithMode(CryptoMode mode);
        IAllowCryptoConfig WithPadding(CryptoPadding padding);
        IAllowCryptoConfig WithSalt(byte[] salt);
        IAllowCryptoConfig WithIterationCount(int count);
        IAllowCryptoConfig WithSignature(byte[] signature);
    }
 
    public interface IAllowCryptoKeyGenInput :
        IAllowCryptoInput,
        IAllowCryptoGenerateKey
    {
    }
 
    public interface IAllowCryptoAction :
        IAllowCryptoGenerateKey,
        IAllowCryptoGenerateIV,
        IAllowCryptoEncrypt,
        IAllowCryptoDecrypt,
        IAllowCryptoSign,
        IAllowCryptoVerify,
        IAllowCryptoHash
    {
    }
 
    public interface ICryptography : IAllowCryptoAction, IAllowCryptoKeyGenInput, IAllowCryptoConfig, IAllowToGPALObject<ICryptography>
    {
    }
    #endregion Cryptography
    #region Gherkin
    public interface IAllowGiven
    {
        IAllowWhen Given(Action step);
        IAllowWhen Given<T1>(Action<T1> step, T1 arg1);
        IAllowWhen Given<T1, T2>(Action<T1, T2> step, T1 arg1, T2 arg2);
        IAllowWhen Given<T1, T2, T3>(Action<T1, T2, T3> step, T1 arg1, T2 arg2, T3 arg3);
    }
 
    public interface IAllowWhen
    {
        IAllowAnd When(Action step);
        IAllowAnd When<T1>(Action<T1> step, T1 arg1);
        IAllowAnd When<T1, T2>(Action<T1, T2> step, T1 arg1, T2 arg2);
        IAllowAnd When<T1, T2, T3>(Action<T1, T2, T3> step, T1 arg1, T2 arg2, T3 arg3);
    }
 
    public interface IAllowAnd
    {
        IAllowThen And(Action step);
        IAllowThen And<T1>(Action<T1> step, T1 arg1);
        IAllowThen And<T1, T2>(Action<T1, T2> step, T1 arg1, T2 arg2);
        IAllowThen And<T1, T2, T3>(Action<T1, T2, T3> step, T1 arg1, T2 arg2, T3 arg3);
    }
 
    public interface IAllowThen : IAllowAnd
    {
        IAllowThen Then(Action step);
        IAllowThen Then<T1>(Action<T1> step, T1 arg1);
        IAllowThen Then<T1, T2>(Action<T1, T2> step, T1 arg1, T2 arg2);
        IAllowThen Then<T1, T2, T3>(Action<T1, T2, T3> step, T1 arg1, T2 arg2, T3 arg3);
    }
    #endregion Gherkin
    #region <Request Settings>
    [Interface(Description = "Describe an API request for .Fetch to issue from inside the page")]
    public interface IAllowRequestSettings : IAllowToGPALObject<GPALRequest>
    {
        [Settings(Description = "Replace a query parameter's value with the next numbered token")]
        IAllowRequestSettings WithTokenFor(string parameterName);
        [Settings(Description = "Path or full URL to request. A path rides the origin the browser is already on")]
        IAllowRequestSettings WithPath(string path);
        [Settings(Description = "HTTP method, for example GET, POST, PUT, DELETE. [GET (default)]")]
        IAllowRequestSettings WithHttpMethod(Enums.HttpVerb method);
        [Settings(Description = "Add a query parameter written as \"name=value\". Call once per parameter")]
        IAllowRequestSettings WithParameter(string nameValue);
        [Settings(Description = "Add a request header written as \"Name: value\". Call once per header")]
        IAllowRequestSettings WithHeader(string nameValue);
        [Settings(Description = "Body to send, used as-is")]
        IAllowRequestSettings WithBody(string body);
        [Settings(Description = "Content type of the body. [application/json (default)]")]
        IAllowRequestSettings WithContentType(Enums.ContentType contentType);
        [Settings(Description = "What this API calls its first page, which the page token counts on from. [0 (default)]")]
        IAllowRequestSettings WithFirstPage(int firstPage);
        [Settings(Description = "The marker replaced with the page number, wherever it appears in the path, a parameter value, a header value or the body. Give it a numbered token to hand GPAL one of the token positions. [{page} (default)]")]
        IAllowRequestSettings WithPageToken(string token = "{page}");
        [Settings(Description = "Handler called after each row of tokens is fetched, with that row's pages. Return -1 to stop")]
        IAllowRequestSettings CallAfterFetch(Browser.Browser.CallAfterFetchDelegate callAfterFetch);
        [Settings(Description = "Name of request (used in messages and errors)")]
        IAllowToGPALObject<GPALRequest> WithName(string name);
    }
    #endregion <Request Settings>
    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();
    }
 
    #region YouTube
    public interface IGPALYouTube
    {
        // Upload phase
        IGPALYouTube WithCredentials(ICredentials credentials);
        IGPALYouTube WithTitle(string title);
        IGPALYouTube WithDescription(string description);
        IGPALYouTube WithTags(params string[] tags);
        IGPALYouTube WithPrivacy(Enums.YouTubePrivacy privacy);
        IGPALYouTube WithCategory(Enums.YouTubeCategory category);
        Browser.YouTubeUploadResult Upload(GPALFile file);
        // Schedule phase: collect upload results, set poll interval, then ScheduleAt fires a background thread
        IGPALYouTube WithVideo(Browser.YouTubeUploadResult result);
        IGPALYouTube WithVideos(IEnumerable<Browser.YouTubeUploadResult> results);
        IGPALYouTube WaitForProcessing(int pollIntervalSeconds = 60);
        IGPALYouTube WithOutputTo(System.Windows.Forms.TextBoxBase control);
        IGPALYouTube ScheduleAt(Browser.PremiereTime premiereTime);
        void WaitForCompletion();
        // Playlist phase
        IGPALYouTube WithPlaylist(string playlistId);
        Browser.YouTubePlaylistResult CreatePlaylist();
        IGPALYouTube AddToPlaylist(string playlistId);
        // Lookup / Search phase
        IGPALYouTube WithVideoId(string videoId);
        IGPALYouTube WithSearchTerms(string query);
        IGPALYouTube WithSearchTerms(IGPALGrid<string> grid);
        IGPALYouTube GetResults(out Browser.YouTubeVideoInfo info);
        IGPALYouTube GetResults(out System.Collections.Generic.List<Browser.YouTubeVideoInfo> results);
    }
    #endregion YouTube
 
}