{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-missing-role-annotations #-}
{-# OPTIONS_GHC -Wno-orphans #-}

-- |
-- Module      : Effectful.Marionette
-- Copyright   : (c) 2026 Institute for Digital Autonomy
-- License     : EUPL-1.2
-- Maintainer  : IDA
--
-- <https://firefox-source-docs.mozilla.org/testing/marionette/ Marionette> is
-- Firefox's built-in remote-control protocol. It plays the same role as a
-- <https://www.w3.org/TR/webdriver/ WebDriver> server, letting a test suite
-- drive a real Firefox instance to navigate, find and interact with
-- elements, execute scripts, and so on. In addition to WebDriver functionality,
-- Marionette can also address Firefox's own chrome (its menus and toolbars)
-- rather than just the content of a web page, and speaks its own lightweight
-- length-prefixed JSON protocol directly over a TCP socket instead of
-- HTTP.
--
-- This module lifts every command from the
-- <https://hackage.haskell.org/package/marionette marionette> library into
-- the 'Eff' monad as a 'Marionette' effect. Run 'runMarionette' to open the
-- connection and discharge that effect for the duration of your action.
--
-- = How to use Marionette
--
-- === Starting Firefox and a session
--
-- Launch Firefox with the @--marionette@ flag so that it listens for
-- connections on port 2828.
--
-- Use 'runMarionette' to connect to it and run a client program.
-- Start a new session with 'newSession', and quit the session with 'deleteSession':
--
-- > import Effectful
-- > import Effectful.Marionette
-- > import Effectful.Process.Typed
-- > import System.Process.Typed (proc)
-- >
-- > main :: IO ()
-- > main =
-- >   runEff . runTypedProcess $
-- >     withProcessTerm_ (proc "firefox" ["--marionette", "--headless"]) \_process ->
-- >       runMarionette $ do
-- >         newSession
-- >         quit
--
-- === Finding and interacting with elements
--
-- Find elements by calling 'findElement' with a 'Selector',
-- then pass the resulting 'Element' to other commands:
--
-- > submitForm :: (HasCallStack, Marionette :> es) => Eff es ()
-- > submitForm = do
-- >   input <- findElement (ById "text-input")
-- >   elementSendKeys input "hello, world"
-- >   submit <- findElement (ByCSS "button[type=submit]")
-- >   elementClick submit
--
-- === Error handling
--
-- Catch command failures with 'Control.Monad.Error.Class.catchError',
-- for example to retry a command against a fallback element:
--
-- > import Control.Monad.Error.Class (catchError)
-- >
-- > clickFirstAvailable :: (HasCallStack, Marionette :> es) => Eff es ()
-- > clickFirstAvailable =
-- >   (elementClick =<< findElement (ById "primary-button"))
-- >     `catchError` \_ -> elementClick =<< findElement (ById "fallback-button")
module Effectful.Marionette
    ( module Effectful.Marionette
    , AccessibilityProperties (..)
    , AuthenticatorId (..)
    , Context (..)
    , Cookie (..)
    , Credential (..)
    , CredentialId (..)
    , Element (..)
    , Frame (..)
    , NewWindowResult (..)
    , Orientation (..)
    , Rect (..)
    , RegistryEntry (..)
    , Selector (..)
    , Shadow (..)
    , Timeouts (..)
    , VirtualAuthenticator (..)
    , WindowHandle (..)
    )
where

import Control.Monad.Catch (MonadThrow (throwM))
import Control.Monad.Error.Class (MonadError (..))
import Data.Aeson (FromJSON, Value)
import Data.ByteString (ByteString)
import Data.Text (Text)
import Effectful
    ( Dispatch (Static)
    , DispatchOf
    , Eff
    , Effect
    , IOE
    , Limit (Limited)
    , MonadIO (liftIO)
    , Persistence (Ephemeral)
    , UnliftStrategy (ConcUnlift)
    , inject
    , runEff
    , withEffToIO
    , (:>)
    )
import Effectful.Concurrent.Async (mapConcurrently, runConcurrent)
import Effectful.Concurrent.STM
    ( Concurrent
    , TMVar
    , TQueue
    , atomically
    , newEmptyTMVarIO
    , readTMVar
    , writeTQueue
    )
import Effectful.Dispatch.Static
    ( SideEffects (WithSideEffects)
    , StaticRep
    , evalStaticRep
    , getStaticRep
    , unsafeEff_
    )
import Effectful.Error.Static (Error, runError)
import Effectful.Error.Static qualified as Error
import Effectful.Reader.Static (Reader, runReader)
import Effectful.Reader.Static qualified as Reader
import GHC.Stack (HasCallStack)
import Test.Marionette
    ( AccessibilityProperties (..)
    , AuthenticatorId (..)
    , Context (..)
    , Cookie (..)
    , Credential (..)
    , CredentialId (..)
    , Element (..)
    , Frame (..)
    , NewWindowResult (..)
    , Orientation (..)
    , Rect (..)
    , RegistryEntry (..)
    , Selector (..)
    , Shadow (..)
    , Timeouts (..)
    , VirtualAuthenticator (..)
    , WindowHandle (..)
    )
import Test.Marionette qualified as Marionette
import Test.Marionette.Client
import Test.Marionette.Protocol qualified as Marionette
import Prelude

instance {-# OVERLAPPING #-} (Error Marionette.Error :> es) => MonadError Marionette.Error (Eff es) where
    throwError :: forall a. Error -> Eff es a
throwError = Error -> Eff es a
forall e (es :: [Effect]) a.
(HasCallStack, Error e :> es, Show e) =>
e -> Eff es a
Error.throwError
    catchError :: forall a. Eff es a -> (Error -> Eff es a) -> Eff es a
catchError Eff es a
v = Eff es a -> (CallStack -> Error -> Eff es a) -> Eff es a
forall e (es :: [Effect]) a.
(HasCallStack, Error e :> es) =>
Eff es a -> (CallStack -> e -> Eff es a) -> Eff es a
Error.catchError Eff es a
v ((CallStack -> Error -> Eff es a) -> Eff es a)
-> ((Error -> Eff es a) -> CallStack -> Error -> Eff es a)
-> (Error -> Eff es a)
-> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Error -> Eff es a) -> CallStack -> Error -> Eff es a
forall a b. a -> b -> a
const

instance
    ( Concurrent :> es
    , Reader (TQueue CommandWithCallback) :> es
    , Error Marionette.Error :> es
    , IOE :> es
    )
    => Marionette.Marionette (Eff es)
    where
    sendCommand :: forall a. (HasCallStack, FromJSON a) => Command -> Eff es a
sendCommand Command
command = do
        TQueue CommandWithCallback
q <- Eff es (TQueue CommandWithCallback)
forall r (es :: [Effect]).
(HasCallStack, Reader r :> es) =>
Eff es r
Reader.ask
        TMVar Result
result :: TMVar Marionette.Result <- Eff es (TMVar Result)
forall (es :: [Effect]) a. (Concurrent :> es) => Eff es (TMVar a)
newEmptyTMVarIO
        STM () -> Eff es ()
forall (es :: [Effect]) a. (Concurrent :> es) => STM a -> Eff es a
atomically (STM () -> Eff es ())
-> (CommandWithCallback -> STM ())
-> CommandWithCallback
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TQueue CommandWithCallback -> CommandWithCallback -> STM ()
forall a. TQueue a -> a -> STM ()
writeTQueue TQueue CommandWithCallback
q (CommandWithCallback -> Eff es ())
-> CommandWithCallback -> Eff es ()
forall a b. (a -> b) -> a -> b
$ Command -> TMVar Result -> CommandWithCallback
CommandWithCallback Command
command TMVar Result
result
        (Error -> Eff es a)
-> (a -> Eff es a) -> Either Error a -> Eff es a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Error -> Eff es a
forall e (es :: [Effect]) a.
(HasCallStack, Error e :> es, Show e) =>
e -> Eff es a
Error.throwError a -> Eff es a
forall a. a -> Eff es a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
            (Either Error a -> Eff es a) -> Eff es (Either Error a) -> Eff es a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Result -> Eff es (Either Error a)
forall (m :: * -> *) a.
(MonadThrow m, FromJSON a) =>
Result -> m (Either Error a)
Marionette.parseResult
            (Result -> Eff es (Either Error a))
-> Eff es Result -> Eff es (Either Error a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< STM Result -> Eff es Result
forall (es :: [Effect]) a. (Concurrent :> es) => STM a -> Eff es a
atomically (TMVar Result -> STM Result
forall a. TMVar a -> STM a
readTMVar TMVar Result
result)
    sendCommands :: forall (t :: * -> *) a.
(HasCallStack, Traversable t, FromJSON a) =>
t Command -> Eff es (t a)
sendCommands = (Command -> Eff es a) -> t Command -> Eff es (t a)
forall (f :: * -> *) (es :: [Effect]) a b.
(HasCallStack, Traversable f, Concurrent :> es) =>
(a -> Eff es b) -> f a -> Eff es (f b)
mapConcurrently Command -> Eff es a
forall a. (HasCallStack, FromJSON a) => Command -> Eff es a
forall (m :: * -> *) a.
(Marionette m, HasCallStack, FromJSON a) =>
Command -> m a
Marionette.sendCommand

data Marionette :: Effect

type instance DispatchOf Marionette = 'Static 'WithSideEffects

newtype instance StaticRep Marionette = Marionette (TQueue CommandWithCallback)

-- | Connects to a running Firefox instance listening for Marionette
-- connections (started with the @--marionette@ command-line flag), and
-- discharges the 'Marionette' effect for the supplied action.
runMarionette :: (IOE :> es) => Eff (Marionette ': es) a -> Eff es a
runMarionette :: forall (es :: [Effect]) a.
(IOE :> es) =>
Eff (Marionette : es) a -> Eff es a
runMarionette Eff (Marionette : es) a
action =
    UnliftStrategy
-> ((forall r. Eff es r -> IO r) -> IO a) -> Eff es a
forall (es :: [Effect]) a.
(HasCallStack, IOE :> es) =>
UnliftStrategy
-> ((forall r. Eff es r -> IO r) -> IO a) -> Eff es a
withEffToIO (Persistence -> Limit -> UnliftStrategy
ConcUnlift Persistence
Ephemeral (Int -> Limit
Limited Int
1)) \forall r. Eff es r -> IO r
unlift ->
        MarionetteT IO a -> IO a
forall (m :: * -> *) a.
(MonadUnliftIO m, MonadMask m) =>
MarionetteT m a -> m a
runMarionetteT do
            TQueue CommandWithCallback
sendQueue <- MarionetteT IO (TQueue CommandWithCallback)
forall (m :: * -> *).
Monad m =>
MarionetteT m (TQueue CommandWithCallback)
Marionette.getSendQueue
            IO a -> MarionetteT IO a
forall a. IO a -> MarionetteT IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> MarionetteT IO a)
-> (Eff (Marionette : es) a -> IO a)
-> Eff (Marionette : es) a
-> MarionetteT IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Eff es a -> IO a
forall r. Eff es r -> IO r
unlift (Eff es a -> IO a)
-> (Eff (Marionette : es) a -> Eff es a)
-> Eff (Marionette : es) a
-> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StaticRep Marionette -> Eff (Marionette : es) a -> Eff es a
forall (e :: Effect) (sideEffects :: SideEffects) (es :: [Effect])
       a.
(HasCallStack, DispatchOf e ~ 'Static sideEffects,
 MaybeIOE sideEffects es) =>
StaticRep e -> Eff (e : es) a -> Eff es a
evalStaticRep (TQueue CommandWithCallback -> StaticRep Marionette
Marionette TQueue CommandWithCallback
sendQueue) (Eff (Marionette : es) a -> Eff es a)
-> (Eff (Marionette : es) a -> Eff (Marionette : es) a)
-> Eff (Marionette : es) a
-> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Eff (Marionette : es) a -> Eff (Marionette : es) a
forall (subEs :: [Effect]) (es :: [Effect]) a.
Subset subEs es =>
Eff subEs a -> Eff es a
inject (Eff (Marionette : es) a -> MarionetteT IO a)
-> Eff (Marionette : es) a -> MarionetteT IO a
forall a b. (a -> b) -> a -> b
$ Eff (Marionette : es) a
action

m
    :: (HasCallStack, Marionette :> es')
    => Eff
        '[ Concurrent
         , Reader (TQueue CommandWithCallback)
         , Error Marionette.Error
         , IOE
         ]
        a
    -> Eff es' a
m :: forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
action = do
    Marionette TQueue CommandWithCallback
sendQueue <- Eff es' (StaticRep Marionette)
forall (e :: Effect) (sideEffects :: SideEffects) (es :: [Effect]).
(HasCallStack, DispatchOf e ~ 'Static sideEffects, e :> es) =>
Eff es (StaticRep e)
getStaticRep
    ((CallStack, Error) -> Eff es' a)
-> (a -> Eff es' a) -> Either (CallStack, Error) a -> Eff es' a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Error -> Eff es' a
forall e a. (HasCallStack, Exception e) => e -> Eff es' a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM (Error -> Eff es' a)
-> ((CallStack, Error) -> Error) -> (CallStack, Error) -> Eff es' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CallStack, Error) -> Error
forall a b. (a, b) -> b
snd) a -> Eff es' a
forall a. a -> Eff es' a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
        (Either (CallStack, Error) a -> Eff es' a)
-> Eff es' (Either (CallStack, Error) a) -> Eff es' a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ( IO (Either (CallStack, Error) a)
-> Eff es' (Either (CallStack, Error) a)
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_
                (IO (Either (CallStack, Error) a)
 -> Eff es' (Either (CallStack, Error) a))
-> (Eff
      '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
        IOE]
      a
    -> IO (Either (CallStack, Error) a))
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     a
-> Eff es' (Either (CallStack, Error) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Eff '[IOE] (Either (CallStack, Error) a)
-> IO (Either (CallStack, Error) a)
forall a. HasCallStack => Eff '[IOE] a -> IO a
runEff
                (Eff '[IOE] (Either (CallStack, Error) a)
 -> IO (Either (CallStack, Error) a))
-> (Eff
      '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
        IOE]
      a
    -> Eff '[IOE] (Either (CallStack, Error) a))
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     a
-> IO (Either (CallStack, Error) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Eff '[Error Error, IOE] a
-> Eff '[IOE] (Either (CallStack, Error) a)
forall e (es :: [Effect]) a.
HasCallStack =>
Eff (Error e : es) a -> Eff es (Either (CallStack, e) a)
runError
                (Eff '[Error Error, IOE] a
 -> Eff '[IOE] (Either (CallStack, Error) a))
-> (Eff
      '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
        IOE]
      a
    -> Eff '[Error Error, IOE] a)
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     a
-> Eff '[IOE] (Either (CallStack, Error) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TQueue CommandWithCallback
-> Eff '[Reader (TQueue CommandWithCallback), Error Error, IOE] a
-> Eff '[Error Error, IOE] a
forall r (es :: [Effect]) a.
HasCallStack =>
r -> Eff (Reader r : es) a -> Eff es a
runReader TQueue CommandWithCallback
sendQueue
                (Eff '[Reader (TQueue CommandWithCallback), Error Error, IOE] a
 -> Eff '[Error Error, IOE] a)
-> (Eff
      '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
        IOE]
      a
    -> Eff '[Reader (TQueue CommandWithCallback), Error Error, IOE] a)
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     a
-> Eff '[Error Error, IOE] a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff '[Reader (TQueue CommandWithCallback), Error Error, IOE] a
forall (es :: [Effect]) a.
(HasCallStack, IOE :> es) =>
Eff (Concurrent : es) a -> Eff es a
runConcurrent
            )
            Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
action

-- | Lifted 'Marionette.acceptConnections'.
acceptConnections :: (HasCallStack, Marionette :> es) => Bool -> Eff es ()
acceptConnections :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Bool -> Eff es ()
acceptConnections = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Bool
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Bool
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *). (HasCallStack, Marionette m) => Bool -> m ()
Marionette.acceptConnections

-- | Lifted 'Marionette.getAccessibilityPropertiesForAccessibilityNode'.
getAccessibilityPropertiesForAccessibilityNode
    :: (HasCallStack, Marionette :> es)
    => Text
    -> Eff es AccessibilityProperties
getAccessibilityPropertiesForAccessibilityNode :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Text -> Eff es AccessibilityProperties
getAccessibilityPropertiesForAccessibilityNode = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  AccessibilityProperties
-> Eff es AccessibilityProperties
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   AccessibilityProperties
 -> Eff es AccessibilityProperties)
-> (Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         AccessibilityProperties)
-> Text
-> Eff es AccessibilityProperties
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     AccessibilityProperties
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Text -> m AccessibilityProperties
Marionette.getAccessibilityPropertiesForAccessibilityNode

-- | Lifted 'Marionette.getAccessibilityPropertiesForElement'.
getAccessibilityPropertiesForElement
    :: (HasCallStack, Marionette :> es)
    => Element
    -> Eff es AccessibilityProperties
getAccessibilityPropertiesForElement :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es AccessibilityProperties
getAccessibilityPropertiesForElement = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  AccessibilityProperties
-> Eff es AccessibilityProperties
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   AccessibilityProperties
 -> Eff es AccessibilityProperties)
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         AccessibilityProperties)
-> Element
-> Eff es AccessibilityProperties
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     AccessibilityProperties
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m AccessibilityProperties
Marionette.getAccessibilityPropertiesForElement

-- | Lifted 'Marionette.getContext'.
getContext :: (HasCallStack, Marionette :> es) => Eff es Context
getContext :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es Context
getContext = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Context
-> Eff es Context
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Context
forall (m :: * -> *). (HasCallStack, Marionette m) => m Context
Marionette.getContext

-- | Lifted 'Marionette.getScreenOrientation'.
getScreenOrientation :: (HasCallStack, Marionette :> es) => Eff es Orientation
getScreenOrientation :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es Orientation
getScreenOrientation = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Orientation
-> Eff es Orientation
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Orientation
forall (m :: * -> *). (HasCallStack, Marionette m) => m Orientation
Marionette.getScreenOrientation

-- | Lifted 'Marionette.getWindowType'.
getWindowType :: (HasCallStack, Marionette :> es) => Eff es Text
getWindowType :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es Text
getWindowType = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
-> Eff es Text
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
forall (m :: * -> *). (HasCallStack, Marionette m) => m Text
Marionette.getWindowType

-- | Lifted 'Marionette.quit'.
quit :: (HasCallStack, Marionette :> es) => Eff es ()
quit :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
quit = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.quit

-- | Lifted 'Marionette.registerChromeHandler'.
registerChromeHandler
    :: (HasCallStack, Marionette :> es)
    => Text
    -> [RegistryEntry]
    -> Eff es Text
registerChromeHandler :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Text -> [RegistryEntry] -> Eff es Text
registerChromeHandler = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
-> Eff es Text
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Text
 -> Eff es Text)
-> ([RegistryEntry]
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Text)
-> [RegistryEntry]
-> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) (([RegistryEntry]
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       Text)
 -> [RegistryEntry] -> Eff es Text)
-> (Text
    -> [RegistryEntry]
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Text)
-> Text
-> [RegistryEntry]
-> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> [RegistryEntry]
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Text
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Text -> [RegistryEntry] -> m Text
Marionette.registerChromeHandler

-- | Lifted 'Marionette.setContext'.
setContext :: (HasCallStack, Marionette :> es) => Context -> Eff es ()
setContext :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Context -> Eff es ()
setContext = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Context
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Context
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Context
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Context -> m ()
Marionette.setContext

-- | Lifted 'Marionette.setScreenOrientation'.
setScreenOrientation
    :: (HasCallStack, Marionette :> es) => Orientation -> Eff es ()
setScreenOrientation :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Orientation -> Eff es ()
setScreenOrientation = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Orientation
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Orientation
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Orientation
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Orientation -> m ()
Marionette.setScreenOrientation

-- | Lifted 'Marionette.unregisterChromeHandler'.
unregisterChromeHandler :: (HasCallStack, Marionette :> es) => Text -> Eff es ()
unregisterChromeHandler :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Text -> Eff es ()
unregisterChromeHandler = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Text
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *). (HasCallStack, Marionette m) => Text -> m ()
Marionette.unregisterChromeHandler

-- | Lifted 'Marionette.acceptAlert'.
acceptAlert :: (HasCallStack, Marionette :> es) => Eff es ()
acceptAlert :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
acceptAlert = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.acceptAlert

-- | Lifted 'Marionette.addCookie'.
addCookie :: (HasCallStack, Marionette :> es) => Cookie -> Eff es ()
addCookie :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Cookie -> Eff es ()
addCookie = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Cookie
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Cookie
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cookie
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Cookie -> m ()
Marionette.addCookie

-- | Lifted 'Marionette.back'.
back :: (HasCallStack, Marionette :> es) => Eff es ()
back :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
back = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.back

-- | Lifted 'Marionette.closeChromeWindow'.
closeChromeWindow :: (HasCallStack, Marionette :> es) => Eff es ()
closeChromeWindow :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
closeChromeWindow = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.closeChromeWindow

-- | Lifted 'Marionette.closeWindow'.
closeWindow :: (HasCallStack, Marionette :> es) => Eff es ()
closeWindow :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
closeWindow = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.closeWindow

-- | Lifted 'Marionette.deleteAllCookies'.
deleteAllCookies :: (HasCallStack, Marionette :> es) => Eff es ()
deleteAllCookies :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
deleteAllCookies = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.deleteAllCookies

-- | Lifted 'Marionette.deleteCookie'.
deleteCookie :: (HasCallStack, Marionette :> es) => Text -> Eff es ()
deleteCookie :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Text -> Eff es ()
deleteCookie = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Text
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *). (HasCallStack, Marionette m) => Text -> m ()
Marionette.deleteCookie

