ghcjs-dom-javascript-0.9.9.0: src/GHCJS/DOM/JSFFI/Generated/SVGPathElement.hs

{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE JavaScriptFFI #-}
-- For HasCallStack compatibility
{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
module GHCJS.DOM.JSFFI.Generated.SVGPathElement
       (js_getTotalLength, getTotalLength, getTotalLength_,
        js_getPointAtLength, getPointAtLength, getPointAtLength_,
        js_getPathSegAtLength, getPathSegAtLength, getPathSegAtLength_,
        js_createSVGPathSegClosePath, createSVGPathSegClosePath,
        createSVGPathSegClosePath_, js_createSVGPathSegMovetoAbs,
        createSVGPathSegMovetoAbs, createSVGPathSegMovetoAbs_,
        js_createSVGPathSegMovetoRel, createSVGPathSegMovetoRel,
        createSVGPathSegMovetoRel_, js_createSVGPathSegLinetoAbs,
        createSVGPathSegLinetoAbs, createSVGPathSegLinetoAbs_,
        js_createSVGPathSegLinetoRel, createSVGPathSegLinetoRel,
        createSVGPathSegLinetoRel_, js_createSVGPathSegCurvetoCubicAbs,
        createSVGPathSegCurvetoCubicAbs, createSVGPathSegCurvetoCubicAbs_,
        js_createSVGPathSegCurvetoCubicRel,
        createSVGPathSegCurvetoCubicRel, createSVGPathSegCurvetoCubicRel_,
        js_createSVGPathSegCurvetoQuadraticAbs,
        createSVGPathSegCurvetoQuadraticAbs,
        createSVGPathSegCurvetoQuadraticAbs_,
        js_createSVGPathSegCurvetoQuadraticRel,
        createSVGPathSegCurvetoQuadraticRel,
        createSVGPathSegCurvetoQuadraticRel_, js_createSVGPathSegArcAbs,
        createSVGPathSegArcAbs, createSVGPathSegArcAbs_,
        js_createSVGPathSegArcRel, createSVGPathSegArcRel,
        createSVGPathSegArcRel_, js_createSVGPathSegLinetoHorizontalAbs,
        createSVGPathSegLinetoHorizontalAbs,
        createSVGPathSegLinetoHorizontalAbs_,
        js_createSVGPathSegLinetoHorizontalRel,
        createSVGPathSegLinetoHorizontalRel,
        createSVGPathSegLinetoHorizontalRel_,
        js_createSVGPathSegLinetoVerticalAbs,
        createSVGPathSegLinetoVerticalAbs,
        createSVGPathSegLinetoVerticalAbs_,
        js_createSVGPathSegLinetoVerticalRel,
        createSVGPathSegLinetoVerticalRel,
        createSVGPathSegLinetoVerticalRel_,
        js_createSVGPathSegCurvetoCubicSmoothAbs,
        createSVGPathSegCurvetoCubicSmoothAbs,
        createSVGPathSegCurvetoCubicSmoothAbs_,
        js_createSVGPathSegCurvetoCubicSmoothRel,
        createSVGPathSegCurvetoCubicSmoothRel,
        createSVGPathSegCurvetoCubicSmoothRel_,
        js_createSVGPathSegCurvetoQuadraticSmoothAbs,
        createSVGPathSegCurvetoQuadraticSmoothAbs,
        createSVGPathSegCurvetoQuadraticSmoothAbs_,
        js_createSVGPathSegCurvetoQuadraticSmoothRel,
        createSVGPathSegCurvetoQuadraticSmoothRel,
        createSVGPathSegCurvetoQuadraticSmoothRel_, js_getPathLength,
        getPathLength, js_getPathSegList, getPathSegList,
        js_getNormalizedPathSegList, getNormalizedPathSegList,
        js_getAnimatedPathSegList, getAnimatedPathSegList,
        js_getAnimatedNormalizedPathSegList,
        getAnimatedNormalizedPathSegList, SVGPathElement(..),
        gTypeSVGPathElement)
       where
import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
import qualified Prelude (error)
import Data.Typeable (Typeable)
import GHCJS.Types (JSVal(..), JSString)
import GHCJS.Foreign (jsNull, jsUndefined)
import GHC.JS.Foreign.Callback (syncCallback, asyncCallback, syncCallback1, asyncCallback1, syncCallback2, asyncCallback2, OnBlocked(..))
import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))
import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))
import Control.Monad (void)
import Control.Monad.IO.Class (MonadIO(..))
import Data.Int (Int64)
import Data.Word (Word, Word64)
import Data.Maybe (fromJust)
import Data.Traversable (mapM)
import GHCJS.DOM.Types
import Control.Applicative ((<$>))
import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName, unsafeEventNameAsync)
import GHCJS.DOM.JSFFI.Generated.Enums
 
