reflex-dom-core 0.8.1.3 → 0.8.1.4

+ Reflex.Dom.Builder.Class: ($dmaskDocument) :: forall (f :: (Type -> Type) -> Type -> Type) (m' :: Type -> Type). (HasDocument m, m ~ f m', RawDocument (DomBuilderSpace m) ~ RawDocument (DomBuilderSpace m'), MonadTrans f, HasDocument m') => m (RawDocument (DomBuilderSpace m))

+ Reflex.Dom.Builder.Class: ($dmcommentNode) :: forall (f :: (Type -> Type) -> Type -> Type) (m' :: Type -> Type). (DomBuilder t m, MonadTrans f, m ~ f m', DomBuilderSpace m' ~ DomBuilderSpace m, DomBuilder t m') => CommentNodeConfig t -> m (CommentNode (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: ($dmelement) :: forall (f :: (Type -> Type) -> Type -> Type) a (m' :: Type -> Type) (er :: EventTag -> Type). (DomBuilder t m, MonadTransControl f, StT f a ~ a, m ~ f m', DomBuilderSpace m' ~ DomBuilderSpace m, DomBuilder t m') => Text -> ElementConfig er t (DomBuilderSpace m) -> m a -> m (Element er (DomBuilderSpace m) t, a)

+ Reflex.Dom.Builder.Class: ($dminputElement) :: forall (f :: (Type -> Type) -> Type -> Type) (m' :: Type -> Type) (er :: EventTag -> Type). (DomBuilder t m, MonadTransControl f, m ~ f m', DomBuilderSpace m' ~ DomBuilderSpace m, DomBuilder t m') => InputElementConfig er t (DomBuilderSpace m) -> m (InputElement er (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: ($dmplaceRawElement) :: forall (f :: (Type -> Type) -> Type -> Type) (m' :: Type -> Type). (DomBuilder t m, MonadTrans f, m ~ f m', DomBuilderSpace m' ~ DomBuilderSpace m, DomBuilder t m') => RawElement (DomBuilderSpace m) -> m ()

+ Reflex.Dom.Builder.Class: ($dmselectElement) :: forall (f :: (Type -> Type) -> Type -> Type) a (m' :: Type -> Type) (er :: EventTag -> Type). (DomBuilder t m, MonadTransControl f, StT f a ~ a, m ~ f m', DomBuilderSpace m' ~ DomBuilderSpace m, DomBuilder t m') => SelectElementConfig er t (DomBuilderSpace m) -> m a -> m (SelectElement er (DomBuilderSpace m) t, a)

+ Reflex.Dom.Builder.Class: ($dmstTCoercion) :: (MonadTransControlStateless t, a ~ StT t a) => proxy t -> Coercion (StT t a) a

+ Reflex.Dom.Builder.Class: ($dmtextAreaElement) :: forall (f :: (Type -> Type) -> Type -> Type) (m' :: Type -> Type) (er :: EventTag -> Type). (DomBuilder t m, MonadTransControl f, m ~ f m', DomBuilderSpace m' ~ DomBuilderSpace m, DomBuilder t m') => TextAreaElementConfig er t (DomBuilderSpace m) -> m (TextAreaElement er (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: ($dmtextNode) :: forall (f :: (Type -> Type) -> Type -> Type) (m' :: Type -> Type). (DomBuilder t m, MonadTrans f, m ~ f m', DomBuilderSpace m' ~ DomBuilderSpace m, DomBuilder t m') => TextNodeConfig t -> m (TextNode (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: ($dmwrapRawElement) :: forall (f :: (Type -> Type) -> Type -> Type) (m' :: Type -> Type) (er :: EventTag -> Type). (DomBuilder t m, MonadTrans f, m ~ f m', DomBuilderSpace m' ~ DomBuilderSpace m, DomBuilder t m') => RawElement (DomBuilderSpace m) -> RawElementConfig er t (DomBuilderSpace m) -> m (Element er (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: type family SetValue a

+ Reflex.Dom.Builder.Immediate: ($dmaskDocument) :: forall (f :: (Type -> Type) -> Type -> Type) (m' :: Type -> Type). (HasDocument m, m ~ f m', RawDocument (DomBuilderSpace m) ~ RawDocument (DomBuilderSpace m'), MonadTrans f, HasDocument m') => m (RawDocument (DomBuilderSpace m))

+ Foreign.JavaScript.TH: WithJSContextSingleton :: ReaderT (JSContextSingleton x) m a -> WithJSContextSingleton x (m :: Type -> Type) a

+ Foreign.JavaScript.TH: [unWithJSContextSingleton] :: WithJSContextSingleton x (m :: Type -> Type) a -> ReaderT (JSContextSingleton x) m a

+ Foreign.JavaScript.TH: data Safety

+ Foreign.JavaScript.TH: newtype WithJSContextSingleton x (m :: Type -> Type) a

+ Foreign.JavaScript.TH: withJSContextSingleton :: MonadJSM m => (forall x. () => JSContextSingleton x -> m r) -> m r

+ Reflex.Dom.Builder.Class: CommentNode :: RawCommentNode d -> CommentNode (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: CommentNodeConfig :: {-# UNPACK #-} !Text -> !Maybe (Event t Text) -> CommentNodeConfig (t :: k)

+ Reflex.Dom.Builder.Class: Element :: EventSelector t (WrapArg er EventName) -> RawElement d -> Element (er :: EventTag -> Type) (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: ElementConfig :: Maybe Namespace -> Map AttributeName Text -> Maybe (Event t (Map AttributeName (Maybe Text))) -> EventSpec s er -> ElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1)

+ Reflex.Dom.Builder.Class: InputElement :: Dynamic t Text -> Dynamic t Bool -> Event t Bool -> Event t Text -> Dynamic t Bool -> Element er d t -> RawInputElement d -> Dynamic t [File] -> InputElement (er :: EventTag -> Type) (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: InputElementConfig :: Text -> Maybe (Event t Text) -> Bool -> Maybe (Event t Bool) -> ElementConfig er t s -> InputElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1)

+ Reflex.Dom.Builder.Class: RawElementConfig :: Maybe (Event t (Map AttributeName (Maybe Text))) -> EventSpec s er -> RawElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1)

+ Reflex.Dom.Builder.Class: SelectElement :: Element er d t -> Dynamic t Text -> Event t Text -> Dynamic t Bool -> RawSelectElement d -> SelectElement (er :: EventTag -> Type) (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: SelectElementConfig :: Text -> Maybe (Event t Text) -> ElementConfig er t m -> SelectElementConfig (er :: EventTag -> Type) (t :: k) (m :: k1)

+ Reflex.Dom.Builder.Class: TextAreaElement :: Dynamic t Text -> Event t Text -> Dynamic t Bool -> Element er d t -> RawTextAreaElement d -> TextAreaElement (er :: EventTag -> Type) (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: TextAreaElementConfig :: Text -> Maybe (Event t Text) -> ElementConfig er t m -> TextAreaElementConfig (er :: EventTag -> Type) (t :: k) (m :: k1)

+ Reflex.Dom.Builder.Class: TextNode :: RawTextNode d -> TextNode (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: TextNodeConfig :: {-# UNPACK #-} !Text -> !Maybe (Event t Text) -> TextNodeConfig (t :: k)

+ Reflex.Dom.Builder.Class: [_commentNodeConfig_initialContents] :: CommentNodeConfig (t :: k) -> {-# UNPACK #-} !Text

+ Reflex.Dom.Builder.Class: [_commentNodeConfig_setContents] :: CommentNodeConfig (t :: k) -> !Maybe (Event t Text)

+ Reflex.Dom.Builder.Class: [_commentNode_raw] :: CommentNode (d :: k) (t :: k1) -> RawCommentNode d

+ Reflex.Dom.Builder.Class: [_elementConfig_eventSpec] :: ElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> EventSpec s er

+ Reflex.Dom.Builder.Class: [_elementConfig_initialAttributes] :: ElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> Map AttributeName Text

+ Reflex.Dom.Builder.Class: [_elementConfig_modifyAttributes] :: ElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> Maybe (Event t (Map AttributeName (Maybe Text)))

+ Reflex.Dom.Builder.Class: [_elementConfig_namespace] :: ElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> Maybe Namespace

+ Reflex.Dom.Builder.Class: [_element_events] :: Element (er :: EventTag -> Type) (d :: k) (t :: k1) -> EventSelector t (WrapArg er EventName)

+ Reflex.Dom.Builder.Class: [_element_raw] :: Element (er :: EventTag -> Type) (d :: k) (t :: k1) -> RawElement d

+ Reflex.Dom.Builder.Class: [_inputElementConfig_elementConfig] :: InputElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> ElementConfig er t s

+ Reflex.Dom.Builder.Class: [_inputElementConfig_initialChecked] :: InputElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> Bool

+ Reflex.Dom.Builder.Class: [_inputElementConfig_initialValue] :: InputElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> Text

+ Reflex.Dom.Builder.Class: [_inputElementConfig_setChecked] :: InputElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> Maybe (Event t Bool)

+ Reflex.Dom.Builder.Class: [_inputElementConfig_setValue] :: InputElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> Maybe (Event t Text)

+ Reflex.Dom.Builder.Class: [_inputElement_checkedChange] :: InputElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Event t Bool

+ Reflex.Dom.Builder.Class: [_inputElement_checked] :: InputElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Dynamic t Bool

+ Reflex.Dom.Builder.Class: [_inputElement_element] :: InputElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Element er d t

+ Reflex.Dom.Builder.Class: [_inputElement_files] :: InputElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Dynamic t [File]

+ Reflex.Dom.Builder.Class: [_inputElement_hasFocus] :: InputElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Dynamic t Bool

+ Reflex.Dom.Builder.Class: [_inputElement_input] :: InputElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Event t Text

+ Reflex.Dom.Builder.Class: [_inputElement_raw] :: InputElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> RawInputElement d

+ Reflex.Dom.Builder.Class: [_inputElement_value] :: InputElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Dynamic t Text

+ Reflex.Dom.Builder.Class: [_rawElementConfig_eventSpec] :: RawElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> EventSpec s er

+ Reflex.Dom.Builder.Class: [_rawElementConfig_modifyAttributes] :: RawElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1) -> Maybe (Event t (Map AttributeName (Maybe Text)))

+ Reflex.Dom.Builder.Class: [_selectElementConfig_elementConfig] :: SelectElementConfig (er :: EventTag -> Type) (t :: k) (m :: k1) -> ElementConfig er t m

+ Reflex.Dom.Builder.Class: [_selectElementConfig_initialValue] :: SelectElementConfig (er :: EventTag -> Type) (t :: k) (m :: k1) -> Text

+ Reflex.Dom.Builder.Class: [_selectElementConfig_setValue] :: SelectElementConfig (er :: EventTag -> Type) (t :: k) (m :: k1) -> Maybe (Event t Text)

+ Reflex.Dom.Builder.Class: [_selectElement_change] :: SelectElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Event t Text

+ Reflex.Dom.Builder.Class: [_selectElement_element] :: SelectElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Element er d t

+ Reflex.Dom.Builder.Class: [_selectElement_hasFocus] :: SelectElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Dynamic t Bool

+ Reflex.Dom.Builder.Class: [_selectElement_raw] :: SelectElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> RawSelectElement d

+ Reflex.Dom.Builder.Class: [_selectElement_value] :: SelectElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Dynamic t Text

+ Reflex.Dom.Builder.Class: [_textAreaElementConfig_elementConfig] :: TextAreaElementConfig (er :: EventTag -> Type) (t :: k) (m :: k1) -> ElementConfig er t m

+ Reflex.Dom.Builder.Class: [_textAreaElementConfig_initialValue] :: TextAreaElementConfig (er :: EventTag -> Type) (t :: k) (m :: k1) -> Text

+ Reflex.Dom.Builder.Class: [_textAreaElementConfig_setValue] :: TextAreaElementConfig (er :: EventTag -> Type) (t :: k) (m :: k1) -> Maybe (Event t Text)

+ Reflex.Dom.Builder.Class: [_textAreaElement_element] :: TextAreaElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Element er d t

+ Reflex.Dom.Builder.Class: [_textAreaElement_hasFocus] :: TextAreaElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Dynamic t Bool

+ Reflex.Dom.Builder.Class: [_textAreaElement_input] :: TextAreaElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Event t Text

+ Reflex.Dom.Builder.Class: [_textAreaElement_raw] :: TextAreaElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> RawTextAreaElement d

+ Reflex.Dom.Builder.Class: [_textAreaElement_value] :: TextAreaElement (er :: EventTag -> Type) (d :: k) (t :: k1) -> Dynamic t Text

+ Reflex.Dom.Builder.Class: [_textNodeConfig_initialContents] :: TextNodeConfig (t :: k) -> {-# UNPACK #-} !Text

+ Reflex.Dom.Builder.Class: [_textNodeConfig_setContents] :: TextNodeConfig (t :: k) -> !Maybe (Event t Text)

+ Reflex.Dom.Builder.Class: [_textNode_raw] :: TextNode (d :: k) (t :: k1) -> RawTextNode d

+ Reflex.Dom.Builder.Class: addEventSpecFlags :: forall proxy (en :: EventTag) er. DomSpace d => proxy d -> EventName en -> (Maybe (er en) -> EventFlags) -> EventSpec d er -> EventSpec d er

+ Reflex.Dom.Builder.Class: askDocument :: HasDocument m => m (RawDocument (DomBuilderSpace m))

+ Reflex.Dom.Builder.Class: class (Monad m, Reflex t, DomSpace DomBuilderSpace m, NotReady t m, Adjustable t m) => DomBuilder t (m :: Type -> Type) | m -> t where {

+ Reflex.Dom.Builder.Class: class (Reflex t, Monad m) => DomRenderHook (t :: k) (m :: Type -> Type) | m -> t

+ Reflex.Dom.Builder.Class: class Default EventSpec d EventResult => DomSpace (d :: k) where {

+ Reflex.Dom.Builder.Class: class Monad m => HasDocument (m :: Type -> Type)

+ Reflex.Dom.Builder.Class: class HasDomEvent (t :: k) target (eventName :: EventTag) | target -> t where {

+ Reflex.Dom.Builder.Class: class ModifyAttributes (t :: k) a | a -> t

+ Reflex.Dom.Builder.Class: class MonadTransControl t => MonadTransControlStateless (t :: Type -> Type -> Type -> Type)

+ Reflex.Dom.Builder.Class: class DomBuilder t m => MountableDomBuilder t (m :: Type -> Type) where {

+ Reflex.Dom.Builder.Class: commentNode :: DomBuilder t m => CommentNodeConfig t -> m (CommentNode (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: commentNodeConfig_initialContents :: forall k (t :: k) f. Functor f => (Text -> f Text) -> CommentNodeConfig t -> f (CommentNodeConfig t)

+ Reflex.Dom.Builder.Class: commentNodeConfig_setContents :: forall {k} (t :: k). Reflex t => Lens (CommentNodeConfig t) (CommentNodeConfig t) (Event t Text) (Event t Text)

+ Reflex.Dom.Builder.Class: data CommentNodeConfig (t :: k)

+ Reflex.Dom.Builder.Class: data Element (er :: EventTag -> Type) (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: data ElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1)

+ Reflex.Dom.Builder.Class: data InputElement (er :: EventTag -> Type) (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: data InputElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1)

+ Reflex.Dom.Builder.Class: data RawElementConfig (er :: EventTag -> Type) (t :: k) (s :: k1)

+ Reflex.Dom.Builder.Class: data SelectElement (er :: EventTag -> Type) (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: data SelectElementConfig (er :: EventTag -> Type) (t :: k) (m :: k1)

+ Reflex.Dom.Builder.Class: data TextAreaElement (er :: EventTag -> Type) (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: data TextAreaElementConfig (er :: EventTag -> Type) (t :: k) (m :: k1)

+ Reflex.Dom.Builder.Class: data TextNodeConfig (t :: k)

+ Reflex.Dom.Builder.Class: element :: forall (er :: EventTag -> Type) a. DomBuilder t m => Text -> ElementConfig er t (DomBuilderSpace m) -> m a -> m (Element er (DomBuilderSpace m) t, a)

+ Reflex.Dom.Builder.Class: elementConfig_eventSpec :: forall (er1 :: EventTag -> Type) k1 (t :: k1) k2 (s1 :: k2) (er2 :: EventTag -> Type) k3 (s2 :: k3) f. Functor f => (EventSpec s1 er1 -> f (EventSpec s2 er2)) -> ElementConfig er1 t s1 -> f (ElementConfig er2 t s2)

+ Reflex.Dom.Builder.Class: elementConfig_initialAttributes :: forall (er :: EventTag -> Type) k1 (t :: k1) k2 (s :: k2) f. Functor f => (Map AttributeName Text -> f (Map AttributeName Text)) -> ElementConfig er t s -> f (ElementConfig er t s)

+ Reflex.Dom.Builder.Class: elementConfig_modifyAttributes :: forall {k1} {k2} (t :: k1) (er :: EventTag -> Type) (m :: k2). Reflex t => Lens' (ElementConfig er t m) (Event t (Map AttributeName (Maybe Text)))

+ Reflex.Dom.Builder.Class: elementConfig_namespace :: forall (er :: EventTag -> Type) k1 (t :: k1) k2 (s :: k2) f. Functor f => (Maybe Namespace -> f (Maybe Namespace)) -> ElementConfig er t s -> f (ElementConfig er t s)

+ Reflex.Dom.Builder.Class: extractRawElementConfig :: forall {k1} {k2} (er :: EventTag -> Type) (t :: k1) (m :: k2). ElementConfig er t m -> RawElementConfig er t m

+ Reflex.Dom.Builder.Class: fromStT :: forall (t :: (Type -> Type) -> Type -> Type) proxy a. MonadTransControlStateless t => proxy t -> StT t a -> a

+ Reflex.Dom.Builder.Class: inputElement :: forall (er :: EventTag -> Type). DomBuilder t m => InputElementConfig er t (DomBuilderSpace m) -> m (InputElement er (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: inputElementConfig_elementConfig :: forall (er1 :: EventTag -> Type) k1 (t :: k1) k2 (s1 :: k2) (er2 :: EventTag -> Type) k3 (s2 :: k3) f. Functor f => (ElementConfig er1 t s1 -> f (ElementConfig er2 t s2)) -> InputElementConfig er1 t s1 -> f (InputElementConfig er2 t s2)

+ Reflex.Dom.Builder.Class: inputElementConfig_initialChecked :: forall (er :: EventTag -> Type) k1 (t :: k1) k2 (s :: k2) f. Functor f => (Bool -> f Bool) -> InputElementConfig er t s -> f (InputElementConfig er t s)

+ Reflex.Dom.Builder.Class: inputElementConfig_initialValue :: forall (er :: EventTag -> Type) k1 (t :: k1) k2 (s :: k2) f. Functor f => (Text -> f Text) -> InputElementConfig er t s -> f (InputElementConfig er t s)

+ Reflex.Dom.Builder.Class: inputElementConfig_setChecked :: forall {k1} {k2} (t :: k1) (er :: EventTag -> Type) (m :: k2). Reflex t => Lens' (InputElementConfig er t m) (Event t Bool)

+ Reflex.Dom.Builder.Class: inputElementConfig_setValue :: forall {k1} {k2} (t :: k1) (er :: EventTag -> Type) (m :: k2). Reflex t => Lens' (InputElementConfig er t m) (Event t Text)

+ Reflex.Dom.Builder.Class: liftCommentNode :: forall f t (m :: Type -> Type). (MonadTrans f, DomBuilder t m) => CommentNodeConfig t -> f m (CommentNode (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: liftElement :: forall t f (m :: Type -> Type) (er :: EventTag -> Type) a. LiftDomBuilder t f m => Text -> ElementConfig er t (DomBuilderSpace m) -> f m a -> f m (Element er (DomBuilderSpace m) t, a)

+ Reflex.Dom.Builder.Class: liftElementConfig :: forall {k1} {k2} (er :: EventTag -> Type) (t :: k1) (s :: k2). ElementConfig er t s -> ElementConfig er t s

+ Reflex.Dom.Builder.Class: liftTextNode :: forall f t (m :: Type -> Type). (MonadTrans f, DomBuilder t m) => TextNodeConfig t -> f m (TextNode (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: liftWithStateless :: (Monad m, MonadTransControlStateless t) => (RunStateless t -> m a) -> t m a

+ Reflex.Dom.Builder.Class: modifyAttributes :: ModifyAttributes t a => Lens' a (Event t (Map AttributeName (Maybe Text)))

+ Reflex.Dom.Builder.Class: newtype CommentNode (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: newtype TextNode (d :: k) (t :: k1)

+ Reflex.Dom.Builder.Class: placeRawElement :: DomBuilder t m => RawElement (DomBuilderSpace m) -> m ()

+ Reflex.Dom.Builder.Class: rawElementConfig_eventSpec :: forall (er1 :: EventTag -> Type) k1 (t :: k1) k2 (s1 :: k2) (er2 :: EventTag -> Type) k3 (s2 :: k3) f. Functor f => (EventSpec s1 er1 -> f (EventSpec s2 er2)) -> RawElementConfig er1 t s1 -> f (RawElementConfig er2 t s2)

+ Reflex.Dom.Builder.Class: rawElementConfig_modifyAttributes :: forall {k1} {k2} (t :: k1) (er :: EventTag -> Type) (m :: k2). Reflex t => Lens' (RawElementConfig er t m) (Event t (Map AttributeName (Maybe Text)))

+ Reflex.Dom.Builder.Class: selectElement :: forall (er :: EventTag -> Type) a. DomBuilder t m => SelectElementConfig er t (DomBuilderSpace m) -> m a -> m (SelectElement er (DomBuilderSpace m) t, a)

+ Reflex.Dom.Builder.Class: selectElementConfig_elementConfig :: forall (er1 :: EventTag -> Type) k1 (t :: k1) k2 (m1 :: k2) (er2 :: EventTag -> Type) k3 (m2 :: k3) f. Functor f => (ElementConfig er1 t m1 -> f (ElementConfig er2 t m2)) -> SelectElementConfig er1 t m1 -> f (SelectElementConfig er2 t m2)

+ Reflex.Dom.Builder.Class: selectElementConfig_initialValue :: forall (er :: EventTag -> Type) k1 (t :: k1) k2 (m :: k2) f. Functor f => (Text -> f Text) -> SelectElementConfig er t m -> f (SelectElementConfig er t m)

+ Reflex.Dom.Builder.Class: selectElementConfig_setValue :: forall {k1} {k2} (t :: k1) (er :: EventTag -> Type) (m :: k2). Reflex t => Lens' (SelectElementConfig er t m) (Event t Text)

+ Reflex.Dom.Builder.Class: stTCoercion :: MonadTransControlStateless t => proxy t -> Coercion (StT t a) a

+ Reflex.Dom.Builder.Class: textAreaElement :: forall (er :: EventTag -> Type). DomBuilder t m => TextAreaElementConfig er t (DomBuilderSpace m) -> m (TextAreaElement er (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: textAreaElementConfig_elementConfig :: forall (er1 :: EventTag -> Type) k1 (t :: k1) k2 (m1 :: k2) (er2 :: EventTag -> Type) k3 (m2 :: k3) f. Functor f => (ElementConfig er1 t m1 -> f (ElementConfig er2 t m2)) -> TextAreaElementConfig er1 t m1 -> f (TextAreaElementConfig er2 t m2)

+ Reflex.Dom.Builder.Class: textAreaElementConfig_initialValue :: forall (er :: EventTag -> Type) k1 (t :: k1) k2 (m :: k2) f. Functor f => (Text -> f Text) -> TextAreaElementConfig er t m -> f (TextAreaElementConfig er t m)

+ Reflex.Dom.Builder.Class: textAreaElementConfig_setValue :: forall {k1} {k2} (t :: k1) (er :: EventTag -> Type) (m :: k2). Reflex t => Lens' (TextAreaElementConfig er t m) (Event t Text)

+ Reflex.Dom.Builder.Class: textNode :: DomBuilder t m => TextNodeConfig t -> m (TextNode (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class: textNodeConfig_initialContents :: forall k (t :: k) f. Functor f => (Text -> f Text) -> TextNodeConfig t -> f (TextNodeConfig t)

+ Reflex.Dom.Builder.Class: textNodeConfig_setContents :: forall {k} (t :: k). Reflex t => Lens' (TextNodeConfig t) (Event t Text)

+ Reflex.Dom.Builder.Class: toStT :: forall (t :: (Type -> Type) -> Type -> Type) proxy a. MonadTransControlStateless t => proxy t -> a -> StT t a

+ Reflex.Dom.Builder.Class: type DomBuilderSpace (m :: Type -> Type);

+ Reflex.Dom.Builder.Class: type DomEventType target (eventName :: EventTag);

+ Reflex.Dom.Builder.Class: type DomFragment (m :: Type -> Type);

+ Reflex.Dom.Builder.Class: type EventSpec (d :: k) :: EventTag -> Type -> Type;

+ Reflex.Dom.Builder.Class: type LiftDomBuilder t (f :: Type -> Type -> Type -> Type) (m :: Type -> Type) = (Reflex t, MonadTransControlStateless f, Monad m, DomBuilder t m, DomBuilderSpace f m ~ DomBuilderSpace m)

+ Reflex.Dom.Builder.Class: type RawCommentNode (d :: k);

+ Reflex.Dom.Builder.Class: type RawDocument (d :: k);

+ Reflex.Dom.Builder.Class: type RawElement (d :: k);

+ Reflex.Dom.Builder.Class: type RawInputElement (d :: k);

+ Reflex.Dom.Builder.Class: type RawSelectElement (d :: k);

+ Reflex.Dom.Builder.Class: type RawTextAreaElement (d :: k);

+ Reflex.Dom.Builder.Class: type RawTextNode (d :: k);

+ Reflex.Dom.Builder.Class: type SetValue a;

+ Reflex.Dom.Builder.Class: type RunStateless (t :: Type -> Type -> Type -> Type) = forall (n :: Type -> Type) b. Monad n => t n b -> n b

+ Reflex.Dom.Builder.Class: withRenderHook :: DomRenderHook t m => (forall x. () => JSM x -> JSM x) -> m a -> m a

+ Reflex.Dom.Builder.Class: wrapRawElement :: forall (er :: EventTag -> Type). DomBuilder t m => RawElement (DomBuilderSpace m) -> RawElementConfig er t (DomBuilderSpace m) -> m (Element er (DomBuilderSpace m) t)

+ Reflex.Dom.Builder.Class.Events: EventResult :: EventResultType en -> EventResult (en :: EventTag)

+ Reflex.Dom.Builder.Class.Events: [unEventResult] :: EventResult (en :: EventTag) -> EventResultType en

+ Reflex.Dom.Builder.Class.Events: data EventName (a :: EventTag)

+ Reflex.Dom.Builder.Class.Events: newtype EventResult (en :: EventTag)

+ Reflex.Dom.Builder.Class.Events: type family EventResultType (en :: EventTag)

+ Reflex.Dom.Builder.Hydratable: HydratableT :: m a -> HydratableT (m :: Type -> Type) a

+ Reflex.Dom.Builder.Hydratable: [runHydratableT] :: HydratableT (m :: Type -> Type) a -> m a

+ Reflex.Dom.Builder.Hydratable: makeHydratable :: forall t (er :: EventTag -> Type) m. Reflex t => ElementConfig er t m -> ElementConfig er t m

+ Reflex.Dom.Builder.Hydratable: newtype HydratableT (m :: Type -> Type) a

+ Reflex.Dom.Builder.Immediate: EventFilterTriggerRef :: IORef (Maybe (EventTrigger t (er en))) -> EventFilterTriggerRef t (er :: EventTag -> Type) (en :: EventTag)

+ Reflex.Dom.Builder.Immediate: GhcjsDomEvent :: EventType en -> GhcjsDomEvent (en :: EventTag)

+ Reflex.Dom.Builder.Immediate: GhcjsDomHandler1 :: (forall (x :: EventTag). () => a x -> JSM (b x)) -> GhcjsDomHandler1 (a :: EventTag -> Type) (b :: EventTag -> Type)

+ Reflex.Dom.Builder.Immediate: GhcjsEventFilter :: (GhcjsDomEvent en -> JSM (EventFlags, JSM (Maybe (er en)))) -> GhcjsEventFilter (er :: EventTag -> Type) (en :: EventTag)

+ Reflex.Dom.Builder.Immediate: GhcjsEventHandler :: (forall (en :: EventTag). () => (EventName en, GhcjsDomEvent en) -> JSM (Maybe (er en))) -> GhcjsEventHandler (er :: EventTag -> Type)

+ Reflex.Dom.Builder.Immediate: GhcjsEventSpec :: DMap EventName (GhcjsEventFilter er) -> GhcjsEventHandler er -> GhcjsEventSpec (er :: EventTag -> Type)

+ Reflex.Dom.Builder.Immediate: HydrationDomBuilderEnv :: {-# UNPACK #-} !Document -> !Either Node (IORef Node) -> {-# UNPACK #-} !IORef Word -> !JSM () -> {-# UNPACK #-} !IORef HydrationMode -> !Event t () -> {-# UNPACK #-} !IORef (HydrationRunnerT t m ()) -> HydrationDomBuilderEnv t (m :: Type -> Type)

+ Reflex.Dom.Builder.Immediate: HydrationDomBuilderT :: ReaderT (HydrationDomBuilderEnv t m) (DomRenderHookT t m) a -> HydrationDomBuilderT (s :: k) t (m :: Type -> Type) a

+ Reflex.Dom.Builder.Immediate: HydrationRunnerT :: StateT HydrationState (ReaderT Node (DomRenderHookT t m)) a -> HydrationRunnerT t (m :: Type -> Type) a

+ Reflex.Dom.Builder.Immediate: Just1 :: f a -> Maybe1 (f :: k -> Type) (a :: k)

+ Reflex.Dom.Builder.Immediate: Nothing1 :: Maybe1 (f :: k -> Type) (a :: k)

+ Reflex.Dom.Builder.Immediate: Window :: EventSelector t (WrapArg EventResult EventName) -> Window -> Window (t :: k)

+ Reflex.Dom.Builder.Immediate: WindowConfig :: WindowConfig (t :: k)

+ Reflex.Dom.Builder.Immediate: [_ghcjsEventSpec_filters] :: GhcjsEventSpec (er :: EventTag -> Type) -> DMap EventName (GhcjsEventFilter er)

+ Reflex.Dom.Builder.Immediate: [_ghcjsEventSpec_handler] :: GhcjsEventSpec (er :: EventTag -> Type) -> GhcjsEventHandler er

+ Reflex.Dom.Builder.Immediate: [_hydrationDomBuilderEnv_commitAction] :: HydrationDomBuilderEnv t (m :: Type -> Type) -> !JSM ()

+ Reflex.Dom.Builder.Immediate: [_hydrationDomBuilderEnv_delayed] :: HydrationDomBuilderEnv t (m :: Type -> Type) -> {-# UNPACK #-} !IORef (HydrationRunnerT t m ())

+ Reflex.Dom.Builder.Immediate: [_hydrationDomBuilderEnv_document] :: HydrationDomBuilderEnv t (m :: Type -> Type) -> {-# UNPACK #-} !Document

+ Reflex.Dom.Builder.Immediate: [_hydrationDomBuilderEnv_hydrationMode] :: HydrationDomBuilderEnv t (m :: Type -> Type) -> {-# UNPACK #-} !IORef HydrationMode

+ Reflex.Dom.Builder.Immediate: [_hydrationDomBuilderEnv_parent] :: HydrationDomBuilderEnv t (m :: Type -> Type) -> !Either Node (IORef Node)

+ Reflex.Dom.Builder.Immediate: [_hydrationDomBuilderEnv_switchover] :: HydrationDomBuilderEnv t (m :: Type -> Type) -> !Event t ()

+ Reflex.Dom.Builder.Immediate: [_hydrationDomBuilderEnv_unreadyChildren] :: HydrationDomBuilderEnv t (m :: Type -> Type) -> {-# UNPACK #-} !IORef Word

+ Reflex.Dom.Builder.Immediate: [_window_events] :: Window (t :: k) -> EventSelector t (WrapArg EventResult EventName)

+ Reflex.Dom.Builder.Immediate: [_window_raw] :: Window (t :: k) -> Window

+ Reflex.Dom.Builder.Immediate: [unGhcjsDomEvent] :: GhcjsDomEvent (en :: EventTag) -> EventType en

+ Reflex.Dom.Builder.Immediate: [unGhcjsDomHandler1] :: GhcjsDomHandler1 (a :: EventTag -> Type) (b :: EventTag -> Type) -> forall (x :: EventTag). () => a x -> JSM (b x)

+ Reflex.Dom.Builder.Immediate: [unGhcjsEventHandler] :: GhcjsEventHandler (er :: EventTag -> Type) -> forall (en :: EventTag). () => (EventName en, GhcjsDomEvent en) -> JSM (Maybe (er en))

+ Reflex.Dom.Builder.Immediate: [unHydrationDomBuilderT] :: HydrationDomBuilderT (s :: k) t (m :: Type -> Type) a -> ReaderT (HydrationDomBuilderEnv t m) (DomRenderHookT t m) a

+ Reflex.Dom.Builder.Immediate: [unHydrationRunnerT] :: HydrationRunnerT t (m :: Type -> Type) a -> StateT HydrationState (ReaderT Node (DomRenderHookT t m)) a

+ Reflex.Dom.Builder.Immediate: addHydrationStep :: forall {k} (m :: Type -> Type) t (s :: k). MonadIO m => HydrationRunnerT t m () -> HydrationDomBuilderT s t m ()

+ Reflex.Dom.Builder.Immediate: addHydrationStepWithSetup :: forall {k} m a t (s :: k). MonadIO m => m a -> (a -> HydrationRunnerT t m ()) -> HydrationDomBuilderT s t m ()

+ Reflex.Dom.Builder.Immediate: append :: forall {k} (m :: Type -> Type) (s :: k) t. MonadJSM m => Node -> HydrationDomBuilderT s t m ()

+ Reflex.Dom.Builder.Immediate: askDocument :: HasDocument m => m (RawDocument (DomBuilderSpace m))

+ Reflex.Dom.Builder.Immediate: askEvents :: forall {k} (m :: Type -> Type) (s :: k) t. Monad m => HydrationDomBuilderT s t m (Chan [DSum (EventTriggerRef t) TriggerInvocation])

+ Reflex.Dom.Builder.Immediate: askParent :: forall (m :: Type -> Type) t. Monad m => HydrationRunnerT t m Node

+ Reflex.Dom.Builder.Immediate: class Monad m => HasDocument (m :: Type -> Type)

+ Reflex.Dom.Builder.Immediate: data GhcjsEventSpec (er :: EventTag -> Type)

+ Reflex.Dom.Builder.Immediate: data HydrationDomBuilderEnv t (m :: Type -> Type)

+ Reflex.Dom.Builder.Immediate: data Maybe1 (f :: k -> Type) (a :: k)

+ Reflex.Dom.Builder.Immediate: data Window (t :: k)

+ Reflex.Dom.Builder.Immediate: data WindowConfig (t :: k)

+ Reflex.Dom.Builder.Immediate: defaultDomEventHandler :: forall e (en :: EventTag). IsElement e => e -> EventName en -> EventM e (EventType en) (Maybe (EventResult en))

+ Reflex.Dom.Builder.Immediate: defaultDomWindowEventHandler :: forall (en :: EventTag). Window -> EventName en -> EventM Window (EventType en) (Maybe (EventResult en))

+ Reflex.Dom.Builder.Immediate: drawChildUpdate :: forall {k1} {k2} (m :: Type -> Type) t k3 (s :: k1) f (a :: k2). MonadJSM m => HydrationDomBuilderEnv t m -> (IORef (ChildReadyState k3) -> JSM ()) -> HydrationDomBuilderT s t m (f a) -> DomRenderHookT t m (Compose (TraverseChild t m k3) f a)

+ Reflex.Dom.Builder.Immediate: elementInternal :: forall (m :: Type -> Type) t (er :: EventTag -> Type) a. (MonadJSM m, Reflex t, MonadReflexCreateTrigger t m, MonadFix m) => Text -> ElementConfig er t HydrationDomSpace -> HydrationDomBuilderT HydrationDomSpace t m a -> HydrationDomBuilderT HydrationDomSpace t m (Element er HydrationDomSpace t, a)

+ Reflex.Dom.Builder.Immediate: elementOnEventName :: forall e (en :: EventTag). IsElement e => EventName en -> e -> EventM e (EventType en) () -> JSM (JSM ())

+ Reflex.Dom.Builder.Immediate: getHydrationMode :: forall {k} (m :: Type -> Type) (s :: k) t. MonadIO m => HydrationDomBuilderT s t m HydrationMode

+ Reflex.Dom.Builder.Immediate: ghcjsEventSpec_filters :: forall (er :: EventTag -> Type) f. Functor f => (DMap EventName (GhcjsEventFilter er) -> f (DMap EventName (GhcjsEventFilter er))) -> GhcjsEventSpec er -> f (GhcjsEventSpec er)

+ Reflex.Dom.Builder.Immediate: ghcjsEventSpec_handler :: forall (er :: EventTag -> Type) f. Functor f => (GhcjsEventHandler er -> f (GhcjsEventHandler er)) -> GhcjsEventSpec er -> f (GhcjsEventSpec er)

+ Reflex.Dom.Builder.Immediate: hoistTraverseIntMapWithKeyWithAdjust :: forall {k} t (m :: Type -> Type) p v' (s :: k) v. (Adjustable t m, MonadHold t m, MonadJSM m, MonadFix m, Monoid (p (TraverseChild t m Int v')), Functor p, PatchTarget (p (TraverseChild t m Int v')) ~ IntMap (TraverseChild t m Int v'), Patch (p (TraverseChild t m Int v')), RawDocument (DomBuilderSpace (HydrationDomBuilderT s t m)) ~ Document) => ((Key -> v -> DomRenderHookT t m (TraverseChild t m Int v')) -> IntMap v -> Event t (p v) -> DomRenderHookT t m (IntMap (TraverseChild t m Int v'), Event t (p (TraverseChild t m Int v')))) -> (p (TraverseChild t m Int v') -> IntMap (IORef (ChildReadyState Int)) -> IO (IntMap (IORef (ChildReadyState Int)))) -> (IORef (IntMap Text) -> Text -> p (TraverseChild t m Int v') -> JSM ()) -> (Key -> v -> HydrationDomBuilderT s t m v') -> IntMap v -> Event t (p v) -> HydrationDomBuilderT s t m (IntMap v', Event t (p v'))

+ Reflex.Dom.Builder.Immediate: hoistTraverseWithKeyWithAdjust :: forall {k1} {k2} t (m :: Type -> Type) k3 p v' (s :: k2) v. (Adjustable t m, MonadHold t m, GCompare k3, MonadJSM m, MonadFix m, Patch (p k3 (Compose (TraverseChild t m (Some k3)) v')), PatchTarget (p k3 (Compose (TraverseChild t m (Some k3)) v')) ~ DMap k3 (Compose (TraverseChild t m (Some k3)) v'), Monoid (p k3 (Compose (TraverseChild t m (Some k3)) v')), RawDocument (DomBuilderSpace (HydrationDomBuilderT s t m)) ~ Document) => (forall (vv :: k1 -> Type) (vv' :: k1 -> Type). () => (forall (a :: k1). () => k3 a -> vv a -> DomRenderHookT t m (vv' a)) -> DMap k3 vv -> Event t (p k3 vv) -> DomRenderHookT t m (DMap k3 vv', Event t (p k3 vv'))) -> (forall (vv :: k1 -> Type) (vv' :: k1 -> Type). () => (forall (a :: k1). () => vv a -> vv' a) -> p k3 vv -> p k3 vv') -> (p k3 (Compose (TraverseChild t m (Some k3)) v') -> DMap k3 (Constant (IORef (ChildReadyState (Some k3))) :: k1 -> Type) -> IO (DMap k3 (Constant (IORef (ChildReadyState (Some k3))) :: k1 -> Type))) -> (IORef (Map (Some k3) Text) -> Text -> p k3 (Compose (TraverseChild t m (Some k3)) v') -> JSM ()) -> (forall (a :: k1). () => k3 a -> v a -> HydrationDomBuilderT s t m (v' a)) -> DMap k3 v -> Event t (p k3 v) -> HydrationDomBuilderT s t m (DMap k3 v', Event t (p k3 v'))

+ Reflex.Dom.Builder.Immediate: hydrateComment :: forall (m :: Type -> Type) t. (MonadJSM m, Reflex t, MonadFix m) => Document -> Text -> Maybe (Event t Text) -> HydrationRunnerT t m Comment

+ Reflex.Dom.Builder.Immediate: insertAfterPreviousNode :: forall (m :: Type -> Type) node t. (MonadJSM m, IsNode node) => node -> HydrationRunnerT t m ()

+ Reflex.Dom.Builder.Immediate: mkHasFocus :: forall {k1} {k2} m (d :: k1) (t :: k2) (er :: EventTag -> Type). (HasDocument m, MonadJSM m, IsNode (RawElement d), MonadHold t m, Reflex t, IsDocumentOrShadowRoot (RawDocument (DomBuilderSpace m))) => Element er d t -> m (Dynamic t Bool)

+ Reflex.Dom.Builder.Immediate: newtype EventFilterTriggerRef t (er :: EventTag -> Type) (en :: EventTag)

+ Reflex.Dom.Builder.Immediate: newtype EventTriggerRef t a

+ Reflex.Dom.Builder.Immediate: newtype GhcjsDomEvent (en :: EventTag)

+ Reflex.Dom.Builder.Immediate: newtype GhcjsDomHandler1 (a :: EventTag -> Type) (b :: EventTag -> Type)

+ Reflex.Dom.Builder.Immediate: newtype GhcjsEventFilter (er :: EventTag -> Type) (en :: EventTag)

+ Reflex.Dom.Builder.Immediate: newtype GhcjsEventHandler (er :: EventTag -> Type)

+ Reflex.Dom.Builder.Immediate: newtype HydrationDomBuilderT (s :: k) t (m :: Type -> Type) a

+ Reflex.Dom.Builder.Immediate: newtype HydrationRunnerT t (m :: Type -> Type) a

+ Reflex.Dom.Builder.Immediate: runHydrationDomBuilderT :: forall {k} m t (s :: k) a. (MonadFix m, PerformEvent t m, MonadReflexCreateTrigger t m, MonadJSM (Performable m), MonadRef m, Ref m ~ IORef) => HydrationDomBuilderT s t m a -> HydrationDomBuilderEnv t m -> Chan [DSum (EventTriggerRef t) TriggerInvocation] -> m a

+ Reflex.Dom.Builder.Immediate: setPreviousNode :: forall (m :: Type -> Type) t. Monad m => Maybe Node -> HydrationRunnerT t m ()

+ Reflex.Dom.Builder.Immediate: showEventName :: forall (en :: EventTag). EventName en -> String

+ Reflex.Dom.Builder.Immediate: textNodeInternal :: forall t (m :: Type -> Type). (Adjustable t m, MonadHold t m, MonadJSM m, MonadFix m) => TextNodeConfig t -> HydrationDomBuilderT HydrationDomSpace t m (TextNode HydrationDomSpace t)

+ Reflex.Dom.Builder.Immediate: traverseDMapWithKeyWithAdjust' :: forall {k1} (s :: k1) t (m :: Type -> Type) k2 v v'. (Adjustable t m, MonadHold t m, MonadFix m, MonadJSM m, GCompare k2, RawDocument (DomBuilderSpace (HydrationDomBuilderT s t m)) ~ Document) => (forall a. () => k2 a -> v a -> HydrationDomBuilderT s t m (v' a)) -> DMap k2 v -> Event t (PatchDMap k2 v) -> HydrationDomBuilderT s t m (DMap k2 v', Event t (PatchDMap k2 v'))

+ Reflex.Dom.Builder.Immediate: traverseIntMapWithKeyWithAdjust' :: forall {k} (s :: k) t (m :: Type -> Type) v v'. (Adjustable t m, MonadJSM m, MonadFix m, MonadHold t m, RawDocument (DomBuilderSpace (HydrationDomBuilderT s t m)) ~ Document) => (Key -> v -> HydrationDomBuilderT s t m v') -> IntMap v -> Event t (PatchIntMap v) -> HydrationDomBuilderT s t m (IntMap v', Event t (PatchIntMap v'))

+ Reflex.Dom.Builder.Immediate: type SupportsHydrationDomBuilder t (m :: Type -> Type) = (Reflex t, MonadJSM m, MonadHold t m, MonadFix m, MonadReflexCreateTrigger t m, MonadRef m, Ref m ~ Ref JSM, Adjustable t m, PrimMonad m, PerformEvent t m, MonadJSM Performable m)

+ Reflex.Dom.Builder.Immediate: type family EventType (en :: EventTag)

+ Reflex.Dom.Builder.Immediate: windowOnEventName :: forall (en :: EventTag). EventName en -> Window -> EventM Window (EventType en) () -> JSM (JSM ())

+ Reflex.Dom.Builder.Immediate: withIsEvent :: forall (en :: EventTag) r. EventName en -> (IsEvent (EventType en) => r) -> r

+ Reflex.Dom.Builder.Immediate: wrap :: forall {k1} (s :: k1) m (er :: EventTag -> Type) t. (MonadJSM m, DomRenderHook t m, EventSpec s ~ GhcjsEventSpec) => Chan [DSum (EventTriggerRef t) TriggerInvocation] -> Element -> RawElementConfig er t s -> m (DMap EventName (EventFilterTriggerRef t er))

+ Reflex.Dom.Builder.Immediate: wrapDomEventsMaybe :: forall (m :: Type -> Type) t e f. (MonadJSM m, MonadReflexCreateTrigger t m) => e -> (forall (en :: EventTag). IsEvent (EventType en) => EventName en -> EventM e (EventType en) (Maybe (f en))) -> (forall (en :: EventTag). () => EventName en -> e -> EventM e (EventType en) () -> JSM (JSM ())) -> ImmediateDomBuilderT t m (EventSelector t (WrapArg f EventName))

+ Reflex.Dom.Builder.Immediate: wrapWindow :: forall (m :: Type -> Type) t. (MonadJSM m, MonadReflexCreateTrigger t m) => Window -> WindowConfig t -> HydrationDomBuilderT GhcjsDomSpace t m (Window t)

+ Reflex.Dom.Builder.InputDisabled: InputDisabledT :: m a -> InputDisabledT (m :: Type -> Type) a

+ Reflex.Dom.Builder.InputDisabled: [runInputDisabledT] :: InputDisabledT (m :: Type -> Type) a -> m a

+ Reflex.Dom.Builder.InputDisabled: disableElementConfig :: forall t (er :: EventTag -> Type) m. Reflex t => ElementConfig er t m -> ElementConfig er t m

+ Reflex.Dom.Builder.InputDisabled: newtype InputDisabledT (m :: Type -> Type) a

+ Reflex.Dom.Builder.Static: StaticDomBuilderEnv :: Bool -> Maybe (Behavior t Text) -> IORef Int -> StaticDomBuilderEnv (t :: k)

+ Reflex.Dom.Builder.Static: StaticDomBuilderT :: ReaderT (StaticDomBuilderEnv t) (StateT [Behavior t Builder] m) a -> StaticDomBuilderT (t :: k) (m :: Type -> Type) a

+ Reflex.Dom.Builder.Static: [_staticDomBuilderEnv_nextRunWithReplaceKey] :: StaticDomBuilderEnv (t :: k) -> IORef Int

+ Reflex.Dom.Builder.Static: [_staticDomBuilderEnv_selectValue] :: StaticDomBuilderEnv (t :: k) -> Maybe (Behavior t Text)

+ Reflex.Dom.Builder.Static: [_staticDomBuilderEnv_shouldEscape] :: StaticDomBuilderEnv (t :: k) -> Bool

+ Reflex.Dom.Builder.Static: [unStaticDomBuilderT] :: StaticDomBuilderT (t :: k) (m :: Type -> Type) a -> ReaderT (StaticDomBuilderEnv t) (StateT [Behavior t Builder] m) a

+ Reflex.Dom.Builder.Static: data StaticDomBuilderEnv (t :: k)

+ Reflex.Dom.Builder.Static: hoistDMapWithKeyWithAdjust :: forall k v v' t m p. (Adjustable t m, MonadHold t m, PatchTarget (p k (Constant (Behavior t Builder) :: Type -> Type)) ~ DMap k (Constant (Behavior t Builder) :: Type -> Type), Patch (p k (Constant (Behavior t Builder) :: Type -> Type))) => (forall (vv :: Type -> Type) (vv' :: Type -> Type). () => (forall a. () => k a -> vv a -> m (vv' a)) -> DMap k vv -> Event t (p k vv) -> m (DMap k vv', Event t (p k vv'))) -> (forall (vv :: Type -> Type) (vv' :: Type -> Type). () => (forall a. () => vv a -> vv' a) -> p k vv -> p k vv') -> (forall a. () => k a -> v a -> StaticDomBuilderT t m (v' a)) -> DMap k v -> Event t (p k v) -> StaticDomBuilderT t m (DMap k v', Event t (p k v'))

+ Reflex.Dom.Builder.Static: hoistIntMapWithKeyWithAdjust :: (Adjustable t m, MonadHold t m, Functor p, Patch (p (Behavior t Builder)), PatchTarget (p (Behavior t Builder)) ~ IntMap (Behavior t Builder)) => (forall x. () => (Key -> a -> m x) -> IntMap a -> Event t (p a) -> m (IntMap x, Event t (p x))) -> (Key -> a -> StaticDomBuilderT t m b) -> IntMap a -> Event t (p a) -> StaticDomBuilderT t m (IntMap b, Event t (p b))

+ Reflex.Dom.Builder.Static: newtype StaticDomBuilderT (t :: k) (m :: Type -> Type) a

+ Reflex.Dom.Builder.Static: renderStatic :: forall {k} (x :: k) a. StaticWidget x a -> IO (a, ByteString)

+ Reflex.Dom.Builder.Static: runStaticDomBuilderT :: forall {k} m (t :: k) a. (Monad m, Reflex t) => StaticDomBuilderT t m a -> StaticDomBuilderEnv t -> m (a, Behavior t Builder)

+ Reflex.Dom.Builder.Static: type StaticWidget (x :: k) = PostBuildT DomTimeline StaticDomBuilderT DomTimeline PerformEventT DomTimeline DomHost

+ Reflex.Dom.Builder.Static: type SupportsStaticDomBuilder t (m :: Type -> Type) = (Reflex t, MonadIO m, MonadHold t m, MonadFix m, PerformEvent t m, MonadReflexCreateTrigger t m, MonadRef m, Ref m ~ Ref IO, Adjustable t m)

+ Reflex.Dom.Location: browserHistoryWith :: (MonadJSM m, TriggerEvent t m, MonadHold t m) => (forall (jsm :: Type -> Type). MonadJSM jsm => Location -> jsm a) -> m (Dynamic t a)

+ Reflex.Dom.Main: mainHydrationWidgetWithHead :: (forall x. () => HydrationWidget x ()) -> (forall x. () => HydrationWidget x ()) -> JSM ()

+ Reflex.Dom.Main: mainHydrationWidgetWithSwitchoverAction :: JSM () -> (forall x. () => HydrationWidget x ()) -> (forall x. () => HydrationWidget x ()) -> JSM ()

+ Reflex.Dom.Main: mainWidget :: (forall x. () => Widget x ()) -> JSM ()

+ Reflex.Dom.Main: mainWidgetInElementById :: Text -> (forall x. () => Widget x ()) -> JSM ()

+ Reflex.Dom.Main: mainWidgetWithCss :: ByteString -> (forall x. () => Widget x ()) -> JSM ()

+ Reflex.Dom.Main: mainWidgetWithHead :: (forall x. () => Widget x ()) -> (forall x. () => Widget x ()) -> JSM ()

+ Reflex.Dom.Main: runApp' :: t ~ DomTimeline => (forall x. () => AppInput t -> Widget x (AppOutput t)) -> JSM ()

+ Reflex.Dom.Main: runHydrationWidgetWithHeadAndBody :: JSM () -> ((forall c. () => HydrationWidget () c -> FloatingWidget () c) -> (forall c. () => HydrationWidget () c -> FloatingWidget () c) -> FloatingWidget () ()) -> JSM ()

+ Reflex.Dom.Main: runHydrationWidgetWithHeadAndBodyWithFailure :: IO () -> JSM () -> ((forall c. () => HydrationWidget () c -> FloatingWidget () c) -> (forall c. () => HydrationWidget () c -> FloatingWidget () c) -> FloatingWidget () ()) -> JSM ()

+ Reflex.Dom.Main: runImmediateWidgetWithHeadAndBody :: ((forall c. () => Widget () c -> FloatingWidget () c) -> (forall c. () => Widget () c -> FloatingWidget () c) -> FloatingWidget () ()) -> JSM ()

+ Reflex.Dom.Main: type DomCoreWidget x = PostBuildT DomTimeline WithJSContextSingleton x PerformEventT DomTimeline DomHost

+ Reflex.Dom.Main: type DomHost = SpiderHost Global

+ Reflex.Dom.Main: type EventChannel = Chan [DSum EventTriggerRef DomTimeline TriggerInvocation]

+ Reflex.Dom.Main: type FloatingWidget x = TriggerEventT DomTimeline DomCoreWidget x

+ Reflex.Dom.Main: type HydrationWidget x a = HydrationDomBuilderT HydrationDomSpace DomTimeline DomCoreWidget x a

+ Reflex.Dom.Main: type Widget x = ImmediateDomBuilderT DomTimeline DomCoreWidget x

+ Reflex.Dom.Modals.Class: class ModalOpener t (m :: Type -> Type)

+ Reflex.Dom.Old: _el_events :: forall (er :: EventTag -> Type) d t. Element er d t -> EventSelector t (WrapArg er EventName)

+ Reflex.Dom.Old: class Attributes (m :: Type -> Type) attrs t

+ Reflex.Dom.Old: class MonadWidgetConstraints t m => MonadWidget t (m :: Type -> Type)

+ Reflex.Dom.Old: elConfig_attributes :: forall attrs1 attrs2 f. Functor f => (attrs1 -> f attrs2) -> ElConfig attrs1 -> f (ElConfig attrs2)

+ Reflex.Dom.Old: elConfig_namespace :: forall attrs f. Functor f => (Maybe Text -> f (Maybe Text)) -> ElConfig attrs -> f (ElConfig attrs)

+ Reflex.Dom.Old: elStopPropagationNS :: forall t m (en :: EventTag) a. MonadWidget t m => Maybe Text -> Text -> EventName en -> m a -> m a

+ Reflex.Dom.Old: onEventName :: forall e (en :: EventTag). IsHTMLElement e => EventName en -> e -> EventM e (EventType en) () -> JSM (JSM ())

+ Reflex.Dom.Old: type El = Element EventResult GhcjsDomSpace :: Type -> Type

+ Reflex.Dom.Old: type WidgetHost (m :: Type -> Type) = Performable m

+ Reflex.Dom.Old: wrapElement :: MonadWidget t m => (forall (en :: EventTag). () => HTMLElement -> EventName en -> EventM Element (EventType en) (Maybe (EventResult en))) -> HTMLElement -> m (El t)

+ Reflex.Dom.Prerender: class (PrerenderClientConstraint t Client m, Client Client m ~ Client m, Prerender t Client m) => Prerender t (m :: Type -> Type) | m -> t where {

+ Reflex.Dom.Prerender: type Client (m :: Type -> Type) :: Type -> Type;

+ Reflex.Dom.Prerender: type PrerenderBaseConstraints t (m :: Type -> Type) = (MonadFix m, MonadHold t m, MonadJSM Performable m, MonadJSM m, MonadRef Performable m, MonadRef m, MonadReflexCreateTrigger t m, MonadSample t Performable m, PerformEvent t m, PostBuild t m, PrimMonad m, Ref Performable m ~ IORef, Ref m ~ IORef)

+ Reflex.Dom.Prerender: type PrerenderClientConstraint t (m :: Type -> Type) = (DomBuilder t m, DomBuilderSpace m ~ GhcjsDomSpace, DomRenderHook t m, HasDocument m, TriggerEvent t m, PrerenderBaseConstraints t m)

+ Reflex.Dom.WebSocket: RawWebSocket :: Event t a -> Event t () -> Event t () -> Event t (Bool, Word, Text) -> RawWebSocket (t :: k) a

+ Reflex.Dom.WebSocket: WebSocketConfig :: Event t [a] -> Event t (Word, Text) -> Bool -> [Text] -> WebSocketConfig (t :: k) a

+ Reflex.Dom.WebSocket: [_webSocketConfig_close] :: WebSocketConfig (t :: k) a -> Event t (Word, Text)

+ Reflex.Dom.WebSocket: [_webSocketConfig_protocols] :: WebSocketConfig (t :: k) a -> [Text]

+ Reflex.Dom.WebSocket: [_webSocketConfig_reconnect] :: WebSocketConfig (t :: k) a -> Bool

+ Reflex.Dom.WebSocket: [_webSocketConfig_send] :: WebSocketConfig (t :: k) a -> Event t [a]

+ Reflex.Dom.WebSocket: [_webSocket_close] :: RawWebSocket (t :: k) a -> Event t (Bool, Word, Text)

+ Reflex.Dom.WebSocket: [_webSocket_error] :: RawWebSocket (t :: k) a -> Event t ()

+ Reflex.Dom.WebSocket: [_webSocket_open] :: RawWebSocket (t :: k) a -> Event t ()

+ Reflex.Dom.WebSocket: [_webSocket_recv] :: RawWebSocket (t :: k) a -> Event t a

+ Reflex.Dom.WebSocket: data RawWebSocket (t :: k) a

+ Reflex.Dom.WebSocket: data WebSocketConfig (t :: k) a

+ Reflex.Dom.WebSocket: type WebSocket (t :: k) = RawWebSocket t ByteString

+ Reflex.Dom.WebSocket: webSocketConfig_close :: forall k (t :: k) a f. Functor f => (Event t (Word, Text) -> f (Event t (Word, Text))) -> WebSocketConfig t a -> f (WebSocketConfig t a)

+ Reflex.Dom.WebSocket: webSocketConfig_protocols :: forall k (t :: k) a f. Functor f => ([Text] -> f [Text]) -> WebSocketConfig t a -> f (WebSocketConfig t a)

+ Reflex.Dom.WebSocket: webSocketConfig_reconnect :: forall k (t :: k) a f. Functor f => (Bool -> f Bool) -> WebSocketConfig t a -> f (WebSocketConfig t a)

+ Reflex.Dom.WebSocket: webSocketConfig_send :: forall k (t :: k) a f. Functor f => (Event t [a] -> f (Event t [a])) -> WebSocketConfig t a -> f (WebSocketConfig t a)

+ Reflex.Dom.WebSocket: webSocket_close :: forall k (t :: k) a f. Functor f => (Event t (Bool, Word, Text) -> f (Event t (Bool, Word, Text))) -> RawWebSocket t a -> f (RawWebSocket t a)

+ Reflex.Dom.WebSocket: webSocket_error :: forall k (t :: k) a f. Functor f => (Event t () -> f (Event t ())) -> RawWebSocket t a -> f (RawWebSocket t a)

+ Reflex.Dom.WebSocket: webSocket_open :: forall k (t :: k) a f. Functor f => (Event t () -> f (Event t ())) -> RawWebSocket t a -> f (RawWebSocket t a)

+ Reflex.Dom.WebSocket: webSocket_recv :: forall k (t :: k) a f. Functor f => (Event t a -> f (Event t a)) -> RawWebSocket t a -> f (RawWebSocket t a)

+ Reflex.Dom.Widget.Basic: blank :: Monad m => m ()

+ Reflex.Dom.Widget.Basic: divClass :: DomBuilder t m => Text -> m a -> m a

+ Reflex.Dom.Widget.Basic: dtdd :: DomBuilder t m => Text -> m a -> m a

+ Reflex.Dom.Widget.Basic: dynComment :: (PostBuild t m, DomBuilder t m) => Dynamic t Text -> m ()

+ Reflex.Dom.Widget.Basic: dynText :: (PostBuild t m, DomBuilder t m) => Dynamic t Text -> m ()

+ Reflex.Dom.Widget.Basic: el :: DomBuilder t m => Text -> m a -> m a

+ Reflex.Dom.Widget.Basic: el' :: DomBuilder t m => Text -> m a -> m (Element EventResult (DomBuilderSpace m) t, a)

+ Reflex.Dom.Widget.Basic: elAttr :: DomBuilder t m => Text -> Map Text Text -> m a -> m a

+ Reflex.Dom.Widget.Basic: elAttr' :: DomBuilder t m => Text -> Map Text Text -> m a -> m (Element EventResult (DomBuilderSpace m) t, a)

+ Reflex.Dom.Widget.Basic: elClass :: DomBuilder t m => Text -> Text -> m a -> m a

+ Reflex.Dom.Widget.Basic: elClass' :: DomBuilder t m => Text -> Text -> m a -> m (Element EventResult (DomBuilderSpace m) t, a)

+ Reflex.Dom.Widget.Basic: elDynAttr :: (DomBuilder t m, PostBuild t m) => Text -> Dynamic t (Map Text Text) -> m a -> m a

+ Reflex.Dom.Widget.Basic: elDynAttr' :: (DomBuilder t m, PostBuild t m) => Text -> Dynamic t (Map Text Text) -> m a -> m (Element EventResult (DomBuilderSpace m) t, a)

+ Reflex.Dom.Widget.Basic: elDynAttrNS :: (DomBuilder t m, PostBuild t m) => Maybe Text -> Text -> Dynamic t (Map Text Text) -> m a -> m a

+ Reflex.Dom.Widget.Basic: elDynAttrNS' :: (DomBuilder t m, PostBuild t m) => Maybe Text -> Text -> Dynamic t (Map Text Text) -> m a -> m (Element EventResult (DomBuilderSpace m) t, a)

+ Reflex.Dom.Widget.Basic: elDynClass :: (DomBuilder t m, PostBuild t m) => Text -> Dynamic t Text -> m a -> m a

+ Reflex.Dom.Widget.Basic: elDynClass' :: (DomBuilder t m, PostBuild t m) => Text -> Dynamic t Text -> m a -> m (Element EventResult (DomBuilderSpace m) t, a)

+ Reflex.Dom.Widget.Basic: partitionMapBySetLT :: Ord k => Set k -> Map k v -> Map (Either k ()) (Map k v)

+ Reflex.Dom.Widget.Basic: type Attrs a;

+ Reflex.Dom.Widget.Input: Checkbox :: Dynamic t Bool -> Event t Bool -> Checkbox (t :: k)

+ Reflex.Dom.Widget.Input: CheckboxConfig :: Event t Bool -> Dynamic t (Map Text Text) -> CheckboxConfig (t :: k)

+ Reflex.Dom.Widget.Input: CheckboxViewEventResult :: CheckboxViewEventResultType en -> CheckboxViewEventResult (en :: EventTag)

+ Reflex.Dom.Widget.Input: Dropdown :: Dynamic t k1 -> Event t k1 -> Dropdown (t :: k) k1

+ Reflex.Dom.Widget.Input: DropdownConfig :: Event t k1 -> Dynamic t (Map Text Text) -> DropdownConfig (t :: k) k1

+ Reflex.Dom.Widget.Input: DropdownViewEventResult :: DropdownViewEventResultType en -> DropdownViewEventResult (en :: EventTag)

+ Reflex.Dom.Widget.Input: FileInput :: Dynamic t [File] -> RawInputElement d -> FileInput (d :: k) (t :: k1)

+ Reflex.Dom.Widget.Input: FileInputConfig :: Dynamic t (Map Text Text) -> FileInputConfig (t :: k)

+ Reflex.Dom.Widget.Input: RangeInput :: Dynamic t Float -> Event t Float -> Event t (Int, Int) -> Dynamic t Bool -> HTMLInputElement -> RangeInput (t :: k)

+ Reflex.Dom.Widget.Input: RangeInputConfig :: Float -> Event t Float -> Dynamic t (Map Text Text) -> RangeInputConfig (t :: k)

+ Reflex.Dom.Widget.Input: TextArea :: Dynamic t Text -> Event t Text -> Dynamic t Bool -> Event t Word -> HTMLTextAreaElement -> TextArea (t :: k)

+ Reflex.Dom.Widget.Input: TextAreaConfig :: Text -> Event t Text -> Dynamic t (Map Text Text) -> TextAreaConfig (t :: k)

+ Reflex.Dom.Widget.Input: TextInput :: Dynamic t Text -> Event t Text -> Event t Word -> Event t Word -> Event t Word -> Dynamic t Bool -> InputElement EventResult GhcjsDomSpace t -> TextInput (t :: k1)

+ Reflex.Dom.Widget.Input: TextInputConfig :: Text -> Text -> Event t Text -> Dynamic t (Map Text Text) -> TextInputConfig (t :: k)

+ Reflex.Dom.Widget.Input: [_checkboxConfig_attributes] :: CheckboxConfig (t :: k) -> Dynamic t (Map Text Text)

+ Reflex.Dom.Widget.Input: [_checkboxConfig_setValue] :: CheckboxConfig (t :: k) -> Event t Bool

+ Reflex.Dom.Widget.Input: [_checkbox_change] :: Checkbox (t :: k) -> Event t Bool

+ Reflex.Dom.Widget.Input: [_checkbox_value] :: Checkbox (t :: k) -> Dynamic t Bool

+ Reflex.Dom.Widget.Input: [_dropdownConfig_attributes] :: DropdownConfig (t :: k) k1 -> Dynamic t (Map Text Text)

+ Reflex.Dom.Widget.Input: [_dropdownConfig_setValue] :: DropdownConfig (t :: k) k1 -> Event t k1

+ Reflex.Dom.Widget.Input: [_dropdown_change] :: Dropdown (t :: k) k1 -> Event t k1

+ Reflex.Dom.Widget.Input: [_dropdown_value] :: Dropdown (t :: k) k1 -> Dynamic t k1

+ Reflex.Dom.Widget.Input: [_fileInputConfig_attributes] :: FileInputConfig (t :: k) -> Dynamic t (Map Text Text)

+ Reflex.Dom.Widget.Input: [_fileInput_element] :: FileInput (d :: k) (t :: k1) -> RawInputElement d

+ Reflex.Dom.Widget.Input: [_fileInput_value] :: FileInput (d :: k) (t :: k1) -> Dynamic t [File]

+ Reflex.Dom.Widget.Input: [_rangeInputConfig_attributes] :: RangeInputConfig (t :: k) -> Dynamic t (Map Text Text)

+ Reflex.Dom.Widget.Input: [_rangeInputConfig_initialValue] :: RangeInputConfig (t :: k) -> Float

+ Reflex.Dom.Widget.Input: [_rangeInputConfig_setValue] :: RangeInputConfig (t :: k) -> Event t Float

+ Reflex.Dom.Widget.Input: [_rangeInput_element] :: RangeInput (t :: k) -> HTMLInputElement

+ Reflex.Dom.Widget.Input: [_rangeInput_hasFocus] :: RangeInput (t :: k) -> Dynamic t Bool

+ Reflex.Dom.Widget.Input: [_rangeInput_input] :: RangeInput (t :: k) -> Event t Float

+ Reflex.Dom.Widget.Input: [_rangeInput_mouseup] :: RangeInput (t :: k) -> Event t (Int, Int)

+ Reflex.Dom.Widget.Input: [_rangeInput_value] :: RangeInput (t :: k) -> Dynamic t Float

+ Reflex.Dom.Widget.Input: [_textAreaConfig_attributes] :: TextAreaConfig (t :: k) -> Dynamic t (Map Text Text)

+ Reflex.Dom.Widget.Input: [_textAreaConfig_initialValue] :: TextAreaConfig (t :: k) -> Text

+ Reflex.Dom.Widget.Input: [_textAreaConfig_setValue] :: TextAreaConfig (t :: k) -> Event t Text

+ Reflex.Dom.Widget.Input: [_textArea_element] :: TextArea (t :: k) -> HTMLTextAreaElement

+ Reflex.Dom.Widget.Input: [_textArea_hasFocus] :: TextArea (t :: k) -> Dynamic t Bool

+ Reflex.Dom.Widget.Input: [_textArea_input] :: TextArea (t :: k) -> Event t Text

+ Reflex.Dom.Widget.Input: [_textArea_keypress] :: TextArea (t :: k) -> Event t Word

+ Reflex.Dom.Widget.Input: [_textArea_value] :: TextArea (t :: k) -> Dynamic t Text

+ Reflex.Dom.Widget.Input: [_textInputConfig_attributes] :: TextInputConfig (t :: k) -> Dynamic t (Map Text Text)

+ Reflex.Dom.Widget.Input: [_textInputConfig_initialValue] :: TextInputConfig (t :: k) -> Text

+ Reflex.Dom.Widget.Input: [_textInputConfig_inputType] :: TextInputConfig (t :: k) -> Text

+ Reflex.Dom.Widget.Input: [_textInputConfig_setValue] :: TextInputConfig (t :: k) -> Event t Text

+ Reflex.Dom.Widget.Input: [_textInput_builderElement] :: TextInput (t :: k1) -> InputElement EventResult GhcjsDomSpace t

+ Reflex.Dom.Widget.Input: [_textInput_hasFocus] :: TextInput (t :: k1) -> Dynamic t Bool

+ Reflex.Dom.Widget.Input: [_textInput_input] :: TextInput (t :: k1) -> Event t Text

+ Reflex.Dom.Widget.Input: [_textInput_keydown] :: TextInput (t :: k1) -> Event t Word

+ Reflex.Dom.Widget.Input: [_textInput_keypress] :: TextInput (t :: k1) -> Event t Word

+ Reflex.Dom.Widget.Input: [_textInput_keyup] :: TextInput (t :: k1) -> Event t Word

+ Reflex.Dom.Widget.Input: [_textInput_value] :: TextInput (t :: k1) -> Dynamic t Text

+ Reflex.Dom.Widget.Input: [unCheckboxViewEventResult] :: CheckboxViewEventResult (en :: EventTag) -> CheckboxViewEventResultType en

+ Reflex.Dom.Widget.Input: [unDropdownViewEventResult] :: DropdownViewEventResult (en :: EventTag) -> DropdownViewEventResultType en

+ Reflex.Dom.Widget.Input: _textInput_element :: forall {k1} (t :: k1). TextInput t -> HTMLInputElement

+ Reflex.Dom.Widget.Input: checkboxConfig_attributes :: forall k (t :: k) f. Functor f => (Dynamic t (Map Text Text) -> f (Dynamic t (Map Text Text))) -> CheckboxConfig t -> f (CheckboxConfig t)

+ Reflex.Dom.Widget.Input: checkboxConfig_setValue :: forall k (t :: k) f. Functor f => (Event t Bool -> f (Event t Bool)) -> CheckboxConfig t -> f (CheckboxConfig t)

+ Reflex.Dom.Widget.Input: checkboxView :: (DomBuilder t m, DomBuilderSpace m ~ GhcjsDomSpace, PostBuild t m) => Dynamic t (Map Text Text) -> Dynamic t Bool -> m (Event t Bool)

+ Reflex.Dom.Widget.Input: checkbox_change :: forall k (t :: k) f. Functor f => (Event t Bool -> f (Event t Bool)) -> Checkbox t -> f (Checkbox t)

+ Reflex.Dom.Widget.Input: checkbox_value :: forall k (t :: k) f. Functor f => (Dynamic t Bool -> f (Dynamic t Bool)) -> Checkbox t -> f (Checkbox t)

+ Reflex.Dom.Widget.Input: data Checkbox (t :: k)

+ Reflex.Dom.Widget.Input: data CheckboxConfig (t :: k)

+ Reflex.Dom.Widget.Input: data Dropdown (t :: k) k1

+ Reflex.Dom.Widget.Input: data DropdownConfig (t :: k) k1

+ Reflex.Dom.Widget.Input: data FileInput (d :: k) (t :: k1)

+ Reflex.Dom.Widget.Input: data RangeInput (t :: k)

+ Reflex.Dom.Widget.Input: data RangeInputConfig (t :: k)

+ Reflex.Dom.Widget.Input: data TextArea (t :: k)

+ Reflex.Dom.Widget.Input: data TextAreaConfig (t :: k)

+ Reflex.Dom.Widget.Input: data TextInput (t :: k1)

+ Reflex.Dom.Widget.Input: data TextInputConfig (t :: k)

+ Reflex.Dom.Widget.Input: dropdownConfig_attributes :: forall k1 (t :: k1) k2 f. Functor f => (Dynamic t (Map Text Text) -> f (Dynamic t (Map Text Text))) -> DropdownConfig t k2 -> f (DropdownConfig t k2)

+ Reflex.Dom.Widget.Input: dropdownConfig_setValue :: forall k1 (t :: k1) k2 k3 f. Functor f => (Event t k2 -> f (Event t k3)) -> DropdownConfig t k2 -> f (DropdownConfig t k3)

+ Reflex.Dom.Widget.Input: dropdown_change :: forall k1 (t :: k1) k2 f. Functor f => (Event t k2 -> f (Event t k2)) -> Dropdown t k2 -> f (Dropdown t k2)

+ Reflex.Dom.Widget.Input: dropdown_value :: forall k1 (t :: k1) k2 f. Functor f => (Dynamic t k2 -> f (Dynamic t k2)) -> Dropdown t k2 -> f (Dropdown t k2)

+ Reflex.Dom.Widget.Input: fileInputConfig_attributes :: forall k1 (t1 :: k1) k2 (t2 :: k2) p f. (Profunctor p, Functor f) => p (Dynamic t1 (Map Text Text)) (f (Dynamic t2 (Map Text Text))) -> p (FileInputConfig t1) (f (FileInputConfig t2))

+ Reflex.Dom.Widget.Input: fileInput_element :: forall k1 (d1 :: k1) k2 (t :: k2) k3 (d2 :: k3) f. Functor f => (RawInputElement d1 -> f (RawInputElement d2)) -> FileInput d1 t -> f (FileInput d2 t)

+ Reflex.Dom.Widget.Input: fileInput_value :: forall k1 (d :: k1) k2 (t1 :: k2) k3 (t2 :: k3) f. Functor f => (Dynamic t1 [File] -> f (Dynamic t2 [File])) -> FileInput d t1 -> f (FileInput d t2)

+ Reflex.Dom.Widget.Input: keydown :: forall {k} (t :: k) e. (Reflex t, HasDomEvent t e 'KeydownTag, DomEventType e 'KeydownTag ~ Word) => Key -> e -> Event t ()

+ Reflex.Dom.Widget.Input: keypress :: forall {k} (t :: k) e. (Reflex t, HasDomEvent t e 'KeypressTag, DomEventType e 'KeypressTag ~ Word) => Key -> e -> Event t ()

+ Reflex.Dom.Widget.Input: keyup :: forall {k} (t :: k) e. (Reflex t, HasDomEvent t e 'KeyupTag, DomEventType e 'KeyupTag ~ Word) => Key -> e -> Event t ()

+ Reflex.Dom.Widget.Input: newtype CheckboxViewEventResult (en :: EventTag)

+ Reflex.Dom.Widget.Input: newtype DropdownViewEventResult (en :: EventTag)

+ Reflex.Dom.Widget.Input: newtype FileInputConfig (t :: k)

+ Reflex.Dom.Widget.Input: rangeInputConfig_attributes :: forall k (t :: k) f. Functor f => (Dynamic t (Map Text Text) -> f (Dynamic t (Map Text Text))) -> RangeInputConfig t -> f (RangeInputConfig t)

+ Reflex.Dom.Widget.Input: rangeInputConfig_initialValue :: forall k (t :: k) f. Functor f => (Float -> f Float) -> RangeInputConfig t -> f (RangeInputConfig t)

+ Reflex.Dom.Widget.Input: rangeInputConfig_setValue :: forall k (t :: k) f. Functor f => (Event t Float -> f (Event t Float)) -> RangeInputConfig t -> f (RangeInputConfig t)

+ Reflex.Dom.Widget.Input: rangeInput_element :: forall k (t :: k) f. Functor f => (HTMLInputElement -> f HTMLInputElement) -> RangeInput t -> f (RangeInput t)

+ Reflex.Dom.Widget.Input: rangeInput_hasFocus :: forall k (t :: k) f. Functor f => (Dynamic t Bool -> f (Dynamic t Bool)) -> RangeInput t -> f (RangeInput t)

+ Reflex.Dom.Widget.Input: rangeInput_input :: forall k (t :: k) f. Functor f => (Event t Float -> f (Event t Float)) -> RangeInput t -> f (RangeInput t)

+ Reflex.Dom.Widget.Input: rangeInput_mouseup :: forall k (t :: k) f. Functor f => (Event t (Int, Int) -> f (Event t (Int, Int))) -> RangeInput t -> f (RangeInput t)

+ Reflex.Dom.Widget.Input: rangeInput_value :: forall k (t :: k) f. Functor f => (Dynamic t Float -> f (Dynamic t Float)) -> RangeInput t -> f (RangeInput t)

+ Reflex.Dom.Widget.Input: regularToCheckboxViewEventType :: forall (t :: EventTag). EventName t -> EventResultType t -> CheckboxViewEventResultType t

+ Reflex.Dom.Widget.Input: regularToDropdownViewEventType :: forall (t :: EventTag). EventName t -> EventResultType t -> DropdownViewEventResultType t

+ Reflex.Dom.Widget.Input: textAreaConfig_attributes :: forall k (t :: k) f. Functor f => (Dynamic t (Map Text Text) -> f (Dynamic t (Map Text Text))) -> TextAreaConfig t -> f (TextAreaConfig t)

+ Reflex.Dom.Widget.Input: textAreaConfig_initialValue :: forall k (t :: k) f. Functor f => (Text -> f Text) -> TextAreaConfig t -> f (TextAreaConfig t)

+ Reflex.Dom.Widget.Input: textAreaConfig_setValue :: forall k (t :: k) f. Functor f => (Event t Text -> f (Event t Text)) -> TextAreaConfig t -> f (TextAreaConfig t)

+ Reflex.Dom.Widget.Input: textArea_element :: forall k (t :: k) f. Functor f => (HTMLTextAreaElement -> f HTMLTextAreaElement) -> TextArea t -> f (TextArea t)

+ Reflex.Dom.Widget.Input: textArea_hasFocus :: forall k (t :: k) f. Functor f => (Dynamic t Bool -> f (Dynamic t Bool)) -> TextArea t -> f (TextArea t)

+ Reflex.Dom.Widget.Input: textArea_input :: forall k (t :: k) f. Functor f => (Event t Text -> f (Event t Text)) -> TextArea t -> f (TextArea t)

+ Reflex.Dom.Widget.Input: textArea_keypress :: forall k (t :: k) f. Functor f => (Event t Word -> f (Event t Word)) -> TextArea t -> f (TextArea t)

+ Reflex.Dom.Widget.Input: textArea_value :: forall k (t :: k) f. Functor f => (Dynamic t Text -> f (Dynamic t Text)) -> TextArea t -> f (TextArea t)

+ Reflex.Dom.Widget.Input: textInputConfig_attributes :: forall k (t :: k) f. Functor f => (Dynamic t (Map Text Text) -> f (Dynamic t (Map Text Text))) -> TextInputConfig t -> f (TextInputConfig t)

+ Reflex.Dom.Widget.Input: textInputConfig_initialValue :: forall k (t :: k) f. Functor f => (Text -> f Text) -> TextInputConfig t -> f (TextInputConfig t)

+ Reflex.Dom.Widget.Input: textInputConfig_inputType :: forall k (t :: k) f. Functor f => (Text -> f Text) -> TextInputConfig t -> f (TextInputConfig t)

+ Reflex.Dom.Widget.Input: textInputConfig_setValue :: forall k (t :: k) f. Functor f => (Event t Text -> f (Event t Text)) -> TextInputConfig t -> f (TextInputConfig t)

+ Reflex.Dom.Widget.Input: textInputGetEnter :: forall {k} (t :: k). Reflex t => TextInput t -> Event t ()

+ Reflex.Dom.Widget.Input: textInput_builderElement :: forall k1 (t :: k1) f. Functor f => (InputElement EventResult GhcjsDomSpace t -> f (InputElement EventResult GhcjsDomSpace t)) -> TextInput t -> f (TextInput t)

+ Reflex.Dom.Widget.Input: textInput_hasFocus :: forall k1 (t :: k1) f. Functor f => (Dynamic t Bool -> f (Dynamic t Bool)) -> TextInput t -> f (TextInput t)

+ Reflex.Dom.Widget.Input: textInput_input :: forall k1 (t :: k1) f. Functor f => (Event t Text -> f (Event t Text)) -> TextInput t -> f (TextInput t)

+ Reflex.Dom.Widget.Input: textInput_keydown :: forall k1 (t :: k1) f. Functor f => (Event t Word -> f (Event t Word)) -> TextInput t -> f (TextInput t)

+ Reflex.Dom.Widget.Input: textInput_keypress :: forall k1 (t :: k1) f. Functor f => (Event t Word -> f (Event t Word)) -> TextInput t -> f (TextInput t)

+ Reflex.Dom.Widget.Input: textInput_keyup :: forall k1 (t :: k1) f. Functor f => (Event t Word -> f (Event t Word)) -> TextInput t -> f (TextInput t)

+ Reflex.Dom.Widget.Input: textInput_value :: forall k1 (t :: k1) f. Functor f => (Dynamic t Text -> f (Dynamic t Text)) -> TextInput t -> f (TextInput t)

+ Reflex.Dom.Widget.Input: type Value a;

+ Reflex.Dom.Widget.Input: type family DropdownViewEventResultType (en :: EventTag)

+ Reflex.Dom.Widget.Lazy: virtualList :: (DomBuilder t m, PostBuild t m, MonadHold t m, PerformEvent t m, MonadJSM (Performable m), DomBuilderSpace m ~ GhcjsDomSpace, MonadFix m, Ord k) => Dynamic t Int -> Int -> Dynamic t Int -> Int -> Event t Int -> (k -> Int) -> Map k v -> Event t (Map k (Maybe v)) -> (k -> v -> Event t v -> m a) -> m (Dynamic t (Int, Int), Dynamic t (Map k a))

+ Reflex.Dom.Widget.Lazy: virtualListWithSelection :: (DomBuilder t m, PostBuild t m, MonadHold t m, PerformEvent t m, MonadJSM (Performable m), DomBuilderSpace m ~ GhcjsDomSpace, MonadFix m, Ord k, Eq v) => Dynamic t Int -> Int -> Dynamic t Int -> Int -> Event t Int -> Text -> Dynamic t (Map Text Text) -> Text -> Dynamic t (Map Text Text) -> (k -> Dynamic t (Maybe v) -> Dynamic t Bool -> m ()) -> Dynamic t (Map k v) -> (Int -> k) -> m (Dynamic t (Int, Int), Event t k)

+ Reflex.Dom.Xhr: data XMLHttpRequest

+ Reflex.Dom.Xhr: xhrRequestConfig_headers :: forall a f. Functor f => (Map Text Text -> f (Map Text Text)) -> XhrRequestConfig a -> f (XhrRequestConfig a)

+ Reflex.Dom.Xhr: xhrRequestConfig_password :: forall a f. Functor f => (Maybe Text -> f (Maybe Text)) -> XhrRequestConfig a -> f (XhrRequestConfig a)

+ Reflex.Dom.Xhr: xhrRequestConfig_responseHeaders :: forall a f. Functor f => (XhrResponseHeaders -> f XhrResponseHeaders) -> XhrRequestConfig a -> f (XhrRequestConfig a)

+ Reflex.Dom.Xhr: xhrRequestConfig_responseType :: forall a f. Functor f => (Maybe XhrResponseType -> f (Maybe XhrResponseType)) -> XhrRequestConfig a -> f (XhrRequestConfig a)

+ Reflex.Dom.Xhr: xhrRequestConfig_sendData :: forall a1 a2 f. Functor f => (a1 -> f a2) -> XhrRequestConfig a1 -> f (XhrRequestConfig a2)

+ Reflex.Dom.Xhr: xhrRequestConfig_user :: forall a f. Functor f => (Maybe Text -> f (Maybe Text)) -> XhrRequestConfig a -> f (XhrRequestConfig a)

+ Reflex.Dom.Xhr: xhrRequestConfig_withCredentials :: forall a f. Functor f => (Bool -> f Bool) -> XhrRequestConfig a -> f (XhrRequestConfig a)

+ Reflex.Dom.Xhr: xhrRequest_config :: forall a1 a2 f. Functor f => (XhrRequestConfig a1 -> f (XhrRequestConfig a2)) -> XhrRequest a1 -> f (XhrRequest a2)

+ Reflex.Dom.Xhr: xhrRequest_method :: forall a f. Functor f => (Text -> f Text) -> XhrRequest a -> f (XhrRequest a)

+ Reflex.Dom.Xhr: xhrRequest_url :: forall a f. Functor f => (Text -> f Text) -> XhrRequest a -> f (XhrRequest a)

+ Reflex.Dom.Xhr: xmlHttpRequestGetStatusText :: (MonadJSM m, FromJSString result) => XMLHttpRequest -> m result