0 | module Web.Raw.Animation

   2 | import JS

   3 | import Web.Internal.AnimationPrim

   4 | import Web.Internal.Types

   6 | %default total

  13 | namespace Animation

  15 |   export

  16 |   currentTime :

  17 |        {auto 0 _ : JSType t}

  18 |     -> {auto 0 _ : Elem Animation (Types t)}

  19 |     -> t

  20 |     -> Attribute False Maybe Double

  21 |   currentTime v = fromNullablePrim

  22 |                     "Animation.getcurrentTime"

  23 |                     prim__currentTime

  24 |                     prim__setCurrentTime

  25 |                     (v :> Animation)

  28 |   export

  29 |   effect :

  30 |        {auto 0 _ : JSType t}

  31 |     -> {auto 0 _ : Elem Animation (Types t)}

  32 |     -> t

  33 |     -> Attribute False Maybe AnimationEffect

  34 |   effect v = fromNullablePrim

  35 |                "Animation.geteffect"

  36 |                prim__effect

  37 |                prim__setEffect

  38 |                (v :> Animation)

  41 |   export

  42 |   finished :

  43 |        {auto 0 _ : JSType t1}

  44 |     -> {auto 0 _ : Elem Animation (Types t1)}

  45 |     -> (obj : t1)

  46 |     -> JSIO (Promise Animation)

  47 |   finished a = primJS $ Animation.prim__finished (up a)

  50 |   export

  51 |   id :

  52 |        {auto 0 _ : JSType t}

  53 |     -> {auto 0 _ : Elem Animation (Types t)}

  54 |     -> t

  55 |     -> Attribute True Prelude.id String

  56 |   id v = fromPrim "Animation.getid" prim__id prim__setId (v :> Animation)

  59 |   export

  60 |   oncancel :

  61 |        {auto 0 _ : JSType t}

  62 |     -> {auto 0 _ : Elem Animation (Types t)}

  63 |     -> t

  64 |     -> Attribute False Maybe EventHandlerNonNull

  65 |   oncancel v = fromNullablePrim

  66 |                  "Animation.getoncancel"

  67 |                  prim__oncancel

  68 |                  prim__setOncancel

  69 |                  (v :> Animation)

  72 |   export

  73 |   onfinish :

  74 |        {auto 0 _ : JSType t}

  75 |     -> {auto 0 _ : Elem Animation (Types t)}

  76 |     -> t

  77 |     -> Attribute False Maybe EventHandlerNonNull

  78 |   onfinish v = fromNullablePrim

  79 |                  "Animation.getonfinish"

  80 |                  prim__onfinish

  81 |                  prim__setOnfinish

  82 |                  (v :> Animation)

  85 |   export

  86 |   pending :

  87 |        {auto 0 _ : JSType t1}

  88 |     -> {auto 0 _ : Elem Animation (Types t1)}

  89 |     -> (obj : t1)

  90 |     -> JSIO Bool

  91 |   pending a = tryJS "Animation.pending" $ Animation.prim__pending (up a)

  94 |   export

  95 |   playState :

  96 |        {auto 0 _ : JSType t1}

  97 |     -> {auto 0 _ : Elem Animation (Types t1)}

  98 |     -> (obj : t1)

  99 |     -> JSIO AnimationPlayState

 100 |   playState a = tryJS "Animation.playState" $ Animation.prim__playState (up a)

 103 |   export

 104 |   playbackRate :

 105 |        {auto 0 _ : JSType t}

 106 |     -> {auto 0 _ : Elem Animation (Types t)}

 107 |     -> t

 108 |     -> Attribute True Prelude.id Double

 109 |   playbackRate v = fromPrim

 110 |                      "Animation.getplaybackRate"

 111 |                      prim__playbackRate

 112 |                      prim__setPlaybackRate

 113 |                      (v :> Animation)

 116 |   export

 117 |   ready :

 118 |        {auto 0 _ : JSType t1}

 119 |     -> {auto 0 _ : Elem Animation (Types t1)}

 120 |     -> (obj : t1)

 121 |     -> JSIO (Promise Animation)

 122 |   ready a = primJS $ Animation.prim__ready (up a)

 125 |   export

 126 |   startTime :

 127 |        {auto 0 _ : JSType t}

 128 |     -> {auto 0 _ : Elem Animation (Types t)}

 129 |     -> t

 130 |     -> Attribute False Maybe Double

 131 |   startTime v = fromNullablePrim

 132 |                   "Animation.getstartTime"

 133 |                   prim__startTime

 134 |                   prim__setStartTime

 135 |                   (v :> Animation)

 138 |   export

 139 |   timeline :

 140 |        {auto 0 _ : JSType t}

 141 |     -> {auto 0 _ : Elem Animation (Types t)}

 142 |     -> t

 143 |     -> Attribute False Maybe AnimationTimeline

 144 |   timeline v = fromNullablePrim

 145 |                  "Animation.gettimeline"

 146 |                  prim__timeline

 147 |                  prim__setTimeline

 148 |                  (v :> Animation)

 151 |   export

 152 |   cancel :

 153 |        {auto 0 _ : JSType t1}

 154 |     -> {auto 0 _ : Elem Animation (Types t1)}

 155 |     -> (obj : t1)

 156 |     -> JSIO ()

 157 |   cancel a = primJS $ Animation.prim__cancel (up a)

 160 |   export

 161 |   finish :

 162 |        {auto 0 _ : JSType t1}

 163 |     -> {auto 0 _ : Elem Animation (Types t1)}

 164 |     -> (obj : t1)

 165 |     -> JSIO ()

 166 |   finish a = primJS $ Animation.prim__finish (up a)

 169 |   export

 170 |   pause :

 171 |        {auto 0 _ : JSType t1}

 172 |     -> {auto 0 _ : Elem Animation (Types t1)}

 173 |     -> (obj : t1)

 174 |     -> JSIO ()

 175 |   pause a = primJS $ Animation.prim__pause (up a)

 178 |   export

 179 |   play :

 180 |        {auto 0 _ : JSType t1}

 181 |     -> {auto 0 _ : Elem Animation (Types t1)}

 182 |     -> (obj : t1)

 183 |     -> JSIO ()

 184 |   play a = primJS $ Animation.prim__play (up a)

 187 |   export

 188 |   reverse :

 189 |        {auto 0 _ : JSType t1}

 190 |     -> {auto 0 _ : Elem Animation (Types t1)}

 191 |     -> (obj : t1)

 192 |     -> JSIO ()

 193 |   reverse a = primJS $ Animation.prim__reverse (up a)

 196 |   export

 197 |   updatePlaybackRate :

 198 |        {auto 0 _ : JSType t1}

 199 |     -> {auto 0 _ : Elem Animation (Types t1)}

 200 |     -> (obj : t1)

 201 |     -> (playbackRate : Double)

 202 |     -> JSIO ()

 203 |   updatePlaybackRate a b = primJS $ Animation.prim__updatePlaybackRate (up a) b

 207 | namespace AnimationEffect

 209 |   export

 210 |   getComputedTiming :

 211 |        {auto 0 _ : JSType t1}

 212 |     -> {auto 0 _ : Elem AnimationEffect (Types t1)}

 213 |     -> (obj : t1)

 214 |     -> JSIO ComputedEffectTiming

 215 |   getComputedTiming a = primJS $ AnimationEffect.prim__getComputedTiming (up a)

 218 |   export

 219 |   getTiming :

 220 |        {auto 0 _ : JSType t1}

 221 |     -> {auto 0 _ : Elem AnimationEffect (Types t1)}

 222 |     -> (obj : t1)

 223 |     -> JSIO EffectTiming

 224 |   getTiming a = primJS $ AnimationEffect.prim__getTiming (up a)

 227 |   export

 228 |   updateTiming' :

 229 |        {auto 0 _ : JSType t1}

 230 |     -> {auto 0 _ : JSType t2}

 231 |     -> {auto 0 _ : Elem AnimationEffect (Types t1)}

 232 |     -> {auto 0 _ : Elem OptionalEffectTiming (Types t2)}

 233 |     -> (obj : t1)

 234 |     -> (timing : Optional t2)

 235 |     -> JSIO ()

 236 |   updateTiming' a b = primJS $

 237 |     AnimationEffect.prim__updateTiming (up a) (optUp b)

 239 |   export

 240 |   updateTiming :

 241 |        {auto 0 _ : JSType t1}

 242 |     -> {auto 0 _ : Elem AnimationEffect (Types t1)}

 243 |     -> (obj : t1)

 244 |     -> JSIO ()

 245 |   updateTiming a = primJS $ AnimationEffect.prim__updateTiming (up a) undef

 249 | namespace AnimationPlaybackEvent

 251 |   export

 252 |   currentTime : (obj : AnimationPlaybackEvent) -> JSIO (Maybe Double)

 253 |   currentTime a = tryJS "AnimationPlaybackEvent.currentTime" $

 254 |     AnimationPlaybackEvent.prim__currentTime a

 257 |   export

 258 |   timelineTime : (obj : AnimationPlaybackEvent) -> JSIO (Maybe Double)

 259 |   timelineTime a = tryJS "AnimationPlaybackEvent.timelineTime" $

 260 |     AnimationPlaybackEvent.prim__timelineTime a

 264 | namespace AnimationTimeline

 266 |   export

 267 |   currentTime :

 268 |        {auto 0 _ : JSType t1}

 269 |     -> {auto 0 _ : Elem AnimationTimeline (Types t1)}

 270 |     -> (obj : t1)

 271 |     -> JSIO (Maybe Double)

 272 |   currentTime a = tryJS "AnimationTimeline.currentTime" $

 273 |     AnimationTimeline.prim__currentTime (up a)

 278 | namespace KeyframeEffect

 280 |   export

 281 |   composite : KeyframeEffect -> Attribute True Prelude.id CompositeOperation

 282 |   composite v = fromPrim

 283 |                   "KeyframeEffect.getcomposite"

 284 |                   prim__composite

 285 |                   prim__setComposite

 286 |                   v

 289 |   export

 290 |   iterationComposite :

 291 |        KeyframeEffect

 292 |     -> Attribute True Prelude.id IterationCompositeOperation

 293 |   iterationComposite v = fromPrim

 294 |                            "KeyframeEffect.getiterationComposite"

 295 |                            prim__iterationComposite

 296 |                            prim__setIterationComposite

 297 |                            v

 300 |   export

 301 |   target :

 302 |        KeyframeEffect

 303 |     -> Attribute False Maybe (HSum [Element, CSSPseudoElement])

 304 |   target v = fromNullablePrim

 305 |                "KeyframeEffect.gettarget"

 306 |                prim__target

 307 |                prim__setTarget

 308 |                v

 311 |   export

 312 |   getKeyframes : (obj : KeyframeEffect) -> JSIO (Array Object)

 313 |   getKeyframes a = primJS $ KeyframeEffect.prim__getKeyframes a

 316 |   export

 317 |   setKeyframes :

 318 |        {auto 0 _ : JSType t2}

 319 |     -> {auto 0 _ : Elem Object (Types t2)}

 320 |     -> (obj : KeyframeEffect)

 321 |     -> (keyframes : Maybe t2)

 322 |     -> JSIO ()

 323 |   setKeyframes a b = primJS $ KeyframeEffect.prim__setKeyframes a (mayUp b)

 332 | namespace Animatable

 334 |   export

 335 |   animate' :

 336 |        {auto 0 _ : JSType t1}

 337 |     -> {auto 0 _ : JSType t2}

 338 |     -> {auto 0 _ : Elem Animatable (Types t1)}

 339 |     -> {auto 0 _ : Elem Object (Types t2)}

 340 |     -> (obj : t1)

 341 |     -> (keyframes : Maybe t2)

 342 |     -> (options : Optional (HSum [Double, KeyframeAnimationOptions]))

 343 |     -> JSIO Animation

 344 |   animate' a b c = primJS $ Animatable.prim__animate (up a) (mayUp b) (toFFI c)

 346 |   export

 347 |   animate :

 348 |        {auto 0 _ : JSType t1}

 349 |     -> {auto 0 _ : JSType t2}

 350 |     -> {auto 0 _ : Elem Animatable (Types t1)}

 351 |     -> {auto 0 _ : Elem Object (Types t2)}

 352 |     -> (obj : t1)

 353 |     -> (keyframes : Maybe t2)

 354 |     -> JSIO Animation

 355 |   animate a b = primJS $ Animatable.prim__animate (up a) (mayUp b) undef

 358 |   export

 359 |   getAnimations :

 360 |        {auto 0 _ : JSType t1}

 361 |     -> {auto 0 _ : Elem Animatable (Types t1)}

 362 |     -> (obj : t1)

 363 |     -> JSIO (Array Animation)

 364 |   getAnimations a = primJS $ Animatable.prim__getAnimations (up a)

 373 | namespace AnimationPlaybackEventInit

 375 |   export

 376 |   new' :

 377 |        (currentTime : Optional (Maybe Double))

 378 |     -> (timelineTime : Optional (Maybe Double))

 379 |     -> JSIO AnimationPlaybackEventInit

 380 |   new' a b = primJS $ AnimationPlaybackEventInit.prim__new (toFFI a) (toFFI b)

 382 |   export

 383 |   new : JSIO AnimationPlaybackEventInit

 384 |   new = primJS $ AnimationPlaybackEventInit.prim__new undef undef

 387 |   export

 388 |   currentTime :

 389 |        {auto 0 _ : JSType t}

 390 |     -> {auto 0 _ : Elem AnimationPlaybackEventInit (Types t)}

 391 |     -> t

 392 |     -> Attribute True Optional (Maybe Double)

 393 |   currentTime v = fromUndefOrPrim

 394 |                     "AnimationPlaybackEventInit.getcurrentTime"

 395 |                     prim__currentTime

 396 |                     prim__setCurrentTime

 397 |                     Nothing

 398 |                     (v :> AnimationPlaybackEventInit)

 401 |   export

 402 |   timelineTime :

 403 |        {auto 0 _ : JSType t}

 404 |     -> {auto 0 _ : Elem AnimationPlaybackEventInit (Types t)}

 405 |     -> t

 406 |     -> Attribute True Optional (Maybe Double)

 407 |   timelineTime v = fromUndefOrPrim

 408 |                      "AnimationPlaybackEventInit.gettimelineTime"

 409 |                      prim__timelineTime

 410 |                      prim__setTimelineTime

 411 |                      Nothing

 412 |                      (v :> AnimationPlaybackEventInit)

 416 | namespace BaseComputedKeyframe

 418 |   export

 419 |   new' :

 420 |        (offset : Optional (Maybe Double))

 421 |     -> (computedOffset : Optional Double)

 422 |     -> (easing : Optional String)

 423 |     -> (composite : Optional CompositeOperationOrAuto)

 424 |     -> JSIO BaseComputedKeyframe

 425 |   new' a b c d = primJS $

 426 |     BaseComputedKeyframe.prim__new (toFFI a) (toFFI b) (toFFI c) (toFFI d)

 428 |   export

 429 |   new : JSIO BaseComputedKeyframe

 430 |   new = primJS $ BaseComputedKeyframe.prim__new undef undef undef undef

 433 |   export

 434 |   composite :

 435 |        {auto 0 _ : JSType t}

 436 |     -> {auto 0 _ : Elem BaseComputedKeyframe (Types t)}

 437 |     -> t

 438 |     -> Attribute False Optional CompositeOperationOrAuto

 439 |   composite v = fromUndefOrPrimNoDefault

 440 |                   "BaseComputedKeyframe.getcomposite"

 441 |                   prim__composite

 442 |                   prim__setComposite

 443 |                   (v :> BaseComputedKeyframe)

 446 |   export

 447 |   computedOffset :

 448 |        {auto 0 _ : JSType t}

 449 |     -> {auto 0 _ : Elem BaseComputedKeyframe (Types t)}

 450 |     -> t

 451 |     -> Attribute False Optional Double

 452 |   computedOffset v = fromUndefOrPrimNoDefault

 453 |                        "BaseComputedKeyframe.getcomputedOffset"

 454 |                        prim__computedOffset

 455 |                        prim__setComputedOffset

 456 |                        (v :> BaseComputedKeyframe)

 459 |   export

 460 |   easing :

 461 |        {auto 0 _ : JSType t}

 462 |     -> {auto 0 _ : Elem BaseComputedKeyframe (Types t)}

 463 |     -> t

 464 |     -> Attribute True Optional String

 465 |   easing v = fromUndefOrPrim

 466 |                "BaseComputedKeyframe.geteasing"

 467 |                prim__easing

 468 |                prim__setEasing

 469 |                "linear"

 470 |                (v :> BaseComputedKeyframe)

 473 |   export

 474 |   offset :

 475 |        {auto 0 _ : JSType t}

 476 |     -> {auto 0 _ : Elem BaseComputedKeyframe (Types t)}

 477 |     -> t

 478 |     -> Attribute True Optional (Maybe Double)

 479 |   offset v = fromUndefOrPrim

 480 |                "BaseComputedKeyframe.getoffset"

 481 |                prim__offset

 482 |                prim__setOffset

 483 |                Nothing

 484 |                (v :> BaseComputedKeyframe)

 488 | namespace BaseKeyframe

 490 |   export

 491 |   new' :

 492 |        (offset : Optional (Maybe Double))

 493 |     -> (easing : Optional String)

 494 |     -> (composite : Optional CompositeOperationOrAuto)

 495 |     -> JSIO BaseKeyframe

 496 |   new' a b c = primJS $ BaseKeyframe.prim__new (toFFI a) (toFFI b) (toFFI c)

 498 |   export

 499 |   new : JSIO BaseKeyframe

 500 |   new = primJS $ BaseKeyframe.prim__new undef undef undef

 503 |   export

 504 |   composite :

 505 |        {auto 0 _ : JSType t}

 506 |     -> {auto 0 _ : Elem BaseKeyframe (Types t)}

 507 |     -> t

 508 |     -> Attribute False Optional CompositeOperationOrAuto

 509 |   composite v = fromUndefOrPrimNoDefault

 510 |                   "BaseKeyframe.getcomposite"

 511 |                   prim__composite

 512 |                   prim__setComposite

 513 |                   (v :> BaseKeyframe)

 516 |   export

 517 |   easing :

 518 |        {auto 0 _ : JSType t}

 519 |     -> {auto 0 _ : Elem BaseKeyframe (Types t)}

 520 |     -> t

 521 |     -> Attribute True Optional String

 522 |   easing v = fromUndefOrPrim

 523 |                "BaseKeyframe.geteasing"

 524 |                prim__easing

 525 |                prim__setEasing

 526 |                "linear"

 527 |                (v :> BaseKeyframe)

 530 |   export

 531 |   offset :

 532 |        {auto 0 _ : JSType t}

 533 |     -> {auto 0 _ : Elem BaseKeyframe (Types t)}

 534 |     -> t

 535 |     -> Attribute True Optional (Maybe Double)

 536 |   offset v = fromUndefOrPrim

 537 |                "BaseKeyframe.getoffset"

 538 |                prim__offset

 539 |                prim__setOffset

 540 |                Nothing

 541 |                (v :> BaseKeyframe)

 545 | namespace BasePropertyIndexedKeyframe

 547 |   export

 548 |   new' :

 549 |        (offset : Optional (Maybe (HSum [Double, Array (Nullable Double)])))

 550 |     -> (easing : Optional (HSum [String, Array String]))

 551 |     -> (composite : Optional (HSum [CompositeOperationOrAuto, Array String]))

 552 |     -> JSIO BasePropertyIndexedKeyframe

 553 |   new' a b c = primJS $

 554 |     BasePropertyIndexedKeyframe.prim__new (toFFI a) (toFFI b) (toFFI c)

 556 |   export

 557 |   new : JSIO BasePropertyIndexedKeyframe

 558 |   new = primJS $ BasePropertyIndexedKeyframe.prim__new undef undef undef

 561 |   export

 562 |   composite :

 563 |        {auto 0 _ : JSType t}

 564 |     -> {auto 0 _ : Elem BasePropertyIndexedKeyframe (Types t)}

 565 |     -> t

 566 |     -> Attribute False Optional (Union2 String (Array String))

 567 |   composite v = fromUndefOrPrimNoDefault

 568 |                   "BasePropertyIndexedKeyframe.getcomposite"

 569 |                   prim__composite

 570 |                   prim__setComposite

 571 |                   (v :> BasePropertyIndexedKeyframe)

 574 |   export

 575 |   easing :

 576 |        {auto 0 _ : JSType t}

 577 |     -> {auto 0 _ : Elem BasePropertyIndexedKeyframe (Types t)}

 578 |     -> t

 579 |     -> Attribute False Optional (Union2 String (Array String))

 580 |   easing v = fromUndefOrPrimNoDefault

 581 |                "BasePropertyIndexedKeyframe.geteasing"

 582 |                prim__easing

 583 |                prim__setEasing

 584 |                (v :> BasePropertyIndexedKeyframe)

 587 |   export

 588 |   offset :

 589 |        {auto 0 _ : JSType t}

 590 |     -> {auto 0 _ : Elem BasePropertyIndexedKeyframe (Types t)}

 591 |     -> t

 592 |     -> Attribute False Optional (Maybe

 593 |                                    (Union2 Double (Array (Nullable Double))))

 594 |   offset v = fromUndefOrPrimNoDefault

 595 |                "BasePropertyIndexedKeyframe.getoffset"

 596 |                prim__offset

 597 |                prim__setOffset

 598 |                (v :> BasePropertyIndexedKeyframe)

 602 | namespace ComputedEffectTiming

 604 |   export

 605 |   new' :

 606 |        (endTime : Optional Double)

 607 |     -> (activeDuration : Optional Double)

 608 |     -> (localTime : Optional (Maybe Double))

 609 |     -> (progress : Optional (Maybe Double))

 610 |     -> (currentIteration : Optional (Maybe Double))

 611 |     -> JSIO ComputedEffectTiming

 612 |   new' a b c d e = primJS $

 613 |     ComputedEffectTiming.prim__new

 614 |       (toFFI a)

 615 |       (toFFI b)

 616 |       (toFFI c)

 617 |       (toFFI d)

 618 |       (toFFI e)

 620 |   export

 621 |   new : JSIO ComputedEffectTiming

 622 |   new = primJS $ ComputedEffectTiming.prim__new undef undef undef undef undef

 625 |   export

 626 |   activeDuration :

 627 |        {auto 0 _ : JSType t}

 628 |     -> {auto 0 _ : Elem ComputedEffectTiming (Types t)}

 629 |     -> t

 630 |     -> Attribute False Optional Double

 631 |   activeDuration v = fromUndefOrPrimNoDefault

 632 |                        "ComputedEffectTiming.getactiveDuration"

 633 |                        prim__activeDuration

 634 |                        prim__setActiveDuration

 635 |                        (v :> ComputedEffectTiming)

 638 |   export

 639 |   currentIteration :

 640 |        {auto 0 _ : JSType t}

 641 |     -> {auto 0 _ : Elem ComputedEffectTiming (Types t)}

 642 |     -> t

 643 |     -> Attribute False Optional (Maybe Double)

 644 |   currentIteration v = fromUndefOrPrimNoDefault

 645 |                          "ComputedEffectTiming.getcurrentIteration"

 646 |                          prim__currentIteration

 647 |                          prim__setCurrentIteration

 648 |                          (v :> ComputedEffectTiming)

 651 |   export

 652 |   endTime :

 653 |        {auto 0 _ : JSType t}

 654 |     -> {auto 0 _ : Elem ComputedEffectTiming (Types t)}

 655 |     -> t

 656 |     -> Attribute False Optional Double

 657 |   endTime v = fromUndefOrPrimNoDefault

 658 |                 "ComputedEffectTiming.getendTime"

 659 |                 prim__endTime

 660 |                 prim__setEndTime

 661 |                 (v :> ComputedEffectTiming)

 664 |   export

 665 |   localTime :

 666 |        {auto 0 _ : JSType t}

 667 |     -> {auto 0 _ : Elem ComputedEffectTiming (Types t)}

 668 |     -> t

 669 |     -> Attribute False Optional (Maybe Double)

 670 |   localTime v = fromUndefOrPrimNoDefault

 671 |                   "ComputedEffectTiming.getlocalTime"

 672 |                   prim__localTime

 673 |                   prim__setLocalTime

 674 |                   (v :> ComputedEffectTiming)

 677 |   export

 678 |   progress :

 679 |        {auto 0 _ : JSType t}

 680 |     -> {auto 0 _ : Elem ComputedEffectTiming (Types t)}

 681 |     -> t

 682 |     -> Attribute False Optional (Maybe Double)

 683 |   progress v = fromUndefOrPrimNoDefault

 684 |                  "ComputedEffectTiming.getprogress"

 685 |                  prim__progress

 686 |                  prim__setProgress

 687 |                  (v :> ComputedEffectTiming)

 691 | namespace DocumentTimelineOptions

 693 |   export

 694 |   new' : (originTime : Optional Double) -> JSIO DocumentTimelineOptions

 695 |   new' a = primJS $ DocumentTimelineOptions.prim__new (toFFI a)

 697 |   export

 698 |   new : JSIO DocumentTimelineOptions

 699 |   new = primJS $ DocumentTimelineOptions.prim__new undef

 702 |   export

 703 |   originTime :

 704 |        {auto 0 _ : JSType t}

 705 |     -> {auto 0 _ : Elem DocumentTimelineOptions (Types t)}

 706 |     -> t

 707 |     -> Attribute True Optional Double

 708 |   originTime v = fromUndefOrPrim

 709 |                    "DocumentTimelineOptions.getoriginTime"

 710 |                    prim__originTime

 711 |                    prim__setOriginTime

 712 |                    0

 713 |                    (v :> DocumentTimelineOptions)

 717 | namespace EffectTiming

 719 |   export

 720 |   new' :

 721 |        (delay : Optional Double)

 722 |     -> (endDelay : Optional Double)

 723 |     -> (fill : Optional FillMode)

 724 |     -> (iterationStart : Optional Double)

 725 |     -> (iterations : Optional Double)

 726 |     -> (duration : Optional (HSum [Double, String]))

 727 |     -> (direction : Optional PlaybackDirection)

 728 |     -> (easing : Optional String)

 729 |     -> JSIO EffectTiming

 730 |   new' a b c d e f g h = primJS $

 731 |     EffectTiming.prim__new

 732 |       (toFFI a)

 733 |       (toFFI b)

 734 |       (toFFI c)

 735 |       (toFFI d)

 736 |       (toFFI e)

 737 |       (toFFI f)

 738 |       (toFFI g)

 739 |       (toFFI h)

 741 |   export

 742 |   new : JSIO EffectTiming

 743 |   new = primJS $

 744 |     EffectTiming.prim__new undef undef undef undef undef undef undef undef

 747 |   export

 748 |   delay :

 749 |        {auto 0 _ : JSType t}

 750 |     -> {auto 0 _ : Elem EffectTiming (Types t)}

 751 |     -> t

 752 |     -> Attribute True Optional Double

 753 |   delay v = fromUndefOrPrim

 754 |               "EffectTiming.getdelay"

 755 |               prim__delay

 756 |               prim__setDelay

 757 |               0

 758 |               (v :> EffectTiming)

 761 |   export

 762 |   direction :

 763 |        {auto 0 _ : JSType t}

 764 |     -> {auto 0 _ : Elem EffectTiming (Types t)}

 765 |     -> t

 766 |     -> Attribute False Optional PlaybackDirection

 767 |   direction v = fromUndefOrPrimNoDefault

 768 |                   "EffectTiming.getdirection"

 769 |                   prim__direction

 770 |                   prim__setDirection

 771 |                   (v :> EffectTiming)

 774 |   export

 775 |   duration :

 776 |        {auto 0 _ : JSType t}

 777 |     -> {auto 0 _ : Elem EffectTiming (Types t)}

 778 |     -> t

 779 |     -> Attribute False Optional (HSum [Double, String])

 780 |   duration v = fromUndefOrPrimNoDefault

 781 |                  "EffectTiming.getduration"

 782 |                  prim__duration

 783 |                  prim__setDuration

 784 |                  (v :> EffectTiming)

 787 |   export

 788 |   easing :

 789 |        {auto 0 _ : JSType t}

 790 |     -> {auto 0 _ : Elem EffectTiming (Types t)}

 791 |     -> t

 792 |     -> Attribute True Optional String

 793 |   easing v = fromUndefOrPrim

 794 |                "EffectTiming.geteasing"

 795 |                prim__easing

 796 |                prim__setEasing

 797 |                "linear"

 798 |                (v :> EffectTiming)

 801 |   export

 802 |   endDelay :

 803 |        {auto 0 _ : JSType t}

 804 |     -> {auto 0 _ : Elem EffectTiming (Types t)}

 805 |     -> t

 806 |     -> Attribute True Optional Double

 807 |   endDelay v = fromUndefOrPrim

 808 |                  "EffectTiming.getendDelay"

 809 |                  prim__endDelay

 810 |                  prim__setEndDelay

 811 |                  0

 812 |                  (v :> EffectTiming)

 815 |   export

 816 |   fill :

 817 |        {auto 0 _ : JSType t}

 818 |     -> {auto 0 _ : Elem EffectTiming (Types t)}

 819 |     -> t

 820 |     -> Attribute False Optional FillMode

 821 |   fill v = fromUndefOrPrimNoDefault

 822 |              "EffectTiming.getfill"

 823 |              prim__fill

 824 |              prim__setFill

 825 |              (v :> EffectTiming)

 828 |   export

 829 |   iterationStart :

 830 |        {auto 0 _ : JSType t}

 831 |     -> {auto 0 _ : Elem EffectTiming (Types t)}

 832 |     -> t

 833 |     -> Attribute True Optional Double

 834 |   iterationStart v = fromUndefOrPrim

 835 |                        "EffectTiming.getiterationStart"

 836 |                        prim__iterationStart

 837 |                        prim__setIterationStart

 838 |                        0.0

 839 |                        (v :> EffectTiming)

 842 |   export

 843 |   iterations :

 844 |        {auto 0 _ : JSType t}

 845 |     -> {auto 0 _ : Elem EffectTiming (Types t)}

 846 |     -> t

 847 |     -> Attribute True Optional Double

 848 |   iterations v = fromUndefOrPrim

 849 |                    "EffectTiming.getiterations"

 850 |                    prim__iterations

 851 |                    prim__setIterations

 852 |                    1.0

 853 |                    (v :> EffectTiming)

 857 | namespace KeyframeAnimationOptions

 859 |   export

 860 |   new' : (id : Optional String) -> JSIO KeyframeAnimationOptions

 861 |   new' a = primJS $ KeyframeAnimationOptions.prim__new (toFFI a)

 863 |   export

 864 |   new : JSIO KeyframeAnimationOptions

 865 |   new = primJS $ KeyframeAnimationOptions.prim__new undef

 868 |   export

 869 |   id :

 870 |        {auto 0 _ : JSType t}

 871 |     -> {auto 0 _ : Elem KeyframeAnimationOptions (Types t)}

 872 |     -> t

 873 |     -> Attribute True Optional String

 874 |   id v = fromUndefOrPrim

 875 |            "KeyframeAnimationOptions.getid"

 876 |            prim__id

 877 |            prim__setId

 878 |            ""

 879 |            (v :> KeyframeAnimationOptions)

 883 | namespace KeyframeEffectOptions

 885 |   export

 886 |   new' :

 887 |        (iterationComposite : Optional IterationCompositeOperation)

 888 |     -> (composite : Optional CompositeOperation)

 889 |     -> JSIO KeyframeEffectOptions

 890 |   new' a b = primJS $ KeyframeEffectOptions.prim__new (toFFI a) (toFFI b)

 892 |   export

 893 |   new : JSIO KeyframeEffectOptions

 894 |   new = primJS $ KeyframeEffectOptions.prim__new undef undef

 897 |   export

 898 |   composite :

 899 |        {auto 0 _ : JSType t}

 900 |     -> {auto 0 _ : Elem KeyframeEffectOptions (Types t)}

 901 |     -> t

 902 |     -> Attribute False Optional CompositeOperation

 903 |   composite v = fromUndefOrPrimNoDefault

 904 |                   "KeyframeEffectOptions.getcomposite"

 905 |                   prim__composite

 906 |                   prim__setComposite

 907 |                   (v :> KeyframeEffectOptions)

 910 |   export

 911 |   iterationComposite :

 912 |        {auto 0 _ : JSType t}

 913 |     -> {auto 0 _ : Elem KeyframeEffectOptions (Types t)}

 914 |     -> t

 915 |     -> Attribute False Optional IterationCompositeOperation

 916 |   iterationComposite v = fromUndefOrPrimNoDefault

 917 |                            "KeyframeEffectOptions.getiterationComposite"

 918 |                            prim__iterationComposite

 919 |                            prim__setIterationComposite

 920 |                            (v :> KeyframeEffectOptions)

 924 | namespace OptionalEffectTiming

 926 |   export

 927 |   new' :

 928 |        (delay : Optional Double)

 929 |     -> (endDelay : Optional Double)

 930 |     -> (fill : Optional FillMode)

 931 |     -> (iterationStart : Optional Double)

 932 |     -> (iterations : Optional Double)

 933 |     -> (duration : Optional (HSum [Double, String]))

 934 |     -> (direction : Optional PlaybackDirection)

 935 |     -> (easing : Optional String)

 936 |     -> JSIO OptionalEffectTiming

 937 |   new' a b c d e f g h = primJS $

 938 |     OptionalEffectTiming.prim__new

 939 |       (toFFI a)

 940 |       (toFFI b)

 941 |       (toFFI c)

 942 |       (toFFI d)

 943 |       (toFFI e)

 944 |       (toFFI f)

 945 |       (toFFI g)

 946 |       (toFFI h)

 948 |   export

 949 |   new : JSIO OptionalEffectTiming

 950 |   new = primJS $

 951 |     OptionalEffectTiming.prim__new

 952 |       undef

 953 |       undef

 954 |       undef

 955 |       undef

 956 |       undef

 957 |       undef

 958 |       undef

 959 |       undef

 962 |   export

 963 |   delay :

 964 |        {auto 0 _ : JSType t}

 965 |     -> {auto 0 _ : Elem OptionalEffectTiming (Types t)}

 966 |     -> t

 967 |     -> Attribute False Optional Double

 968 |   delay v = fromUndefOrPrimNoDefault

 969 |               "OptionalEffectTiming.getdelay"

 970 |               prim__delay

 971 |               prim__setDelay

 972 |               (v :> OptionalEffectTiming)

 975 |   export

 976 |   direction :

 977 |        {auto 0 _ : JSType t}

 978 |     -> {auto 0 _ : Elem OptionalEffectTiming (Types t)}

 979 |     -> t

 980 |     -> Attribute False Optional PlaybackDirection

 981 |   direction v = fromUndefOrPrimNoDefault

 982 |                   "OptionalEffectTiming.getdirection"

 983 |                   prim__direction

 984 |                   prim__setDirection

 985 |                   (v :> OptionalEffectTiming)

 988 |   export

 989 |   duration :

 990 |        {auto 0 _ : JSType t}

 991 |     -> {auto 0 _ : Elem OptionalEffectTiming (Types t)}

 992 |     -> t

 993 |     -> Attribute False Optional (HSum [Double, String])

 994 |   duration v = fromUndefOrPrimNoDefault

 995 |                  "OptionalEffectTiming.getduration"

 996 |                  prim__duration

 997 |                  prim__setDuration

 998 |                  (v :> OptionalEffectTiming)