foreign import javascript unsafe "(($1) => { return $1[\"getTotalLength\"](); })"
        js_getTotalLength :: SVGPathElement -> IO Float

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.getTotalLength Mozilla SVGPathElement.getTotalLength documentation> 
getTotalLength :: (MonadIO m) => SVGPathElement -> m Float
getTotalLength self = liftIO (js_getTotalLength self)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.getTotalLength Mozilla SVGPathElement.getTotalLength documentation> 
getTotalLength_ :: (MonadIO m) => SVGPathElement -> m ()
getTotalLength_ self = liftIO (void (js_getTotalLength self))
 
foreign import javascript unsafe "(($1, $2) => { return $1[\"getPointAtLength\"]($2); })"
        js_getPointAtLength ::
        SVGPathElement -> Optional Float -> IO SVGPoint

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.getPointAtLength Mozilla SVGPathElement.getPointAtLength documentation> 
getPointAtLength ::
                 (MonadIO m) => SVGPathElement -> Maybe Float -> m SVGPoint
getPointAtLength self distance
  = liftIO (js_getPointAtLength self (maybeToOptional distance))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.getPointAtLength Mozilla SVGPathElement.getPointAtLength documentation> 
getPointAtLength_ ::
                  (MonadIO m) => SVGPathElement -> Maybe Float -> m ()
getPointAtLength_ self distance
  = liftIO
      (void (js_getPointAtLength self (maybeToOptional distance)))
 
foreign import javascript unsafe "(($1, $2) => { return $1[\"getPathSegAtLength\"]($2); })"
        js_getPathSegAtLength ::
        SVGPathElement -> Optional Float -> IO Word

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.getPathSegAtLength Mozilla SVGPathElement.getPathSegAtLength documentation> 
getPathSegAtLength ::
                   (MonadIO m) => SVGPathElement -> Maybe Float -> m Word
getPathSegAtLength self distance
  = liftIO (js_getPathSegAtLength self (maybeToOptional distance))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.getPathSegAtLength Mozilla SVGPathElement.getPathSegAtLength documentation> 
getPathSegAtLength_ ::
                    (MonadIO m) => SVGPathElement -> Maybe Float -> m ()
getPathSegAtLength_ self distance
  = liftIO
      (void (js_getPathSegAtLength self (maybeToOptional distance)))
 
foreign import javascript unsafe
        "(($1) => { return $1[\"createSVGPathSegClosePath\"](); })" js_createSVGPathSegClosePath
        :: SVGPathElement -> IO SVGPathSegClosePath

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegClosePath Mozilla SVGPathElement.createSVGPathSegClosePath documentation> 
createSVGPathSegClosePath ::
                          (MonadIO m) => SVGPathElement -> m SVGPathSegClosePath
createSVGPathSegClosePath self
  = liftIO (js_createSVGPathSegClosePath self)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegClosePath Mozilla SVGPathElement.createSVGPathSegClosePath documentation> 
createSVGPathSegClosePath_ :: (MonadIO m) => SVGPathElement -> m ()
createSVGPathSegClosePath_ self
  = liftIO (void (js_createSVGPathSegClosePath self))
 
foreign import javascript unsafe
        "(($1, $2, $3) => { return $1[\"createSVGPathSegMovetoAbs\"]($2,\n$3); })"
        js_createSVGPathSegMovetoAbs ::
        SVGPathElement ->
          Optional Float -> Optional Float -> IO SVGPathSegMovetoAbs

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegMovetoAbs Mozilla SVGPathElement.createSVGPathSegMovetoAbs documentation> 
createSVGPathSegMovetoAbs ::
                          (MonadIO m) =>
                            SVGPathElement ->
                              Maybe Float -> Maybe Float -> m SVGPathSegMovetoAbs
createSVGPathSegMovetoAbs self x y
  = liftIO
      (js_createSVGPathSegMovetoAbs self (maybeToOptional x)
         (maybeToOptional y))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegMovetoAbs Mozilla SVGPathElement.createSVGPathSegMovetoAbs documentation> 
createSVGPathSegMovetoAbs_ ::
                           (MonadIO m) => SVGPathElement -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegMovetoAbs_ self x y
  = liftIO
      (void
         (js_createSVGPathSegMovetoAbs self (maybeToOptional x)
            (maybeToOptional y)))
 