-- | Lifted 'Marionette.deleteSession'.
deleteSession :: (HasCallStack, Marionette :> es) => Eff es ()
deleteSession :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
deleteSession = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.deleteSession

-- | Lifted 'Marionette.dismissAlert'.
dismissAlert :: (HasCallStack, Marionette :> es) => Eff es ()
dismissAlert :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
dismissAlert = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.dismissAlert

-- | Lifted 'Marionette.elementClear'.
elementClear :: (HasCallStack, Marionette :> es) => Element -> Eff es ()
elementClear :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es ()
elementClear = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Element
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m ()
Marionette.elementClear

-- | Lifted 'Marionette.elementClick'.
elementClick :: (HasCallStack, Marionette :> es) => Element -> Eff es ()
elementClick :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es ()
elementClick = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Element
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m ()
Marionette.elementClick

-- | Lifted 'Marionette.elementSendKeys'.
elementSendKeys
    :: (HasCallStack, Marionette :> es) => Element -> Text -> Eff es ()
elementSendKeys :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Text -> Eff es ()
elementSendKeys = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Text
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Text
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       ())
 -> Text -> Eff es ())
-> (Element
    -> Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Element
-> Text
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Text
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> Text -> m ()
Marionette.elementSendKeys

-- | Lifted 'Marionette.executeAsyncScript'.
executeAsyncScript
    :: (HasCallStack, Marionette :> es, Foldable f, FromJSON a)
    => Text
    -> f Value
    -> Eff es (Maybe a)
executeAsyncScript :: forall (es :: [Effect]) (f :: * -> *) a.
(HasCallStack, Marionette :> es, Foldable f, FromJSON a) =>
Text -> f Value -> Eff es (Maybe a)
executeAsyncScript = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  (Maybe a)
-> Eff es (Maybe a)
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   (Maybe a)
 -> Eff es (Maybe a))