1001 |   export

1002 |   easing :

1003 |        {auto 0 _ : JSType t}

1004 |     -> {auto 0 _ : Elem OptionalEffectTiming (Types t)}

1005 |     -> t

1006 |     -> Attribute False Optional String

1007 |   easing v = fromUndefOrPrimNoDefault

1008 |                "OptionalEffectTiming.geteasing"

1009 |                prim__easing

1010 |                prim__setEasing

1011 |                (v :> OptionalEffectTiming)

1014 |   export

1015 |   endDelay :

1016 |        {auto 0 _ : JSType t}

1017 |     -> {auto 0 _ : Elem OptionalEffectTiming (Types t)}

1018 |     -> t

1019 |     -> Attribute False Optional Double

1020 |   endDelay v = fromUndefOrPrimNoDefault

1021 |                  "OptionalEffectTiming.getendDelay"

1022 |                  prim__endDelay

1023 |                  prim__setEndDelay

1024 |                  (v :> OptionalEffectTiming)

1027 |   export

1028 |   fill :

1029 |        {auto 0 _ : JSType t}

1030 |     -> {auto 0 _ : Elem OptionalEffectTiming (Types t)}

1031 |     -> t

1032 |     -> Attribute False Optional FillMode

1033 |   fill v = fromUndefOrPrimNoDefault

1034 |              "OptionalEffectTiming.getfill"

1035 |              prim__fill

1036 |              prim__setFill

1037 |              (v :> OptionalEffectTiming)

1040 |   export

1041 |   iterationStart :

1042 |        {auto 0 _ : JSType t}

1043 |     -> {auto 0 _ : Elem OptionalEffectTiming (Types t)}

1044 |     -> t

1045 |     -> Attribute False Optional Double

1046 |   iterationStart v = fromUndefOrPrimNoDefault

1047 |                        "OptionalEffectTiming.getiterationStart"

1048 |                        prim__iterationStart

1049 |                        prim__setIterationStart

1050 |                        (v :> OptionalEffectTiming)

1053 |   export

1054 |   iterations :

1055 |        {auto 0 _ : JSType t}

1056 |     -> {auto 0 _ : Elem OptionalEffectTiming (Types t)}

1057 |     -> t

1058 |     -> Attribute False Optional Double

1059 |   iterations v = fromUndefOrPrimNoDefault

1060 |                    "OptionalEffectTiming.getiterations"

1061 |                    prim__iterations

1062 |                    prim__setIterations

1063 |                    (v :> OptionalEffectTiming)