foreign import javascript unsafe
        "(($1, $2, $3) => { return $1[\"createSVGPathSegMovetoRel\"]($2,\n$3); })"
        js_createSVGPathSegMovetoRel ::
        SVGPathElement ->
          Optional Float -> Optional Float -> IO SVGPathSegMovetoRel

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegMovetoRel Mozilla SVGPathElement.createSVGPathSegMovetoRel documentation> 
createSVGPathSegMovetoRel ::
                          (MonadIO m) =>
                            SVGPathElement ->
                              Maybe Float -> Maybe Float -> m SVGPathSegMovetoRel
createSVGPathSegMovetoRel self x y
  = liftIO
      (js_createSVGPathSegMovetoRel self (maybeToOptional x)
         (maybeToOptional y))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegMovetoRel Mozilla SVGPathElement.createSVGPathSegMovetoRel documentation> 
createSVGPathSegMovetoRel_ ::
                           (MonadIO m) => SVGPathElement -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegMovetoRel_ self x y
  = liftIO
      (void
         (js_createSVGPathSegMovetoRel self (maybeToOptional x)
            (maybeToOptional y)))
 
foreign import javascript unsafe
        "(($1, $2, $3) => { return $1[\"createSVGPathSegLinetoAbs\"]($2,\n$3); })"
        js_createSVGPathSegLinetoAbs ::
        SVGPathElement ->
          Optional Float -> Optional Float -> IO SVGPathSegLinetoAbs

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoAbs Mozilla SVGPathElement.createSVGPathSegLinetoAbs documentation> 
createSVGPathSegLinetoAbs ::
                          (MonadIO m) =>
                            SVGPathElement ->
                              Maybe Float -> Maybe Float -> m SVGPathSegLinetoAbs
createSVGPathSegLinetoAbs self x y
  = liftIO
      (js_createSVGPathSegLinetoAbs self (maybeToOptional x)
         (maybeToOptional y))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoAbs Mozilla SVGPathElement.createSVGPathSegLinetoAbs documentation> 
createSVGPathSegLinetoAbs_ ::
                           (MonadIO m) => SVGPathElement -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegLinetoAbs_ self x y
  = liftIO
      (void
         (js_createSVGPathSegLinetoAbs self (maybeToOptional x)
            (maybeToOptional y)))
 
foreign import javascript unsafe
        "(($1, $2, $3) => { return $1[\"createSVGPathSegLinetoRel\"]($2,\n$3); })"
        js_createSVGPathSegLinetoRel ::
        SVGPathElement ->
          Optional Float -> Optional Float -> IO SVGPathSegLinetoRel

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoRel Mozilla SVGPathElement.createSVGPathSegLinetoRel documentation> 
createSVGPathSegLinetoRel ::
                          (MonadIO m) =>
                            SVGPathElement ->
                              Maybe Float -> Maybe Float -> m SVGPathSegLinetoRel
createSVGPathSegLinetoRel self x y
  = liftIO
      (js_createSVGPathSegLinetoRel self (maybeToOptional x)
         (maybeToOptional y))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoRel Mozilla SVGPathElement.createSVGPathSegLinetoRel documentation> 
createSVGPathSegLinetoRel_ ::
                           (MonadIO m) => SVGPathElement -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegLinetoRel_ self x y
  = liftIO
      (void
         (js_createSVGPathSegLinetoRel self (maybeToOptional x)
            (maybeToOptional y)))
 
foreign import javascript unsafe
        "(($1, $2, $3, $4, $5, $6, $7) => { return $1[\"createSVGPathSegCurvetoCubicAbs\"]($2,\n$3, $4, $5, $6, $7); })"
        js_createSVGPathSegCurvetoCubicAbs ::
        SVGPathElement ->
          Optional Float ->
            Optional Float ->
              Optional Float ->
                Optional Float ->
                  Optional Float -> Optional Float -> IO SVGPathSegCurvetoCubicAbs

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicAbs Mozilla SVGPathElement.createSVGPathSegCurvetoCubicAbs documentation> 
createSVGPathSegCurvetoCubicAbs ::
                                (MonadIO m) =>
                                  SVGPathElement ->
                                    Maybe Float ->
                                      Maybe Float ->
                                        Maybe Float ->
                                          Maybe Float ->
                                            Maybe Float ->
                                              Maybe Float -> m SVGPathSegCurvetoCubicAbs
createSVGPathSegCurvetoCubicAbs self x y x1 y1 x2 y2
  = liftIO
      (js_createSVGPathSegCurvetoCubicAbs self (maybeToOptional x)
         (maybeToOptional y)
         (maybeToOptional x1)
         (maybeToOptional y1)
         (maybeToOptional x2)
         (maybeToOptional y2))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicAbs Mozilla SVGPathElement.createSVGPathSegCurvetoCubicAbs documentation> 