-> (f Value
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         (Maybe a))
-> f Value
-> Eff es (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((f Value
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       (Maybe a))
 -> f Value -> Eff es (Maybe a))
-> (Text
    -> f Value
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         (Maybe a))
-> Text
-> f Value
-> Eff es (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> f Value
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     (Maybe a)
forall (m :: * -> *) (f :: * -> *) a.
(HasCallStack, Marionette m, Foldable f, FromJSON a) =>
Text -> f Value -> m (Maybe a)
Marionette.executeAsyncScript

-- | Lifted 'Marionette.executeScript'.
executeScript
    :: (HasCallStack, Marionette :> es, Foldable f, FromJSON a)
    => Text
    -> f Value
    -> Eff es a
executeScript :: forall (es :: [Effect]) (f :: * -> *) a.
(HasCallStack, Marionette :> es, Foldable f, FromJSON a) =>
Text -> f Value -> Eff es a
executeScript = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es a
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   a
 -> Eff es a)
-> (f Value
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         a)
-> f Value
-> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((f Value
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       a)
 -> f Value -> Eff es a)
-> (Text
    -> f Value
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         a)
-> Text
-> f Value
-> Eff es a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> f Value
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     a
forall (m :: * -> *) (f :: * -> *) a.
(HasCallStack, Marionette m, Foldable f, FromJSON a) =>
Text -> f Value -> m a
Marionette.executeScript

-- | Lifted 'Marionette.findElement'.
findElement :: (HasCallStack, Marionette :> es) => Selector -> Eff es Element
findElement :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Selector -> Eff es Element
findElement = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Element
-> Eff es Element
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Element
 -> Eff es Element)
