interface Text.XHtml.Internals where {
infixr  2 +++;
infixr  7 <<;
infixl  8 !;

{-# NEED #-}
instance ADDATTRS Html;

{-# NEED #-}
instance (ADDATTRS b) => ADDATTRS (a -> b);

{-# NEED #-}
instance HTML Html;

{-# NEED #-}
instance HTML Prelude.Char;

{-# NEED #-}
instance (HTML a) => HTML [a];

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Fractional (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.RealFrac (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Num (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Real (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Enum (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Read a,Prelude.Integral a) => Prelude.Read (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Ord (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Eq (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Functor NHC.Internal.IO;

{-# NEED #-}
instance Prelude.Monad NHC.Internal.IO;

{-# NEED #-}
instance Prelude.Show Html;

{-# NEED #-}
instance Prelude.Show HtmlAttr;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Show (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (NHC.Internal.IO a);

{-# NEED #-}
instance Data.Monoid.Monoid Html;

{-# NEED #-}
instance (Data.Monoid.Monoid a,Data.Monoid.Monoid b) => Data.Monoid.Monoid (a,b);

{-# NEED #-}
instance Data.Monoid.Monoid Prelude.Ordering;

{-# NEED #-}
instance (Data.Monoid.Monoid a) => Data.Monoid.Monoid (Prelude.Maybe a);

{-# NEED #-}
instance Data.Monoid.Monoid ();

{-# NEED #-}
instance Data.Monoid.Monoid [a];

{-# NEED #-}
instance (Data.Monoid.Monoid b) => Data.Monoid.Monoid (a -> b);
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface Data.Monoid
{-# NEED Monoid #-}
class Monoid a;
interface ! Text.XHtml.Internals
{-# NEED validHtmlITags #-}
validHtmlITags{-# 0 #-}::[Prelude.String];

{-# NEED renderEndTag #-}
renderEndTag{-# 3 #-}::(Prelude.String -> (Prelude.String -> Prelude.ShowS));

{-# NEED renderTag #-}
renderTag{-# 5 #-}::(Prelude.Bool -> (Prelude.String -> ([HtmlAttr] -> (Prelude.String -> Prelude.ShowS))));

{-# NEED prettyHtml' #-}
prettyHtml'{-# 1 #-}::(HtmlElement -> [Prelude.String]);

{-# NEED renderHtml' #-}
renderHtml'{-# 2 #-}::(Prelude.Int -> (HtmlElement -> Prelude.ShowS));

{-# NEED showHtml' #-}
showHtml'{-# 1 #-}::(HtmlElement -> Prelude.ShowS);

{-# NEED prettyHtmlFragment #-}
prettyHtmlFragment{-# 0 #-}::(HTML a) => (a -> Prelude.String);

{-# NEED renderHtmlFragment #-}
renderHtmlFragment{-# 1 #-}::(HTML a) => (a -> Prelude.String);

{-# NEED showHtmlFragment #-}
showHtmlFragment{-# 1 #-}::(HTML a) => (a -> Prelude.String);

{-# NEED prettyHtmlInternal #-}
prettyHtmlInternal{-# 2 #-}::(HTML a) => (Prelude.String -> (a -> Prelude.String));

{-# NEED renderHtmlInternal #-}
renderHtmlInternal{-# 2 #-}::(HTML a) => (Prelude.String -> (a -> Prelude.String));

{-# NEED showHtmlInternal #-}
showHtmlInternal{-# 2 #-}::(HTML a) => (Prelude.String -> (a -> Prelude.String));

{-# NEED mkHtml #-}
mkHtml{-# 0 #-}::(HTML a) => (a -> Html);

{-# NEED primHtml #-}
primHtml{-# 1 #-}::(Prelude.String -> Html);

{-# NEED stringToHtmlString #-}
stringToHtmlString{-# 0 #-}::(Prelude.String -> Prelude.String);

{-# NEED strAttr #-}
strAttr{-# 2 #-}::(Prelude.String -> (Prelude.String -> HtmlAttr));

{-# NEED intAttr #-}
intAttr{-# 2 #-}::(Prelude.String -> (Prelude.Int -> HtmlAttr));

{-# NEED emptyAttr #-}
emptyAttr{-# 1 #-}::(Prelude.String -> HtmlAttr);

{-# NEED itag #-}
itag{-# 1 #-}::(Prelude.String -> Html);

{-# NEED tag #-}
tag{-# 2 #-}::(Prelude.String -> (Html -> Html));

{-# NEED isNoHtml #-}
isNoHtml{-# 1 #-}::(Html -> Prelude.Bool);

{-# NEED noHtml #-}
noHtml{-# 0 #-}::Html;

{-# NEED (+++) #-}
(+++){-# 2 #-}::(HTML a,HTML b) => (a -> (b -> Html));

{-# NEED concatHtml #-}
concatHtml{-# 1 #-}::(HTML a) => ([a] -> Html);

{-# NEED (<<) #-}
(<<){-# 2 #-}::(HTML b) => ((Html -> a) -> (b -> a));

{-# NEED {ADDATTRS (!)} #-}
class ADDATTRS a where {
  (!){-# 2 #-}::(a -> ([HtmlAttr] -> a));
};

{-# NEED {HTML toHtmlFromList toHtml} #-}
class HTML a where {
  toHtmlFromList{-# 1 #-}::([a] -> Html);
  toHtml{-# 1 #-}::(a -> Html);
};

{-# NEED {HtmlElement HtmlString HtmlTag markupTag markupAttrs markupContent} {Html Html getHtmlElements} #-}
data HtmlElement
  = HtmlString Prelude.String
  | HtmlTag {markupTag :: Prelude.String} {markupAttrs :: [HtmlAttr]} {markupContent :: Html};
newtype {-#  #-} Html
  = Html {getHtmlElements :: [HtmlElement]};

{-# NEED {HtmlAttr HtmlAttr} #-}
data HtmlAttr
  = HtmlAttr Prelude.String Prelude.String;
}