createSVGPathSegCurvetoCubicAbs_ ::
                                 (MonadIO m) =>
                                   SVGPathElement ->
                                     Maybe Float ->
                                       Maybe Float ->
                                         Maybe Float ->
                                           Maybe Float -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegCurvetoCubicAbs_ self x y x1 y1 x2 y2
  = liftIO
      (void
         (js_createSVGPathSegCurvetoCubicAbs self (maybeToOptional x)
            (maybeToOptional y)
            (maybeToOptional x1)
            (maybeToOptional y1)
            (maybeToOptional x2)
            (maybeToOptional y2)))
 
foreign import javascript unsafe
        "(($1, $2, $3, $4, $5, $6, $7) => { return $1[\"createSVGPathSegCurvetoCubicRel\"]($2,\n$3, $4, $5, $6, $7); })"
        js_createSVGPathSegCurvetoCubicRel ::
        SVGPathElement ->
          Optional Float ->
            Optional Float ->
              Optional Float ->
                Optional Float ->
                  Optional Float -> Optional Float -> IO SVGPathSegCurvetoCubicRel

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicRel Mozilla SVGPathElement.createSVGPathSegCurvetoCubicRel documentation> 
createSVGPathSegCurvetoCubicRel ::
                                (MonadIO m) =>
                                  SVGPathElement ->
                                    Maybe Float ->
                                      Maybe Float ->
                                        Maybe Float ->
                                          Maybe Float ->
                                            Maybe Float ->
                                              Maybe Float -> m SVGPathSegCurvetoCubicRel
createSVGPathSegCurvetoCubicRel self x y x1 y1 x2 y2
  = liftIO
      (js_createSVGPathSegCurvetoCubicRel self (maybeToOptional x)
         (maybeToOptional y)
         (maybeToOptional x1)
         (maybeToOptional y1)
         (maybeToOptional x2)
         (maybeToOptional y2))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicRel Mozilla SVGPathElement.createSVGPathSegCurvetoCubicRel documentation> 
createSVGPathSegCurvetoCubicRel_ ::
                                 (MonadIO m) =>
                                   SVGPathElement ->
                                     Maybe Float ->
                                       Maybe Float ->
                                         Maybe Float ->
                                           Maybe Float -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegCurvetoCubicRel_ self x y x1 y1 x2 y2
  = liftIO
      (void
         (js_createSVGPathSegCurvetoCubicRel self (maybeToOptional x)
            (maybeToOptional y)
            (maybeToOptional x1)
            (maybeToOptional y1)
            (maybeToOptional x2)
            (maybeToOptional y2)))
 
foreign import javascript unsafe
        "(($1, $2, $3, $4, $5) => { return $1[\"createSVGPathSegCurvetoQuadraticAbs\"]($2,\n$3, $4, $5); })"
        js_createSVGPathSegCurvetoQuadraticAbs ::
        SVGPathElement ->
          Optional Float ->
            Optional Float ->
              Optional Float ->
                Optional Float -> IO SVGPathSegCurvetoQuadraticAbs

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticAbs Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticAbs documentation> 
createSVGPathSegCurvetoQuadraticAbs ::
                                    (MonadIO m) =>
                                      SVGPathElement ->
                                        Maybe Float ->
                                          Maybe Float ->
                                            Maybe Float ->
                                              Maybe Float -> m SVGPathSegCurvetoQuadraticAbs
createSVGPathSegCurvetoQuadraticAbs self x y x1 y1
  = liftIO
      (js_createSVGPathSegCurvetoQuadraticAbs self (maybeToOptional x)
         (maybeToOptional y)
         (maybeToOptional x1)
         (maybeToOptional y1))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticAbs Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticAbs documentation> 
createSVGPathSegCurvetoQuadraticAbs_ ::
                                     (MonadIO m) =>
                                       SVGPathElement ->
                                         Maybe Float ->
                                           Maybe Float -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegCurvetoQuadraticAbs_ self x y x1 y1
  = liftIO
      (void
         (js_createSVGPathSegCurvetoQuadraticAbs self (maybeToOptional x)
            (maybeToOptional y)
            (maybeToOptional x1)
            (maybeToOptional y1)))
 
foreign import javascript unsafe
        "(($1, $2, $3, $4, $5) => { return $1[\"createSVGPathSegCurvetoQuadraticRel\"]($2,\n$3, $4, $5); })"
        js_createSVGPathSegCurvetoQuadraticRel ::
        SVGPathElement ->
          Optional Float ->
            Optional Float ->
              Optional Float ->
                Optional Float -> IO SVGPathSegCurvetoQuadraticRel

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticRel Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticRel documentation> 
createSVGPathSegCurvetoQuadraticRel ::
                                    (MonadIO m) =>
                                      SVGPathElement ->
                                        Maybe Float ->
                                          Maybe Float ->
                                            Maybe Float ->
                                              Maybe Float -> m SVGPathSegCurvetoQuadraticRel