-> (Selector
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Element)
-> Selector
-> Eff es Element
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Selector
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Element
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Selector -> m Element
Marionette.findElement

-- | Lifted 'Marionette.findElementFrom'.
findElementFrom
    :: (HasCallStack, Marionette :> es)
    => Element
    -> Selector
    -> Eff es Element
findElementFrom :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Selector -> Eff es Element
findElementFrom = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Element
-> Eff es Element
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Element
 -> Eff es Element)
-> (Selector
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Element)
-> Selector
-> Eff es Element
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Selector
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       Element)
 -> Selector -> Eff es Element)
-> (Element
    -> Selector
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Element)
-> Element
-> Selector
-> Eff es Element
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Selector
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Element
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> Selector -> m Element
Marionette.findElementFrom

-- | Lifted 'Marionette.findElementFromShadowRoot'.
findElementFromShadowRoot
    :: (HasCallStack, Marionette :> es)
    => Shadow
    -> Selector
    -> Eff es Element
findElementFromShadowRoot :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Shadow -> Selector -> Eff es Element
findElementFromShadowRoot = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Element
-> Eff es Element
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Element
 -> Eff es Element)
-> (Selector
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Element)
-> Selector
-> Eff es Element
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Selector
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       Element)
 -> Selector -> Eff es Element)
-> (Shadow
    -> Selector
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Element)
-> Shadow
-> Selector
-> Eff es Element
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Shadow
-> Selector
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Element
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Shadow -> Selector -> m Element
Marionette.findElementFromShadowRoot

-- | Lifted 'Marionette.findElements'.
findElements
    :: ( HasCallStack
       , Marionette :> es
       )
    => Selector
    -> Eff es [Element]
findElements :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Selector -> Eff es [Element]
findElements = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  [Element]
-> Eff es [Element]
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   [Element]
 -> Eff es [Element])
-> (Selector
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         [Element])
-> Selector
-> Eff es [Element]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Selector
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     [Element]
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Selector -> m [Element]
Marionette.findElements

-- | Lifted 'Marionette.findElementsFrom'.
findElementsFrom
    :: ( HasCallStack
       , Marionette :> es
       )
    => Element
    -> Selector
    -> Eff es [Element]
findElementsFrom :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Selector -> Eff es [Element]
findElementsFrom = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  [Element]
-> Eff es [Element]
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   [Element]
 -> Eff es [Element])
-> (Selector
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         [Element])
-> Selector
-> Eff es [Element]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Selector
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       [Element])
 -> Selector -> Eff es [Element])
-> (Element
    -> Selector
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         [Element])
-> Element
-> Selector
-> Eff es [Element]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Selector
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     [Element]
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> Selector -> m [Element]
Marionette.findElementsFrom

-- | Lifted 'Marionette.findElementsFromShadowRoot'.
findElementsFromShadowRoot
    :: (HasCallStack, Marionette :> es)
    => Shadow
    -> Selector
    -> Eff es [Element]
findElementsFromShadowRoot :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Shadow -> Selector -> Eff es [Element]
findElementsFromShadowRoot = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  [Element]
-> Eff es [Element]
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   [Element]
 -> Eff es [Element])
-> (Selector
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         [Element])
-> Selector
-> Eff es [Element]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Selector
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       [Element])
 -> Selector -> Eff es [Element])
-> (Shadow
    -> Selector
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         [Element])
-> Shadow
-> Selector
-> Eff es [Element]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Shadow
-> Selector
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     [Element]
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Shadow -> Selector -> m [Element]
Marionette.findElementsFromShadowRoot

-- | Lifted 'Marionette.forward'.
forward :: (HasCallStack, Marionette :> es) => Eff es ()
forward :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
forward = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.forward

-- | Lifted 'Marionette.fullscreenWindow'.
fullscreenWindow :: (HasCallStack, Marionette :> es) => Eff es ()
fullscreenWindow :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
fullscreenWindow = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.fullscreenWindow

-- | Lifted 'Marionette.getActiveElement'.
getActiveElement :: (HasCallStack, Marionette :> es) => Eff es Element
getActiveElement :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es Element
getActiveElement = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Element
-> Eff es Element
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Element
forall (m :: * -> *). (HasCallStack, Marionette m) => m Element
Marionette.getActiveElement

-- | Lifted 'Marionette.getAlertText'.
getAlertText :: (HasCallStack, Marionette :> es) => Eff es Text
getAlertText :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es Text
getAlertText = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
-> Eff es Text
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
forall (m :: * -> *). (HasCallStack, Marionette m) => m Text
Marionette.getAlertText