createSVGPathSegCurvetoQuadraticRel self x y x1 y1
  = liftIO
      (js_createSVGPathSegCurvetoQuadraticRel self (maybeToOptional x)
         (maybeToOptional y)
         (maybeToOptional x1)
         (maybeToOptional y1))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticRel Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticRel documentation> 
createSVGPathSegCurvetoQuadraticRel_ ::
                                     (MonadIO m) =>
                                       SVGPathElement ->
                                         Maybe Float ->
                                           Maybe Float -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegCurvetoQuadraticRel_ self x y x1 y1
  = liftIO
      (void
         (js_createSVGPathSegCurvetoQuadraticRel self (maybeToOptional x)
            (maybeToOptional y)
            (maybeToOptional x1)
            (maybeToOptional y1)))
 
foreign import javascript unsafe
        "(($1, $2, $3, $4, $5, $6, $7, $8) => { return $1[\"createSVGPathSegArcAbs\"]($2,\n$3, $4, $5, $6, $7, $8); })"
        js_createSVGPathSegArcAbs ::
        SVGPathElement ->
          Optional Float ->
            Optional Float ->
              Optional Float ->
                Optional Float ->
                  Optional Float -> Bool -> Bool -> IO SVGPathSegArcAbs

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegArcAbs Mozilla SVGPathElement.createSVGPathSegArcAbs documentation> 
createSVGPathSegArcAbs ::
                       (MonadIO m) =>
                         SVGPathElement ->
                           Maybe Float ->
                             Maybe Float ->
                               Maybe Float ->
                                 Maybe Float -> Maybe Float -> Bool -> Bool -> m SVGPathSegArcAbs
createSVGPathSegArcAbs self x y r1 r2 angle largeArcFlag sweepFlag
  = liftIO
      (js_createSVGPathSegArcAbs self (maybeToOptional x)
         (maybeToOptional y)
         (maybeToOptional r1)
         (maybeToOptional r2)
         (maybeToOptional angle)
         largeArcFlag
         sweepFlag)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegArcAbs Mozilla SVGPathElement.createSVGPathSegArcAbs documentation> 
createSVGPathSegArcAbs_ ::
                        (MonadIO m) =>
                          SVGPathElement ->
                            Maybe Float ->
                              Maybe Float ->
                                Maybe Float -> Maybe Float -> Maybe Float -> Bool -> Bool -> m ()
createSVGPathSegArcAbs_ self x y r1 r2 angle largeArcFlag sweepFlag
  = liftIO
      (void
         (js_createSVGPathSegArcAbs self (maybeToOptional x)
            (maybeToOptional y)
            (maybeToOptional r1)
            (maybeToOptional r2)
            (maybeToOptional angle)
            largeArcFlag
            sweepFlag))
 
foreign import javascript unsafe
        "(($1, $2, $3, $4, $5, $6, $7, $8) => { return $1[\"createSVGPathSegArcRel\"]($2,\n$3, $4, $5, $6, $7, $8); })"
        js_createSVGPathSegArcRel ::
        SVGPathElement ->
          Optional Float ->
            Optional Float ->
              Optional Float ->
                Optional Float ->
                  Optional Float -> Bool -> Bool -> IO SVGPathSegArcRel

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegArcRel Mozilla SVGPathElement.createSVGPathSegArcRel documentation> 
createSVGPathSegArcRel ::
                       (MonadIO m) =>
                         SVGPathElement ->
                           Maybe Float ->
                             Maybe Float ->
                               Maybe Float ->
                                 Maybe Float -> Maybe Float -> Bool -> Bool -> m SVGPathSegArcRel
createSVGPathSegArcRel self x y r1 r2 angle largeArcFlag sweepFlag
  = liftIO
      (js_createSVGPathSegArcRel self (maybeToOptional x)
         (maybeToOptional y)
         (maybeToOptional r1)
         (maybeToOptional r2)
         (maybeToOptional angle)
         largeArcFlag
         sweepFlag)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegArcRel Mozilla SVGPathElement.createSVGPathSegArcRel documentation> 
createSVGPathSegArcRel_ ::
                        (MonadIO m) =>
                          SVGPathElement ->
                            Maybe Float ->
                              Maybe Float ->
                                Maybe Float -> Maybe Float -> Maybe Float -> Bool -> Bool -> m ()