-- | Lifted 'Marionette.getComputedLabel'.
getComputedLabel :: (HasCallStack, Marionette :> es) => Element -> Eff es Text
getComputedLabel :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es Text
getComputedLabel = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
-> Eff es Text
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Text
 -> Eff es Text)
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Text)
-> Element
-> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Text
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m Text
Marionette.getComputedLabel

-- | Lifted 'Marionette.getComputedRole'.
getComputedRole :: (HasCallStack, Marionette :> es) => Element -> Eff es Text
getComputedRole :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es Text
getComputedRole = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
-> Eff es Text
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Text
 -> Eff es Text)
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Text)
-> Element
-> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Text
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m Text
Marionette.getComputedRole

-- | Lifted 'Marionette.getCookies'.
getCookies :: (HasCallStack, Marionette :> es) => Eff es [Cookie]
getCookies :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es [Cookie]
getCookies = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  [Cookie]
-> Eff es [Cookie]
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  [Cookie]
forall (m :: * -> *). (HasCallStack, Marionette m) => m [Cookie]
Marionette.getCookies

-- | Lifted 'Marionette.getCurrentURL'.
getCurrentURL :: (HasCallStack, Marionette :> es) => Eff es Text
getCurrentURL :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es Text
getCurrentURL = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
-> Eff es Text
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
forall (m :: * -> *). (HasCallStack, Marionette m) => m Text
Marionette.getCurrentURL

-- | Lifted 'Marionette.getElementAttribute'.
getElementAttribute
    :: (HasCallStack, Marionette :> es)
    => Text
    -> Element
    -> Eff es (Maybe Text)
getElementAttribute :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Text -> Element -> Eff es (Maybe Text)
getElementAttribute = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  (Maybe Text)
-> Eff es (Maybe Text)
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   (Maybe Text)
 -> Eff es (Maybe Text))
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         (Maybe Text))
-> Element
-> Eff es (Maybe Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Element
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       (Maybe Text))
 -> Element -> Eff es (Maybe Text))
-> (Text
    -> Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         (Maybe Text))
-> Text
-> Element
-> Eff es (Maybe Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     (Maybe Text)
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Text -> Element -> m (Maybe Text)
Marionette.getElementAttribute

-- | Lifted 'Marionette.getElementCSSValue'.
getElementCSSValue
    :: (HasCallStack, Marionette :> es)
    => Element
    -> Text
    -> Eff es (Maybe Text)
getElementCSSValue :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Text -> Eff es (Maybe Text)
getElementCSSValue = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  (Maybe Text)
-> Eff es (Maybe Text)
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   (Maybe Text)
 -> Eff es (Maybe Text))
-> (Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         (Maybe Text))
-> Text
-> Eff es (Maybe Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Text
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       (Maybe Text))
 -> Text -> Eff es (Maybe Text))
-> (Element
    -> Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         (Maybe Text))
-> Element
-> Text
-> Eff es (Maybe Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Text
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     (Maybe Text)
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> Text -> m (Maybe Text)
Marionette.getElementCSSValue

-- | Lifted 'Marionette.getElementProperty'.
getElementProperty
    :: (HasCallStack, Marionette :> es)
    => Element
    -> Text
    -> Eff es (Maybe Text)
getElementProperty :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Text -> Eff es (Maybe Text)
getElementProperty = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  (Maybe Text)
-> Eff es (Maybe Text)
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   (Maybe Text)
 -> Eff es (Maybe Text))
-> (Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         (Maybe Text))
-> Text
-> Eff es (Maybe Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Text
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       (Maybe Text))
 -> Text -> Eff es (Maybe Text))
-> (Element
    -> Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         (Maybe Text))
-> Element
-> Text
-> Eff es (Maybe Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Text
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     (Maybe Text)
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> Text -> m (Maybe Text)
Marionette.getElementProperty

-- | Lifted 'Marionette.getElementRect'.
getElementRect :: (HasCallStack, Marionette :> es) => Element -> Eff es Rect
getElementRect :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es Rect
getElementRect = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Rect
-> Eff es Rect
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Rect
 -> Eff es Rect)
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Rect)
-> Element
-> Eff es Rect
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Rect
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m Rect
Marionette.getElementRect

-- | Lifted 'Marionette.getElementTagName'.
getElementTagName :: (HasCallStack, Marionette :> es) => Element -> Eff es Text
getElementTagName :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es Text
getElementTagName = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
-> Eff es Text
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Text
 -> Eff es Text)
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Text)
-> Element
-> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Text
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m Text
Marionette.getElementTagName

-- | Lifted 'Marionette.getElementText'.
getElementText :: (HasCallStack, Marionette :> es) => Element -> Eff es Text
getElementText :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es Text
getElementText = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
-> Eff es Text
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Text
 -> Eff es Text)
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Text)
-> Element
-> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Text
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m Text
Marionette.getElementText

-- | Lifted 'Marionette.getPageSource'.
getPageSource :: (HasCallStack, Marionette :> es) => Eff es Text
getPageSource :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es Text
getPageSource = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
-> Eff es Text
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
forall (m :: * -> *). (HasCallStack, Marionette m) => m Text
Marionette.getPageSource

-- | Lifted 'Marionette.getShadowRoot'.
getShadowRoot :: (HasCallStack, Marionette :> es) => Element -> Eff es Shadow
getShadowRoot :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es Shadow
getShadowRoot = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Shadow
-> Eff es Shadow
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Shadow
 -> Eff es Shadow)
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Shadow)
-> Element
-> Eff es Shadow
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Shadow
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m Shadow
Marionette.getShadowRoot

-- | Lifted 'Marionette.getTimeouts'.
getTimeouts :: (HasCallStack, Marionette :> es) => Eff es Timeouts
getTimeouts :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es Timeouts
getTimeouts = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Timeouts
-> Eff es Timeouts
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Timeouts
forall (m :: * -> *). (HasCallStack, Marionette m) => m Timeouts
Marionette.getTimeouts

-- | Lifted 'Marionette.getTitle'.
getTitle :: (HasCallStack, Marionette :> es) => Eff es Text
getTitle :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es Text
getTitle = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
-> Eff es Text
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Text
forall (m :: * -> *). (HasCallStack, Marionette m) => m Text
Marionette.getTitle

-- | Lifted 'Marionette.getWindowHandle'.
getWindowHandle :: (HasCallStack, Marionette :> es) => Eff es WindowHandle
getWindowHandle :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es WindowHandle
getWindowHandle = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  WindowHandle
-> Eff es WindowHandle
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  WindowHandle
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
m WindowHandle
Marionette.getWindowHandle

-- | Lifted 'Marionette.getWindowHandles'.
getWindowHandles :: (HasCallStack, Marionette :> es) => Eff es [WindowHandle]
getWindowHandles :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es [WindowHandle]
getWindowHandles = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  [WindowHandle]
-> Eff es [WindowHandle]
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  [WindowHandle]
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
m [WindowHandle]
Marionette.getWindowHandles

-- | Lifted 'Marionette.getWindowRect'.
getWindowRect :: (HasCallStack, Marionette :> es) => Eff es Rect
getWindowRect :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es Rect
getWindowRect = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Rect
-> Eff es Rect
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Rect
forall (m :: * -> *). (HasCallStack, Marionette m) => m Rect
Marionette.getWindowRect

-- | Lifted 'Marionette.isElementDisplayed'.
isElementDisplayed :: (HasCallStack, Marionette :> es) => Element -> Eff es Bool
isElementDisplayed :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es Bool
isElementDisplayed = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Bool
-> Eff es Bool
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Bool
 -> Eff es Bool)
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Bool)
-> Element
-> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Bool
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m Bool
Marionette.isElementDisplayed

-- | Lifted 'Marionette.isElementEnabled'.
isElementEnabled :: (HasCallStack, Marionette :> es) => Element -> Eff es Bool
isElementEnabled :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es Bool
isElementEnabled = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Bool
-> Eff es Bool
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Bool
 -> Eff es Bool)
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Bool)
-> Element
-> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Bool
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m Bool
Marionette.isElementEnabled

-- | Lifted 'Marionette.isElementSelected'.
isElementSelected :: (HasCallStack, Marionette :> es) => Element -> Eff es Bool
isElementSelected :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Element -> Eff es Bool
isElementSelected = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  Bool
-> Eff es Bool
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   Bool
 -> Eff es Bool)
-> (Element
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         Bool)
-> Element
-> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     Bool
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Element -> m Bool
Marionette.isElementSelected

-- | Lifted 'Marionette.maximizeWindow'.
maximizeWindow :: (HasCallStack, Marionette :> es) => Eff es ()
maximizeWindow :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
maximizeWindow = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.maximizeWindow

-- | Lifted 'Marionette.minimizeWindow'.
minimizeWindow :: (HasCallStack, Marionette :> es) => Eff es ()
minimizeWindow :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
minimizeWindow = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.minimizeWindow

-- | Lifted 'Marionette.navigate'.
navigate :: (HasCallStack, Marionette :> es) => Text -> Eff es ()
navigate :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Text -> Eff es ()
navigate = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Text
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *). (HasCallStack, Marionette m) => Text -> m ()
Marionette.navigate

-- | Lifted 'Marionette.newSession'.
newSession :: (HasCallStack, Marionette :> es) => Eff es ()
newSession :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
newSession = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.newSession

-- | Lifted 'Marionette.newWindow'.
newWindow :: (HasCallStack, Marionette :> es) => Eff es NewWindowResult
newWindow :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es NewWindowResult
newWindow = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  NewWindowResult
-> Eff es NewWindowResult
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  NewWindowResult
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
m NewWindowResult
Marionette.newWindow

-- | Lifted 'Marionette.newTab'.
newTab :: (HasCallStack, Marionette :> es) => Eff es NewWindowResult
newTab :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es NewWindowResult
newTab = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  NewWindowResult
-> Eff es NewWindowResult
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  NewWindowResult
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
m NewWindowResult
Marionette.newTab

-- | Lifted 'Marionette.performActions'.
performActions :: (HasCallStack, Marionette :> es) => Eff es ()
performActions :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
performActions = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.performActions

-- | Lifted 'Marionette.print'.
print :: (HasCallStack, Marionette :> es) => Eff es ()
print :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
print = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.print

-- | Lifted 'Marionette.refresh'.
refresh :: (HasCallStack, Marionette :> es) => Eff es ()
refresh :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
refresh = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.refresh

-- | Lifted 'Marionette.releaseActions'.
releaseActions :: (HasCallStack, Marionette :> es) => Eff es ()
releaseActions :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
releaseActions = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.releaseActions

-- | Lifted 'Marionette.sendAlertText'.
sendAlertText :: (HasCallStack, Marionette :> es) => Text -> Eff es ()
sendAlertText :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Text -> Eff es ()
sendAlertText = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Text
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Text
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *). (HasCallStack, Marionette m) => Text -> m ()
Marionette.sendAlertText

-- | Lifted 'Marionette.setPermission'.
setPermission :: (HasCallStack, Marionette :> es) => Eff es ()
setPermission :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
setPermission = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.setPermission

-- | Lifted 'Marionette.setTimeouts'.
setTimeouts :: (HasCallStack, Marionette :> es) => Timeouts -> Eff es ()
setTimeouts :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Timeouts -> Eff es ()
setTimeouts = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Timeouts
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Timeouts
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Timeouts
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
Timeouts -> m ()
Marionette.setTimeouts

-- | Lifted 'Marionette.setWindowRect'.
setWindowRect :: (HasCallStack, Marionette :> es) => Rect -> Eff es ()
setWindowRect :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Rect -> Eff es ()
setWindowRect = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Rect
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Rect
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rect
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *). (HasCallStack, Marionette m) => Rect -> m ()
Marionette.setWindowRect