createSVGPathSegArcRel_ self x y r1 r2 angle largeArcFlag sweepFlag
  = liftIO
      (void
         (js_createSVGPathSegArcRel self (maybeToOptional x)
            (maybeToOptional y)
            (maybeToOptional r1)
            (maybeToOptional r2)
            (maybeToOptional angle)
            largeArcFlag
            sweepFlag))
 
foreign import javascript unsafe
        "(($1, $2) => { return $1[\"createSVGPathSegLinetoHorizontalAbs\"]($2); })"
        js_createSVGPathSegLinetoHorizontalAbs ::
        SVGPathElement ->
          Optional Float -> IO SVGPathSegLinetoHorizontalAbs

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoHorizontalAbs Mozilla SVGPathElement.createSVGPathSegLinetoHorizontalAbs documentation> 
createSVGPathSegLinetoHorizontalAbs ::
                                    (MonadIO m) =>
                                      SVGPathElement ->
                                        Maybe Float -> m SVGPathSegLinetoHorizontalAbs
createSVGPathSegLinetoHorizontalAbs self x
  = liftIO
      (js_createSVGPathSegLinetoHorizontalAbs self (maybeToOptional x))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoHorizontalAbs Mozilla SVGPathElement.createSVGPathSegLinetoHorizontalAbs documentation> 
createSVGPathSegLinetoHorizontalAbs_ ::
                                     (MonadIO m) => SVGPathElement -> Maybe Float -> m ()
createSVGPathSegLinetoHorizontalAbs_ self x
  = liftIO
      (void
         (js_createSVGPathSegLinetoHorizontalAbs self (maybeToOptional x)))
 
foreign import javascript unsafe
        "(($1, $2) => { return $1[\"createSVGPathSegLinetoHorizontalRel\"]($2); })"
        js_createSVGPathSegLinetoHorizontalRel ::
        SVGPathElement ->
          Optional Float -> IO SVGPathSegLinetoHorizontalRel

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoHorizontalRel Mozilla SVGPathElement.createSVGPathSegLinetoHorizontalRel documentation> 
createSVGPathSegLinetoHorizontalRel ::
                                    (MonadIO m) =>
                                      SVGPathElement ->
                                        Maybe Float -> m SVGPathSegLinetoHorizontalRel
createSVGPathSegLinetoHorizontalRel self x
  = liftIO
      (js_createSVGPathSegLinetoHorizontalRel self (maybeToOptional x))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoHorizontalRel Mozilla SVGPathElement.createSVGPathSegLinetoHorizontalRel documentation> 
createSVGPathSegLinetoHorizontalRel_ ::
                                     (MonadIO m) => SVGPathElement -> Maybe Float -> m ()
createSVGPathSegLinetoHorizontalRel_ self x
  = liftIO
      (void
         (js_createSVGPathSegLinetoHorizontalRel self (maybeToOptional x)))
 
foreign import javascript unsafe
        "(($1, $2) => { return $1[\"createSVGPathSegLinetoVerticalAbs\"]($2); })"
        js_createSVGPathSegLinetoVerticalAbs ::
        SVGPathElement -> Optional Float -> IO SVGPathSegLinetoVerticalAbs

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoVerticalAbs Mozilla SVGPathElement.createSVGPathSegLinetoVerticalAbs documentation> 
createSVGPathSegLinetoVerticalAbs ::
                                  (MonadIO m) =>
                                    SVGPathElement -> Maybe Float -> m SVGPathSegLinetoVerticalAbs
createSVGPathSegLinetoVerticalAbs self y
  = liftIO
      (js_createSVGPathSegLinetoVerticalAbs self (maybeToOptional y))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoVerticalAbs Mozilla SVGPathElement.createSVGPathSegLinetoVerticalAbs documentation> 
createSVGPathSegLinetoVerticalAbs_ ::
                                   (MonadIO m) => SVGPathElement -> Maybe Float -> m ()
createSVGPathSegLinetoVerticalAbs_ self y
  = liftIO
      (void
         (js_createSVGPathSegLinetoVerticalAbs self (maybeToOptional y)))
 
foreign import javascript unsafe
        "(($1, $2) => { return $1[\"createSVGPathSegLinetoVerticalRel\"]($2); })"
        js_createSVGPathSegLinetoVerticalRel ::
        SVGPathElement -> Optional Float -> IO SVGPathSegLinetoVerticalRel

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoVerticalRel Mozilla SVGPathElement.createSVGPathSegLinetoVerticalRel documentation> 
createSVGPathSegLinetoVerticalRel ::
                                  (MonadIO m) =>
                                    SVGPathElement -> Maybe Float -> m SVGPathSegLinetoVerticalRel
createSVGPathSegLinetoVerticalRel self y
  = liftIO
      (js_createSVGPathSegLinetoVerticalRel self (maybeToOptional y))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegLinetoVerticalRel Mozilla SVGPathElement.createSVGPathSegLinetoVerticalRel documentation> 
createSVGPathSegLinetoVerticalRel_ ::
                                   (MonadIO m) => SVGPathElement -> Maybe Float -> m ()
createSVGPathSegLinetoVerticalRel_ self y
  = liftIO
      (void
         (js_createSVGPathSegLinetoVerticalRel self (maybeToOptional y)))
 
foreign import javascript unsafe
        "(($1, $2, $3, $4, $5) => { return $1[\"createSVGPathSegCurvetoCubicSmoothAbs\"]($2,\n$3, $4, $5); })"
        js_createSVGPathSegCurvetoCubicSmoothAbs ::
        SVGPathElement ->
          Optional Float ->
            Optional Float ->
              Optional Float ->
                Optional Float -> IO SVGPathSegCurvetoCubicSmoothAbs

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicSmoothAbs Mozilla SVGPathElement.createSVGPathSegCurvetoCubicSmoothAbs documentation> 
createSVGPathSegCurvetoCubicSmoothAbs ::
                                      (MonadIO m) =>
                                        SVGPathElement ->
                                          Maybe Float ->
                                            Maybe Float ->
                                              Maybe Float ->
                                                Maybe Float -> m SVGPathSegCurvetoCubicSmoothAbs
createSVGPathSegCurvetoCubicSmoothAbs self x y x2 y2
  = liftIO
      (js_createSVGPathSegCurvetoCubicSmoothAbs self (maybeToOptional x)
         (maybeToOptional y)
         (maybeToOptional x2)
         (maybeToOptional y2))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicSmoothAbs Mozilla SVGPathElement.createSVGPathSegCurvetoCubicSmoothAbs documentation> 
createSVGPathSegCurvetoCubicSmoothAbs_ ::
                                       (MonadIO m) =>
                                         SVGPathElement ->
                                           Maybe Float ->
                                             Maybe Float -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegCurvetoCubicSmoothAbs_ self x y x2 y2
  = liftIO
      (void
         (js_createSVGPathSegCurvetoCubicSmoothAbs self (maybeToOptional x)
            (maybeToOptional y)
            (maybeToOptional x2)
            (maybeToOptional y2)))
 
foreign import javascript unsafe
        "(($1, $2, $3, $4, $5) => { return $1[\"createSVGPathSegCurvetoCubicSmoothRel\"]($2,\n$3, $4, $5); })"
        js_createSVGPathSegCurvetoCubicSmoothRel ::
        SVGPathElement ->
          Optional Float ->
            Optional Float ->
              Optional Float ->
                Optional Float -> IO SVGPathSegCurvetoCubicSmoothRel

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicSmoothRel Mozilla SVGPathElement.createSVGPathSegCurvetoCubicSmoothRel documentation> 
createSVGPathSegCurvetoCubicSmoothRel ::
                                      (MonadIO m) =>
                                        SVGPathElement ->
                                          Maybe Float ->
                                            Maybe Float ->
                                              Maybe Float ->
                                                Maybe Float -> m SVGPathSegCurvetoCubicSmoothRel
createSVGPathSegCurvetoCubicSmoothRel self x y x2 y2
  = liftIO
      (js_createSVGPathSegCurvetoCubicSmoothRel self (maybeToOptional x)
         (maybeToOptional y)
         (maybeToOptional x2)
         (maybeToOptional y2))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoCubicSmoothRel Mozilla SVGPathElement.createSVGPathSegCurvetoCubicSmoothRel documentation> 
createSVGPathSegCurvetoCubicSmoothRel_ ::
                                       (MonadIO m) =>
                                         SVGPathElement ->
                                           Maybe Float ->
                                             Maybe Float -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegCurvetoCubicSmoothRel_ self x y x2 y2
  = liftIO
      (void
         (js_createSVGPathSegCurvetoCubicSmoothRel self (maybeToOptional x)
            (maybeToOptional y)
            (maybeToOptional x2)
            (maybeToOptional y2)))
 
foreign import javascript unsafe
        "(($1, $2, $3) => { return $1[\"createSVGPathSegCurvetoQuadraticSmoothAbs\"]($2,\n$3); })"
        js_createSVGPathSegCurvetoQuadraticSmoothAbs ::
        SVGPathElement ->
          Optional Float ->
            Optional Float -> IO SVGPathSegCurvetoQuadraticSmoothAbs

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothAbs Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothAbs documentation> 
createSVGPathSegCurvetoQuadraticSmoothAbs ::
                                          (MonadIO m) =>
                                            SVGPathElement ->
                                              Maybe Float ->
                                                Maybe Float -> m SVGPathSegCurvetoQuadraticSmoothAbs