-- | Lifted 'Marionette.switchToFrame'.
switchToFrame :: (HasCallStack, Marionette :> es) => Frame -> Eff es ()
switchToFrame :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Frame -> Eff es ()
switchToFrame = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Frame
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Frame
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Frame
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *). (HasCallStack, Marionette m) => Frame -> m ()
Marionette.switchToFrame

-- | Lifted 'Marionette.switchToParentFrame'.
switchToParentFrame :: (HasCallStack, Marionette :> es) => Eff es ()
switchToParentFrame :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ()
switchToParentFrame = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
forall (m :: * -> *). (HasCallStack, Marionette m) => m ()
Marionette.switchToParentFrame

-- | Lifted 'Marionette.switchToWindow'.
switchToWindow :: (HasCallStack, Marionette :> es) => WindowHandle -> Eff es ()
switchToWindow :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
WindowHandle -> Eff es ()
switchToWindow = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (WindowHandle
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> WindowHandle
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WindowHandle
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
WindowHandle -> m ()
Marionette.switchToWindow

-- | Lifted 'Marionette.takeScreenshot'.
takeScreenshot :: (HasCallStack, Marionette :> es) => Eff es ByteString
takeScreenshot :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
Eff es ByteString
takeScreenshot = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ByteString
-> Eff es ByteString
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ByteString
forall (m :: * -> *). (HasCallStack, Marionette m) => m ByteString
Marionette.takeScreenshot

-- | Lifted 'Marionette.addCredential'.
addCredential
    :: (HasCallStack, Marionette :> es)
    => AuthenticatorId
    -> Credential
    -> Eff es ()
addCredential :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
AuthenticatorId -> Credential -> Eff es ()
addCredential = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Credential
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Credential
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Credential
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       ())
 -> Credential -> Eff es ())
-> (AuthenticatorId
    -> Credential
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> AuthenticatorId
-> Credential
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AuthenticatorId
-> Credential
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
AuthenticatorId -> Credential -> m ()
Marionette.addCredential

-- | Lifted 'Marionette.addVirtualAuthenticator'.
addVirtualAuthenticator
    :: (HasCallStack, Marionette :> es)
    => VirtualAuthenticator
    -> Eff es AuthenticatorId
addVirtualAuthenticator :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
VirtualAuthenticator -> Eff es AuthenticatorId
addVirtualAuthenticator = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  AuthenticatorId
-> Eff es AuthenticatorId
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   AuthenticatorId
 -> Eff es AuthenticatorId)
-> (VirtualAuthenticator
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         AuthenticatorId)
-> VirtualAuthenticator
-> Eff es AuthenticatorId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VirtualAuthenticator
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     AuthenticatorId
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
VirtualAuthenticator -> m AuthenticatorId
Marionette.addVirtualAuthenticator

-- | Lifted 'Marionette.getCredentials'.
getCredentials :: (HasCallStack, Marionette :> es) => AuthenticatorId -> Eff es [Credential]
getCredentials :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
AuthenticatorId -> Eff es [Credential]
getCredentials = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  [Credential]
-> Eff es [Credential]
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   [Credential]
 -> Eff es [Credential])
-> (AuthenticatorId
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         [Credential])
-> AuthenticatorId
-> Eff es [Credential]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AuthenticatorId
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     [Credential]
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
AuthenticatorId -> m [Credential]
Marionette.getCredentials

-- | Lifted 'Marionette.removeAllCredentials'.
removeAllCredentials
    :: (HasCallStack, Marionette :> es)
    => AuthenticatorId
    -> Eff es ()
removeAllCredentials :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
AuthenticatorId -> Eff es ()
removeAllCredentials = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (AuthenticatorId
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> AuthenticatorId
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AuthenticatorId
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
AuthenticatorId -> m ()
Marionette.removeAllCredentials

-- | Lifted 'Marionette.removeCredential'.
removeCredential
    :: (HasCallStack, Marionette :> es)
    => AuthenticatorId
    -> CredentialId
    -> Eff es ()
removeCredential :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
AuthenticatorId -> CredentialId -> Eff es ()
removeCredential = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (CredentialId
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> CredentialId
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((CredentialId
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       ())
 -> CredentialId -> Eff es ())
-> (AuthenticatorId
    -> CredentialId
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> AuthenticatorId
-> CredentialId
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AuthenticatorId
-> CredentialId
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
AuthenticatorId -> CredentialId -> m ()
Marionette.removeCredential

-- | Lifted 'Marionette.removeVirtualAuthenticator'.
removeVirtualAuthenticator
    :: (HasCallStack, Marionette :> es)
    => AuthenticatorId
    -> Eff es ()
removeVirtualAuthenticator :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
AuthenticatorId -> Eff es ()
removeVirtualAuthenticator = Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (AuthenticatorId
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> AuthenticatorId
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AuthenticatorId
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
AuthenticatorId -> m ()
Marionette.removeVirtualAuthenticator

-- | Lifted 'Marionette.setUserVerified'.
setUserVerified
    :: (HasCallStack, Marionette :> es)
    => AuthenticatorId
    -> Bool
    -> Eff es ()
setUserVerified :: forall (es :: [Effect]).
(HasCallStack, Marionette :> es) =>
AuthenticatorId -> Bool -> Eff es ()
setUserVerified = (Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  ()
-> Eff es ()
forall (es' :: [Effect]) a.
(HasCallStack, Marionette :> es') =>
Eff
  '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
    IOE]
  a
-> Eff es' a
m (Eff
   '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
     IOE]
   ()
 -> Eff es ())
-> (Bool
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> Bool
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Bool
  -> Eff
       '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
         IOE]
       ())
 -> Bool -> Eff es ())
-> (AuthenticatorId
    -> Bool
    -> Eff
         '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
           IOE]
         ())
-> AuthenticatorId
-> Bool
-> Eff es ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AuthenticatorId
-> Bool
-> Eff
     '[Concurrent, Reader (TQueue CommandWithCallback), Error Error,
       IOE]
     ()
forall (m :: * -> *).
(HasCallStack, Marionette m) =>
AuthenticatorId -> Bool -> m ()
Marionette.setUserVerified