createSVGPathSegCurvetoQuadraticSmoothAbs self x y
  = liftIO
      (js_createSVGPathSegCurvetoQuadraticSmoothAbs self
         (maybeToOptional x)
         (maybeToOptional y))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothAbs Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothAbs documentation> 
createSVGPathSegCurvetoQuadraticSmoothAbs_ ::
                                           (MonadIO m) =>
                                             SVGPathElement -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegCurvetoQuadraticSmoothAbs_ self x y
  = liftIO
      (void
         (js_createSVGPathSegCurvetoQuadraticSmoothAbs self
            (maybeToOptional x)
            (maybeToOptional y)))
 
foreign import javascript unsafe
        "(($1, $2, $3) => { return $1[\"createSVGPathSegCurvetoQuadraticSmoothRel\"]($2,\n$3); })"
        js_createSVGPathSegCurvetoQuadraticSmoothRel ::
        SVGPathElement ->
          Optional Float ->
            Optional Float -> IO SVGPathSegCurvetoQuadraticSmoothRel

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothRel Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothRel documentation> 
createSVGPathSegCurvetoQuadraticSmoothRel ::
                                          (MonadIO m) =>
                                            SVGPathElement ->
                                              Maybe Float ->
                                                Maybe Float -> m SVGPathSegCurvetoQuadraticSmoothRel
createSVGPathSegCurvetoQuadraticSmoothRel self x y
  = liftIO
      (js_createSVGPathSegCurvetoQuadraticSmoothRel self
         (maybeToOptional x)
         (maybeToOptional y))

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothRel Mozilla SVGPathElement.createSVGPathSegCurvetoQuadraticSmoothRel documentation> 
createSVGPathSegCurvetoQuadraticSmoothRel_ ::
                                           (MonadIO m) =>
                                             SVGPathElement -> Maybe Float -> Maybe Float -> m ()
createSVGPathSegCurvetoQuadraticSmoothRel_ self x y
  = liftIO
      (void
         (js_createSVGPathSegCurvetoQuadraticSmoothRel self
            (maybeToOptional x)
            (maybeToOptional y)))
 
foreign import javascript unsafe "(($1) => { return $1[\"pathLength\"]; })"
        js_getPathLength :: SVGPathElement -> IO SVGAnimatedNumber

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.pathLength Mozilla SVGPathElement.pathLength documentation> 
getPathLength ::
              (MonadIO m) => SVGPathElement -> m SVGAnimatedNumber
getPathLength self = liftIO (js_getPathLength self)
 
foreign import javascript unsafe "(($1) => { return $1[\"pathSegList\"]; })"
        js_getPathSegList :: SVGPathElement -> IO SVGPathSegList

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.pathSegList Mozilla SVGPathElement.pathSegList documentation> 
getPathSegList :: (MonadIO m) => SVGPathElement -> m SVGPathSegList
getPathSegList self = liftIO (js_getPathSegList self)
 
foreign import javascript unsafe "(($1) => { return $1[\"normalizedPathSegList\"]; })"
        js_getNormalizedPathSegList :: SVGPathElement -> IO SVGPathSegList

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.normalizedPathSegList Mozilla SVGPathElement.normalizedPathSegList documentation> 
getNormalizedPathSegList ::
                         (MonadIO m) => SVGPathElement -> m SVGPathSegList
getNormalizedPathSegList self
  = liftIO (js_getNormalizedPathSegList self)
 
foreign import javascript unsafe "(($1) => { return $1[\"animatedPathSegList\"]; })"
        js_getAnimatedPathSegList :: SVGPathElement -> IO SVGPathSegList

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.animatedPathSegList Mozilla SVGPathElement.animatedPathSegList documentation> 
getAnimatedPathSegList ::
                       (MonadIO m) => SVGPathElement -> m SVGPathSegList
getAnimatedPathSegList self
  = liftIO (js_getAnimatedPathSegList self)
 
foreign import javascript unsafe
        "(($1) => { return $1[\"animatedNormalizedPathSegList\"]; })"
        js_getAnimatedNormalizedPathSegList ::
        SVGPathElement -> IO SVGPathSegList

-- | <https://developer.mozilla.org/en-US/docs/Web/API/SVGPathElement.animatedNormalizedPathSegList Mozilla SVGPathElement.animatedNormalizedPathSegList documentation> 
getAnimatedNormalizedPathSegList ::
                                 (MonadIO m) => SVGPathElement -> m SVGPathSegList
getAnimatedNormalizedPathSegList self
  = liftIO (js_getAnimatedNormalizedPathSegList self)