0 | module Web.Raw.Streams

   2 | import JS

   3 | import Web.Internal.StreamsPrim

   4 | import Web.Internal.Types

   6 | %default total

  13 | namespace ByteLengthQueuingStrategy

  15 |   export

  16 |   new :

  17 |        {auto 0 _ : JSType t1}

  18 |     -> {auto 0 _ : Elem QueuingStrategyInit (Types t1)}

  19 |     -> (init : t1)

  20 |     -> JSIO ByteLengthQueuingStrategy

  21 |   new a = primJS $ ByteLengthQueuingStrategy.prim__new (up a)

  24 |   export

  25 |   highWaterMark : (obj : ByteLengthQueuingStrategy) -> JSIO Double

  26 |   highWaterMark a = primJS $ ByteLengthQueuingStrategy.prim__highWaterMark a

  29 |   export

  30 |   size : (obj : ByteLengthQueuingStrategy) -> JSIO Function

  31 |   size a = primJS $ ByteLengthQueuingStrategy.prim__size a

  35 | namespace CountQueuingStrategy

  37 |   export

  38 |   new :

  39 |        {auto 0 _ : JSType t1}

  40 |     -> {auto 0 _ : Elem QueuingStrategyInit (Types t1)}

  41 |     -> (init : t1)

  42 |     -> JSIO CountQueuingStrategy

  43 |   new a = primJS $ CountQueuingStrategy.prim__new (up a)

  46 |   export

  47 |   highWaterMark : (obj : CountQueuingStrategy) -> JSIO Double

  48 |   highWaterMark a = primJS $ CountQueuingStrategy.prim__highWaterMark a

  51 |   export

  52 |   size : (obj : CountQueuingStrategy) -> JSIO Function

  53 |   size a = primJS $ CountQueuingStrategy.prim__size a

  57 | namespace ReadableByteStreamController

  59 |   export

  60 |   byobRequest :

  61 |        (obj : ReadableByteStreamController)

  62 |     -> JSIO (Maybe ReadableStreamBYOBRequest)

  63 |   byobRequest a = tryJS "ReadableByteStreamController.byobRequest" $

  64 |     ReadableByteStreamController.prim__byobRequest a

  67 |   export

  68 |   desiredSize : (obj : ReadableByteStreamController) -> JSIO (Maybe Double)

  69 |   desiredSize a = tryJS "ReadableByteStreamController.desiredSize" $

  70 |     ReadableByteStreamController.prim__desiredSize a

  73 |   export

  74 |   close : (obj : ReadableByteStreamController) -> JSIO ()

  75 |   close a = primJS $ ReadableByteStreamController.prim__close a

  78 |   export

  79 |   enqueue :

  80 |        (obj : ReadableByteStreamController)

  81 |     -> (chunk : HSum

  82 |                   [ Int8Array

  83 |                   , Int16Array

  84 |                   , Int32Array

  85 |                   , UInt8Array

  86 |                   , UInt8Array

  87 |                   , UInt8Array

  88 |                   , UInt8ClampedArray

  89 |                   , Float32Array

  90 |                   , Float64Array

  91 |                   , DataView

  92 |                   ])

  93 |     -> JSIO ()

  94 |   enqueue a b = primJS $ ReadableByteStreamController.prim__enqueue a (toFFI b)

  97 |   export

  98 |   error' : (obj : ReadableByteStreamController) -> (e : Optional Any) -> JSIO ()

  99 |   error' a b = primJS $ ReadableByteStreamController.prim__error a (toFFI b)

 101 |   export

 102 |   error : (obj : ReadableByteStreamController) -> JSIO ()

 103 |   error a = primJS $ ReadableByteStreamController.prim__error a undef

 107 | namespace ReadableStream

 109 |   export

 110 |   new' :

 111 |        {auto 0 _ : JSType t1}

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

 113 |     -> {auto 0 _ : Elem Object (Types t1)}

 114 |     -> {auto 0 _ : Elem QueuingStrategy (Types t2)}

 115 |     -> (underlyingSource : Optional t1)

 116 |     -> (strategy : Optional t2)

 117 |     -> JSIO ReadableStream

 118 |   new' a b = primJS $ ReadableStream.prim__new (optUp a) (optUp b)

 120 |   export

 121 |   new : JSIO ReadableStream

 122 |   new = primJS $ ReadableStream.prim__new undef undef

 125 |   export

 126 |   locked : (obj : ReadableStream) -> JSIO Bool

 127 |   locked a = tryJS "ReadableStream.locked" $ ReadableStream.prim__locked a

 130 |   export

 131 |   cancel' :

 132 |        (obj : ReadableStream)

 133 |     -> (reason : Optional Any)

 134 |     -> JSIO (Promise Undefined)

 135 |   cancel' a b = primJS $ ReadableStream.prim__cancel a (toFFI b)

 137 |   export

 138 |   cancel : (obj : ReadableStream) -> JSIO (Promise Undefined)

 139 |   cancel a = primJS $ ReadableStream.prim__cancel a undef

 142 |   export

 143 |   getReader' :

 144 |        {auto 0 _ : JSType t2}

 145 |     -> {auto 0 _ : Elem ReadableStreamGetReaderOptions (Types t2)}

 146 |     -> (obj : ReadableStream)

 147 |     -> (options : Optional t2)

 148 |     -> JSIO (HSum [ReadableStreamDefaultReader, ReadableStreamBYOBReader])

 149 |   getReader' a b = tryJS "ReadableStream.getReader'" $

 150 |     ReadableStream.prim__getReader a (optUp b)

 152 |   export

 153 |   getReader :

 154 |        (obj : ReadableStream)

 155 |     -> JSIO (HSum [ReadableStreamDefaultReader, ReadableStreamBYOBReader])

 156 |   getReader a = tryJS "ReadableStream.getReader" $

 157 |     ReadableStream.prim__getReader a undef

 160 |   export

 161 |   pipeThrough' :

 162 |        {auto 0 _ : JSType t2}

 163 |     -> {auto 0 _ : JSType t3}

 164 |     -> {auto 0 _ : Elem ReadableWritablePair (Types t2)}

 165 |     -> {auto 0 _ : Elem StreamPipeOptions (Types t3)}

 166 |     -> (obj : ReadableStream)

 167 |     -> (transform : t2)

 168 |     -> (options : Optional t3)

 169 |     -> JSIO ReadableStream

 170 |   pipeThrough' a b c = primJS $

 171 |     ReadableStream.prim__pipeThrough a (up b) (optUp c)

 173 |   export

 174 |   pipeThrough :

 175 |        {auto 0 _ : JSType t2}

 176 |     -> {auto 0 _ : Elem ReadableWritablePair (Types t2)}

 177 |     -> (obj : ReadableStream)

 178 |     -> (transform : t2)

 179 |     -> JSIO ReadableStream

 180 |   pipeThrough a b = primJS $ ReadableStream.prim__pipeThrough a (up b) undef

 183 |   export

 184 |   pipeTo' :

 185 |        {auto 0 _ : JSType t3}

 186 |     -> {auto 0 _ : Elem StreamPipeOptions (Types t3)}

 187 |     -> (obj : ReadableStream)

 188 |     -> (destination : WritableStream)

 189 |     -> (options : Optional t3)

 190 |     -> JSIO (Promise Undefined)

 191 |   pipeTo' a b c = primJS $ ReadableStream.prim__pipeTo a b (optUp c)

 193 |   export

 194 |   pipeTo :

 195 |        (obj : ReadableStream)

 196 |     -> (destination : WritableStream)

 197 |     -> JSIO (Promise Undefined)

 198 |   pipeTo a b = primJS $ ReadableStream.prim__pipeTo a b undef

 201 |   export

 202 |   tee : (obj : ReadableStream) -> JSIO (Array ReadableStream)

 203 |   tee a = primJS $ ReadableStream.prim__tee a

 207 | namespace ReadableStreamBYOBReader

 209 |   export

 210 |   new : (stream : ReadableStream) -> JSIO ReadableStreamBYOBReader

 211 |   new a = primJS $ ReadableStreamBYOBReader.prim__new a

 214 |   export

 215 |   read :

 216 |        (obj : ReadableStreamBYOBReader)

 217 |     -> (view : HSum

 218 |                  [ Int8Array

 219 |                  , Int16Array

 220 |                  , Int32Array

 221 |                  , UInt8Array

 222 |                  , UInt8Array

 223 |                  , UInt8Array

 224 |                  , UInt8ClampedArray

 225 |                  , Float32Array

 226 |                  , Float64Array

 227 |                  , DataView

 228 |                  ])

 229 |     -> JSIO (Promise ReadableStreamBYOBReadResult)

 230 |   read a b = primJS $ ReadableStreamBYOBReader.prim__read a (toFFI b)

 233 |   export

 234 |   releaseLock : (obj : ReadableStreamBYOBReader) -> JSIO ()

 235 |   releaseLock a = primJS $ ReadableStreamBYOBReader.prim__releaseLock a

 239 | namespace ReadableStreamBYOBRequest

 241 |   export

 242 |   view :

 243 |        (obj : ReadableStreamBYOBRequest)

 244 |     -> JSIO

 245 |          (Maybe

 246 |             (Union10

 247 |                Int8Array

 248 |                Int16Array

 249 |                Int32Array

 250 |                UInt8Array

 251 |                UInt8Array

 252 |                UInt8Array

 253 |                UInt8ClampedArray

 254 |                Float32Array

 255 |                Float64Array

 256 |                DataView))

 257 |   view a = tryJS "ReadableStreamBYOBRequest.view" $

 258 |     ReadableStreamBYOBRequest.prim__view a

 261 |   export

 262 |   respond :

 263 |        (obj : ReadableStreamBYOBRequest)

 264 |     -> (bytesWritten : JSBits64)

 265 |     -> JSIO ()

 266 |   respond a b = primJS $ ReadableStreamBYOBRequest.prim__respond a b

 269 |   export

 270 |   respondWithNewView :

 271 |        (obj : ReadableStreamBYOBRequest)

 272 |     -> (view : HSum

 273 |                  [ Int8Array

 274 |                  , Int16Array

 275 |                  , Int32Array

 276 |                  , UInt8Array

 277 |                  , UInt8Array

 278 |                  , UInt8Array

 279 |                  , UInt8ClampedArray

 280 |                  , Float32Array

 281 |                  , Float64Array

 282 |                  , DataView

 283 |                  ])

 284 |     -> JSIO ()

 285 |   respondWithNewView a b = primJS $

 286 |     ReadableStreamBYOBRequest.prim__respondWithNewView a (toFFI b)

 290 | namespace ReadableStreamDefaultController

 292 |   export

 293 |   desiredSize : (obj : ReadableStreamDefaultController) -> JSIO (Maybe Double)

 294 |   desiredSize a = tryJS "ReadableStreamDefaultController.desiredSize" $

 295 |     ReadableStreamDefaultController.prim__desiredSize a

 298 |   export

 299 |   close : (obj : ReadableStreamDefaultController) -> JSIO ()

 300 |   close a = primJS $ ReadableStreamDefaultController.prim__close a

 303 |   export

 304 |   enqueue' :

 305 |        (obj : ReadableStreamDefaultController)

 306 |     -> (chunk : Optional Any)

 307 |     -> JSIO ()

 308 |   enqueue' a b = primJS $

 309 |     ReadableStreamDefaultController.prim__enqueue a (toFFI b)

 311 |   export

 312 |   enqueue : (obj : ReadableStreamDefaultController) -> JSIO ()

 313 |   enqueue a = primJS $ ReadableStreamDefaultController.prim__enqueue a undef

 316 |   export

 317 |   error' :

 318 |        (obj : ReadableStreamDefaultController)

 319 |     -> (e : Optional Any)

 320 |     -> JSIO ()

 321 |   error' a b = primJS $ ReadableStreamDefaultController.prim__error a (toFFI b)

 323 |   export

 324 |   error : (obj : ReadableStreamDefaultController) -> JSIO ()

 325 |   error a = primJS $ ReadableStreamDefaultController.prim__error a undef

 329 | namespace ReadableStreamDefaultReader

 331 |   export

 332 |   new : (stream : ReadableStream) -> JSIO ReadableStreamDefaultReader

 333 |   new a = primJS $ ReadableStreamDefaultReader.prim__new a

 336 |   export

 337 |   read :

 338 |        (obj : ReadableStreamDefaultReader)

 339 |     -> JSIO (Promise ReadableStreamDefaultReadResult)

 340 |   read a = primJS $ ReadableStreamDefaultReader.prim__read a

 343 |   export

 344 |   releaseLock : (obj : ReadableStreamDefaultReader) -> JSIO ()

 345 |   releaseLock a = primJS $ ReadableStreamDefaultReader.prim__releaseLock a

 349 | namespace TransformStream

 351 |   export

 352 |   new' :

 353 |        {auto 0 _ : JSType t1}

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

 355 |     -> {auto 0 _ : JSType t3}

 356 |     -> {auto 0 _ : Elem Object (Types t1)}

 357 |     -> {auto 0 _ : Elem QueuingStrategy (Types t2)}

 358 |     -> {auto 0 _ : Elem QueuingStrategy (Types t3)}

 359 |     -> (transformer : Optional t1)

 360 |     -> (writableStrategy : Optional t2)

 361 |     -> (readableStrategy : Optional t3)

 362 |     -> JSIO TransformStream

 363 |   new' a b c = primJS $ TransformStream.prim__new (optUp a) (optUp b) (optUp c)

 365 |   export

 366 |   new : JSIO TransformStream

 367 |   new = primJS $ TransformStream.prim__new undef undef undef

 370 |   export

 371 |   readable : (obj : TransformStream) -> JSIO ReadableStream

 372 |   readable a = primJS $ TransformStream.prim__readable a

 375 |   export

 376 |   writable : (obj : TransformStream) -> JSIO WritableStream

 377 |   writable a = primJS $ TransformStream.prim__writable a

 381 | namespace TransformStreamDefaultController

 383 |   export

 384 |   desiredSize : (obj : TransformStreamDefaultController) -> JSIO (Maybe Double)

 385 |   desiredSize a = tryJS "TransformStreamDefaultController.desiredSize" $

 386 |     TransformStreamDefaultController.prim__desiredSize a

 389 |   export

 390 |   enqueue' :

 391 |        (obj : TransformStreamDefaultController)

 392 |     -> (chunk : Optional Any)

 393 |     -> JSIO ()

 394 |   enqueue' a b = primJS $

 395 |     TransformStreamDefaultController.prim__enqueue a (toFFI b)

 397 |   export

 398 |   enqueue : (obj : TransformStreamDefaultController) -> JSIO ()

 399 |   enqueue a = primJS $ TransformStreamDefaultController.prim__enqueue a undef

 402 |   export

 403 |   error' :

 404 |        (obj : TransformStreamDefaultController)

 405 |     -> (reason : Optional Any)

 406 |     -> JSIO ()

 407 |   error' a b = primJS $ TransformStreamDefaultController.prim__error a (toFFI b)

 409 |   export

 410 |   error : (obj : TransformStreamDefaultController) -> JSIO ()

 411 |   error a = primJS $ TransformStreamDefaultController.prim__error a undef

 414 |   export

 415 |   terminate : (obj : TransformStreamDefaultController) -> JSIO ()

 416 |   terminate a = primJS $ TransformStreamDefaultController.prim__terminate a

 420 | namespace WritableStream

 422 |   export

 423 |   new' :

 424 |        {auto 0 _ : JSType t1}

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

 426 |     -> {auto 0 _ : Elem Object (Types t1)}

 427 |     -> {auto 0 _ : Elem QueuingStrategy (Types t2)}

 428 |     -> (underlyingSink : Optional t1)

 429 |     -> (strategy : Optional t2)

 430 |     -> JSIO WritableStream

 431 |   new' a b = primJS $ WritableStream.prim__new (optUp a) (optUp b)

 433 |   export

 434 |   new : JSIO WritableStream

 435 |   new = primJS $ WritableStream.prim__new undef undef

 438 |   export

 439 |   locked : (obj : WritableStream) -> JSIO Bool

 440 |   locked a = tryJS "WritableStream.locked" $ WritableStream.prim__locked a

 443 |   export

 444 |   abort' :

 445 |        (obj : WritableStream)

 446 |     -> (reason : Optional Any)

 447 |     -> JSIO (Promise Undefined)

 448 |   abort' a b = primJS $ WritableStream.prim__abort a (toFFI b)

 450 |   export

 451 |   abort : (obj : WritableStream) -> JSIO (Promise Undefined)

 452 |   abort a = primJS $ WritableStream.prim__abort a undef

 455 |   export

 456 |   close : (obj : WritableStream) -> JSIO (Promise Undefined)

 457 |   close a = primJS $ WritableStream.prim__close a

 460 |   export

 461 |   getWriter : (obj : WritableStream) -> JSIO WritableStreamDefaultWriter

 462 |   getWriter a = primJS $ WritableStream.prim__getWriter a

 466 | namespace WritableStreamDefaultController

 468 |   export

 469 |   error' :

 470 |        (obj : WritableStreamDefaultController)

 471 |     -> (e : Optional Any)

 472 |     -> JSIO ()

 473 |   error' a b = primJS $ WritableStreamDefaultController.prim__error a (toFFI b)

 475 |   export

 476 |   error : (obj : WritableStreamDefaultController) -> JSIO ()

 477 |   error a = primJS $ WritableStreamDefaultController.prim__error a undef

 481 | namespace WritableStreamDefaultWriter

 483 |   export

 484 |   new : (stream : WritableStream) -> JSIO WritableStreamDefaultWriter

 485 |   new a = primJS $ WritableStreamDefaultWriter.prim__new a

 488 |   export

 489 |   closed : (obj : WritableStreamDefaultWriter) -> JSIO (Promise Undefined)

 490 |   closed a = primJS $ WritableStreamDefaultWriter.prim__closed a

 493 |   export

 494 |   desiredSize : (obj : WritableStreamDefaultWriter) -> JSIO (Maybe Double)

 495 |   desiredSize a = tryJS "WritableStreamDefaultWriter.desiredSize" $

 496 |     WritableStreamDefaultWriter.prim__desiredSize a

 499 |   export

 500 |   ready : (obj : WritableStreamDefaultWriter) -> JSIO (Promise Undefined)

 501 |   ready a = primJS $ WritableStreamDefaultWriter.prim__ready a

 504 |   export

 505 |   abort' :

 506 |        (obj : WritableStreamDefaultWriter)

 507 |     -> (reason : Optional Any)

 508 |     -> JSIO (Promise Undefined)

 509 |   abort' a b = primJS $ WritableStreamDefaultWriter.prim__abort a (toFFI b)

 511 |   export

 512 |   abort : (obj : WritableStreamDefaultWriter) -> JSIO (Promise Undefined)

 513 |   abort a = primJS $ WritableStreamDefaultWriter.prim__abort a undef

 516 |   export

 517 |   close : (obj : WritableStreamDefaultWriter) -> JSIO (Promise Undefined)

 518 |   close a = primJS $ WritableStreamDefaultWriter.prim__close a

 521 |   export

 522 |   releaseLock : (obj : WritableStreamDefaultWriter) -> JSIO ()

 523 |   releaseLock a = primJS $ WritableStreamDefaultWriter.prim__releaseLock a

 526 |   export

 527 |   write' :

 528 |        (obj : WritableStreamDefaultWriter)

 529 |     -> (chunk : Optional Any)

 530 |     -> JSIO (Promise Undefined)

 531 |   write' a b = primJS $ WritableStreamDefaultWriter.prim__write a (toFFI b)

 533 |   export

 534 |   write : (obj : WritableStreamDefaultWriter) -> JSIO (Promise Undefined)

 535 |   write a = primJS $ WritableStreamDefaultWriter.prim__write a undef

 544 | namespace GenericTransformStream

 546 |   export

 547 |   readable :

 548 |        {auto 0 _ : JSType t1}

 549 |     -> {auto 0 _ : Elem GenericTransformStream (Types t1)}

 550 |     -> (obj : t1)

 551 |     -> JSIO ReadableStream

 552 |   readable a = primJS $ GenericTransformStream.prim__readable (up a)

 555 |   export

 556 |   writable :

 557 |        {auto 0 _ : JSType t1}

 558 |     -> {auto 0 _ : Elem GenericTransformStream (Types t1)}

 559 |     -> (obj : t1)

 560 |     -> JSIO WritableStream

 561 |   writable a = primJS $ GenericTransformStream.prim__writable (up a)

 565 | namespace ReadableStreamGenericReader

 567 |   export

 568 |   closed :

 569 |        {auto 0 _ : JSType t1}

 570 |     -> {auto 0 _ : Elem ReadableStreamGenericReader (Types t1)}

 571 |     -> (obj : t1)

 572 |     -> JSIO (Promise Undefined)

 573 |   closed a = primJS $ ReadableStreamGenericReader.prim__closed (up a)

 576 |   export

 577 |   cancel' :

 578 |        {auto 0 _ : JSType t1}

 579 |     -> {auto 0 _ : Elem ReadableStreamGenericReader (Types t1)}

 580 |     -> (obj : t1)

 581 |     -> (reason : Optional Any)

 582 |     -> JSIO (Promise Undefined)

 583 |   cancel' a b = primJS $

 584 |     ReadableStreamGenericReader.prim__cancel (up a) (toFFI b)

 586 |   export

 587 |   cancel :

 588 |        {auto 0 _ : JSType t1}

 589 |     -> {auto 0 _ : Elem ReadableStreamGenericReader (Types t1)}

 590 |     -> (obj : t1)

 591 |     -> JSIO (Promise Undefined)

 592 |   cancel a = primJS $ ReadableStreamGenericReader.prim__cancel (up a) undef

 601 | namespace QueuingStrategy

 603 |   export

 604 |   new' :

 605 |        (highWaterMark : Optional Double)

 606 |     -> (size : Optional QueuingStrategySize)

 607 |     -> JSIO QueuingStrategy

 608 |   new' a b = primJS $ QueuingStrategy.prim__new (toFFI a) (toFFI b)

 610 |   export

 611 |   new : JSIO QueuingStrategy

 612 |   new = primJS $ QueuingStrategy.prim__new undef undef

 615 |   export

 616 |   highWaterMark :

 617 |        {auto 0 _ : JSType t}

 618 |     -> {auto 0 _ : Elem QueuingStrategy (Types t)}

 619 |     -> t

 620 |     -> Attribute False Optional Double

 621 |   highWaterMark v = fromUndefOrPrimNoDefault

 622 |                       "QueuingStrategy.gethighWaterMark"

 623 |                       prim__highWaterMark

 624 |                       prim__setHighWaterMark

 625 |                       (v :> QueuingStrategy)

 628 |   export

 629 |   size :

 630 |        {auto 0 _ : JSType t}

 631 |     -> {auto 0 _ : Elem QueuingStrategy (Types t)}

 632 |     -> t

 633 |     -> Attribute False Optional QueuingStrategySize

 634 |   size v = fromUndefOrPrimNoDefault

 635 |              "QueuingStrategy.getsize"

 636 |              prim__size

 637 |              prim__setSize

 638 |              (v :> QueuingStrategy)

 642 | namespace QueuingStrategyInit

 644 |   export

 645 |   new : (highWaterMark : Double) -> JSIO QueuingStrategyInit

 646 |   new a = primJS $ QueuingStrategyInit.prim__new a

 649 |   export

 650 |   highWaterMark :

 651 |        {auto 0 _ : JSType t}

 652 |     -> {auto 0 _ : Elem QueuingStrategyInit (Types t)}

 653 |     -> t

 654 |     -> Attribute True Prelude.id Double

 655 |   highWaterMark v = fromPrim

 656 |                       "QueuingStrategyInit.gethighWaterMark"

 657 |                       prim__highWaterMark

 658 |                       prim__setHighWaterMark

 659 |                       (v :> QueuingStrategyInit)

 663 | namespace ReadableStreamBYOBReadResult

 665 |   export

 666 |   new' :

 667 |        (value : Optional

 668 |                   (HSum

 669 |                      [ Int8Array

 670 |                      , Int16Array

 671 |                      , Int32Array

 672 |                      , UInt8Array

 673 |                      , UInt8Array

 674 |                      , UInt8Array

 675 |                      , UInt8ClampedArray

 676 |                      , Float32Array

 677 |                      , Float64Array

 678 |                      , DataView

 679 |                      ]))

 680 |     -> (done : Optional Bool)

 681 |     -> JSIO ReadableStreamBYOBReadResult

 682 |   new' a b = primJS $ ReadableStreamBYOBReadResult.prim__new (toFFI a) (toFFI b)

 684 |   export

 685 |   new : JSIO ReadableStreamBYOBReadResult

 686 |   new = primJS $ ReadableStreamBYOBReadResult.prim__new undef undef

 689 |   export

 690 |   done :

 691 |        {auto 0 _ : JSType t}

 692 |     -> {auto 0 _ : Elem ReadableStreamBYOBReadResult (Types t)}

 693 |     -> t

 694 |     -> Attribute False Optional Bool

 695 |   done v = fromUndefOrPrimNoDefault

 696 |              "ReadableStreamBYOBReadResult.getdone"

 697 |              prim__done

 698 |              prim__setDone

 699 |              (v :> ReadableStreamBYOBReadResult)

 702 |   export

 703 |   value :

 704 |        {auto 0 _ : JSType t}

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

 706 |     -> t

 707 |     -> Attribute False Optional (Union10

 708 |                                    Int8Array

 709 |                                    Int16Array

 710 |                                    Int32Array

 711 |                                    UInt8Array

 712 |                                    UInt8Array

 713 |                                    UInt8Array

 714 |                                    UInt8ClampedArray

 715 |                                    Float32Array

 716 |                                    Float64Array

 717 |                                    DataView)

 718 |   value v = fromUndefOrPrimNoDefault

 719 |               "ReadableStreamBYOBReadResult.getvalue"

 720 |               prim__value

 721 |               prim__setValue

 722 |               (v :> ReadableStreamBYOBReadResult)

 726 | namespace ReadableStreamDefaultReadResult

 728 |   export

 729 |   new' :

 730 |        (value : Optional Any)

 731 |     -> (done : Optional Bool)

 732 |     -> JSIO ReadableStreamDefaultReadResult

 733 |   new' a b = primJS $

 734 |     ReadableStreamDefaultReadResult.prim__new (toFFI a) (toFFI b)

 736 |   export

 737 |   new : JSIO ReadableStreamDefaultReadResult

 738 |   new = primJS $ ReadableStreamDefaultReadResult.prim__new undef undef

 741 |   export

 742 |   done :

 743 |        {auto 0 _ : JSType t}

 744 |     -> {auto 0 _ : Elem ReadableStreamDefaultReadResult (Types t)}

 745 |     -> t

 746 |     -> Attribute False Optional Bool

 747 |   done v = fromUndefOrPrimNoDefault

 748 |              "ReadableStreamDefaultReadResult.getdone"

 749 |              prim__done

 750 |              prim__setDone

 751 |              (v :> ReadableStreamDefaultReadResult)

 754 |   export

 755 |   value :

 756 |        {auto 0 _ : JSType t}

 757 |     -> {auto 0 _ : Elem ReadableStreamDefaultReadResult (Types t)}

 758 |     -> t

 759 |     -> Attribute False Optional Any

 760 |   value v = fromUndefOrPrimNoDefault

 761 |               "ReadableStreamDefaultReadResult.getvalue"

 762 |               prim__value

 763 |               prim__setValue

 764 |               (v :> ReadableStreamDefaultReadResult)

 768 | namespace ReadableStreamGetReaderOptions

 770 |   export

 771 |   new' :

 772 |        (mode : Optional ReadableStreamReaderMode)

 773 |     -> JSIO ReadableStreamGetReaderOptions

 774 |   new' a = primJS $ ReadableStreamGetReaderOptions.prim__new (toFFI a)

 776 |   export

 777 |   new : JSIO ReadableStreamGetReaderOptions

 778 |   new = primJS $ ReadableStreamGetReaderOptions.prim__new undef

 781 |   export

 782 |   mode :

 783 |        {auto 0 _ : JSType t}

 784 |     -> {auto 0 _ : Elem ReadableStreamGetReaderOptions (Types t)}

 785 |     -> t

 786 |     -> Attribute False Optional ReadableStreamReaderMode

 787 |   mode v = fromUndefOrPrimNoDefault

 788 |              "ReadableStreamGetReaderOptions.getmode"

 789 |              prim__mode

 790 |              prim__setMode

 791 |              (v :> ReadableStreamGetReaderOptions)

 795 | namespace ReadableStreamIteratorOptions

 797 |   export

 798 |   new' : (preventCancel : Optional Bool) -> JSIO ReadableStreamIteratorOptions

 799 |   new' a = primJS $ ReadableStreamIteratorOptions.prim__new (toFFI a)

 801 |   export

 802 |   new : JSIO ReadableStreamIteratorOptions

 803 |   new = primJS $ ReadableStreamIteratorOptions.prim__new undef

 806 |   export

 807 |   preventCancel :

 808 |        {auto 0 _ : JSType t}

 809 |     -> {auto 0 _ : Elem ReadableStreamIteratorOptions (Types t)}

 810 |     -> t

 811 |     -> Attribute True Optional Bool

 812 |   preventCancel v = fromUndefOrPrim

 813 |                       "ReadableStreamIteratorOptions.getpreventCancel"

 814 |                       prim__preventCancel

 815 |                       prim__setPreventCancel

 816 |                       False

 817 |                       (v :> ReadableStreamIteratorOptions)

 821 | namespace ReadableWritablePair

 823 |   export

 824 |   new :

 825 |        (readable : ReadableStream)

 826 |     -> (writable : WritableStream)

 827 |     -> JSIO ReadableWritablePair

 828 |   new a b = primJS $ ReadableWritablePair.prim__new a b

 831 |   export

 832 |   readable :

 833 |        {auto 0 _ : JSType t}

 834 |     -> {auto 0 _ : Elem ReadableWritablePair (Types t)}

 835 |     -> t

 836 |     -> Attribute True Prelude.id ReadableStream

 837 |   readable v = fromPrim

 838 |                  "ReadableWritablePair.getreadable"

 839 |                  prim__readable

 840 |                  prim__setReadable

 841 |                  (v :> ReadableWritablePair)

 844 |   export

 845 |   writable :

 846 |        {auto 0 _ : JSType t}

 847 |     -> {auto 0 _ : Elem ReadableWritablePair (Types t)}

 848 |     -> t

 849 |     -> Attribute True Prelude.id WritableStream

 850 |   writable v = fromPrim

 851 |                  "ReadableWritablePair.getwritable"

 852 |                  prim__writable

 853 |                  prim__setWritable

 854 |                  (v :> ReadableWritablePair)

 858 | namespace StreamPipeOptions

 860 |   export

 861 |   new' :

 862 |        (preventClose : Optional Bool)

 863 |     -> (preventAbort : Optional Bool)

 864 |     -> (preventCancel : Optional Bool)

 865 |     -> (signal : Optional AbortSignal)

 866 |     -> JSIO StreamPipeOptions

 867 |   new' a b c d = primJS $

 868 |     StreamPipeOptions.prim__new (toFFI a) (toFFI b) (toFFI c) (toFFI d)

 870 |   export

 871 |   new : JSIO StreamPipeOptions

 872 |   new = primJS $ StreamPipeOptions.prim__new undef undef undef undef

 875 |   export

 876 |   preventAbort :

 877 |        {auto 0 _ : JSType t}

 878 |     -> {auto 0 _ : Elem StreamPipeOptions (Types t)}

 879 |     -> t

 880 |     -> Attribute True Optional Bool

 881 |   preventAbort v = fromUndefOrPrim

 882 |                      "StreamPipeOptions.getpreventAbort"

 883 |                      prim__preventAbort

 884 |                      prim__setPreventAbort

 885 |                      False

 886 |                      (v :> StreamPipeOptions)

 889 |   export

 890 |   preventCancel :

 891 |        {auto 0 _ : JSType t}

 892 |     -> {auto 0 _ : Elem StreamPipeOptions (Types t)}

 893 |     -> t

 894 |     -> Attribute True Optional Bool

 895 |   preventCancel v = fromUndefOrPrim

 896 |                       "StreamPipeOptions.getpreventCancel"

 897 |                       prim__preventCancel

 898 |                       prim__setPreventCancel

 899 |                       False

 900 |                       (v :> StreamPipeOptions)

 903 |   export

 904 |   preventClose :

 905 |        {auto 0 _ : JSType t}

 906 |     -> {auto 0 _ : Elem StreamPipeOptions (Types t)}

 907 |     -> t

 908 |     -> Attribute True Optional Bool

 909 |   preventClose v = fromUndefOrPrim

 910 |                      "StreamPipeOptions.getpreventClose"

 911 |                      prim__preventClose

 912 |                      prim__setPreventClose

 913 |                      False

 914 |                      (v :> StreamPipeOptions)

 917 |   export

 918 |   signal :

 919 |        {auto 0 _ : JSType t}

 920 |     -> {auto 0 _ : Elem StreamPipeOptions (Types t)}

 921 |     -> t

 922 |     -> Attribute False Optional AbortSignal

 923 |   signal v = fromUndefOrPrimNoDefault

 924 |                "StreamPipeOptions.getsignal"

 925 |                prim__signal

 926 |                prim__setSignal

 927 |                (v :> StreamPipeOptions)

 931 | namespace Transformer

 933 |   export

 934 |   new' :

 935 |        (start : Optional TransformerStartCallback)

 936 |     -> (transform : Optional TransformerTransformCallback)

 937 |     -> (flush : Optional TransformerFlushCallback)

 938 |     -> (readableType : Optional Any)

 939 |     -> (writableType : Optional Any)

 940 |     -> JSIO Transformer

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

 942 |     Transformer.prim__new (toFFI a) (toFFI b) (toFFI c) (toFFI d) (toFFI e)

 944 |   export

 945 |   new : JSIO Transformer

 946 |   new = primJS $ Transformer.prim__new undef undef undef undef undef

 949 |   export

 950 |   flush :

 951 |        {auto 0 _ : JSType t}

 952 |     -> {auto 0 _ : Elem Transformer (Types t)}

 953 |     -> t

 954 |     -> Attribute False Optional TransformerFlushCallback

 955 |   flush v = fromUndefOrPrimNoDefault

 956 |               "Transformer.getflush"

 957 |               prim__flush

 958 |               prim__setFlush

 959 |               (v :> Transformer)

 962 |   export

 963 |   readableType :

 964 |        {auto 0 _ : JSType t}

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

 966 |     -> t

 967 |     -> Attribute False Optional Any

 968 |   readableType v = fromUndefOrPrimNoDefault

 969 |                      "Transformer.getreadableType"

 970 |                      prim__readableType

 971 |                      prim__setReadableType

 972 |                      (v :> Transformer)

 975 |   export

 976 |   start :

 977 |        {auto 0 _ : JSType t}

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

 979 |     -> t

 980 |     -> Attribute False Optional TransformerStartCallback

 981 |   start v = fromUndefOrPrimNoDefault

 982 |               "Transformer.getstart"

 983 |               prim__start

 984 |               prim__setStart

 985 |               (v :> Transformer)

 988 |   export

 989 |   transform :

 990 |        {auto 0 _ : JSType t}

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

 992 |     -> t

 993 |     -> Attribute False Optional TransformerTransformCallback

 994 |   transform v = fromUndefOrPrimNoDefault

 995 |                   "Transformer.gettransform"

 996 |                   prim__transform

 997 |                   prim__setTransform

 998 |                   (v :> Transformer)

1001 |   export

1002 |   writableType :

1003 |        {auto 0 _ : JSType t}

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

1005 |     -> t

1006 |     -> Attribute False Optional Any

1007 |   writableType v = fromUndefOrPrimNoDefault

1008 |                      "Transformer.getwritableType"

1009 |                      prim__writableType

1010 |                      prim__setWritableType

1011 |                      (v :> Transformer)

1015 | namespace UnderlyingSink

1017 |   export

1018 |   new' :

1019 |        (start : Optional UnderlyingSinkStartCallback)

1020 |     -> (write : Optional UnderlyingSinkWriteCallback)

1021 |     -> (close : Optional UnderlyingSinkCloseCallback)

1022 |     -> (abort : Optional UnderlyingSinkAbortCallback)

1023 |     -> (type : Optional Any)

1024 |     -> JSIO UnderlyingSink

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

1026 |     UnderlyingSink.prim__new (toFFI a) (toFFI b) (toFFI c) (toFFI d) (toFFI e)

1028 |   export

1029 |   new : JSIO UnderlyingSink

1030 |   new = primJS $ UnderlyingSink.prim__new undef undef undef undef undef

1033 |   export

1034 |   abort :

1035 |        {auto 0 _ : JSType t}

1036 |     -> {auto 0 _ : Elem UnderlyingSink (Types t)}

1037 |     -> t

1038 |     -> Attribute False Optional UnderlyingSinkAbortCallback

1039 |   abort v = fromUndefOrPrimNoDefault

1040 |               "UnderlyingSink.getabort"

1041 |               prim__abort

1042 |               prim__setAbort

1043 |               (v :> UnderlyingSink)

1046 |   export

1047 |   close :

1048 |        {auto 0 _ : JSType t}

1049 |     -> {auto 0 _ : Elem UnderlyingSink (Types t)}

1050 |     -> t

1051 |     -> Attribute False Optional UnderlyingSinkCloseCallback

1052 |   close v = fromUndefOrPrimNoDefault

1053 |               "UnderlyingSink.getclose"

1054 |               prim__close

1055 |               prim__setClose

1056 |               (v :> UnderlyingSink)

1059 |   export

1060 |   start :

1061 |        {auto 0 _ : JSType t}

1062 |     -> {auto 0 _ : Elem UnderlyingSink (Types t)}

1063 |     -> t

1064 |     -> Attribute False Optional UnderlyingSinkStartCallback

1065 |   start v = fromUndefOrPrimNoDefault

1066 |               "UnderlyingSink.getstart"

1067 |               prim__start

1068 |               prim__setStart

1069 |               (v :> UnderlyingSink)

1072 |   export

1073 |   type :

1074 |        {auto 0 _ : JSType t}

1075 |     -> {auto 0 _ : Elem UnderlyingSink (Types t)}

1076 |     -> t

1077 |     -> Attribute False Optional Any

1078 |   type v = fromUndefOrPrimNoDefault

1079 |              "UnderlyingSink.gettype"

1080 |              prim__type

1081 |              prim__setType

1082 |              (v :> UnderlyingSink)

1085 |   export

1086 |   write :

1087 |        {auto 0 _ : JSType t}

1088 |     -> {auto 0 _ : Elem UnderlyingSink (Types t)}

1089 |     -> t

1090 |     -> Attribute False Optional UnderlyingSinkWriteCallback

1091 |   write v = fromUndefOrPrimNoDefault

1092 |               "UnderlyingSink.getwrite"

1093 |               prim__write

1094 |               prim__setWrite

1095 |               (v :> UnderlyingSink)

1099 | namespace UnderlyingSource

1101 |   export

1102 |   new' :

1103 |        (start : Optional UnderlyingSourceStartCallback)

1104 |     -> (pull : Optional UnderlyingSourcePullCallback)

1105 |     -> (cancel : Optional UnderlyingSourceCancelCallback)

1106 |     -> (type : Optional ReadableStreamType)

1107 |     -> (autoAllocateChunkSize : Optional JSBits64)

1108 |     -> JSIO UnderlyingSource

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

1110 |     UnderlyingSource.prim__new (toFFI a) (toFFI b) (toFFI c) (toFFI d) (toFFI e)

1112 |   export

1113 |   new : JSIO UnderlyingSource

1114 |   new = primJS $ UnderlyingSource.prim__new undef undef undef undef undef

1117 |   export

1118 |   autoAllocateChunkSize :

1119 |        {auto 0 _ : JSType t}

1120 |     -> {auto 0 _ : Elem UnderlyingSource (Types t)}

1121 |     -> t

1122 |     -> Attribute False Optional JSBits64

1123 |   autoAllocateChunkSize v = fromUndefOrPrimNoDefault

1124 |                               "UnderlyingSource.getautoAllocateChunkSize"

1125 |                               prim__autoAllocateChunkSize

1126 |                               prim__setAutoAllocateChunkSize

1127 |                               (v :> UnderlyingSource)

1130 |   export

1131 |   cancel :

1132 |        {auto 0 _ : JSType t}

1133 |     -> {auto 0 _ : Elem UnderlyingSource (Types t)}

1134 |     -> t

1135 |     -> Attribute False Optional UnderlyingSourceCancelCallback

1136 |   cancel v = fromUndefOrPrimNoDefault

1137 |                "UnderlyingSource.getcancel"

1138 |                prim__cancel

1139 |                prim__setCancel

1140 |                (v :> UnderlyingSource)

1143 |   export

1144 |   pull :

1145 |        {auto 0 _ : JSType t}

1146 |     -> {auto 0 _ : Elem UnderlyingSource (Types t)}

1147 |     -> t

1148 |     -> Attribute False Optional UnderlyingSourcePullCallback

1149 |   pull v = fromUndefOrPrimNoDefault

1150 |              "UnderlyingSource.getpull"

1151 |              prim__pull

1152 |              prim__setPull

1153 |              (v :> UnderlyingSource)

1156 |   export

1157 |   start :

1158 |        {auto 0 _ : JSType t}

1159 |     -> {auto 0 _ : Elem UnderlyingSource (Types t)}

1160 |     -> t

1161 |     -> Attribute False Optional UnderlyingSourceStartCallback

1162 |   start v = fromUndefOrPrimNoDefault

1163 |               "UnderlyingSource.getstart"

1164 |               prim__start

1165 |               prim__setStart

1166 |               (v :> UnderlyingSource)

1169 |   export

1170 |   type :

1171 |        {auto 0 _ : JSType t}

1172 |     -> {auto 0 _ : Elem UnderlyingSource (Types t)}

1173 |     -> t

1174 |     -> Attribute False Optional ReadableStreamType

1175 |   type v = fromUndefOrPrimNoDefault

1176 |              "UnderlyingSource.gettype"

1177 |              prim__type

1178 |              prim__setType

1179 |              (v :> UnderlyingSource)

1188 | namespace QueuingStrategySize

1190 |   export

1191 |   toQueuingStrategySize :

1192 |        (UndefOr AnyPtr -> IO Double)

1193 |     -> JSIO QueuingStrategySize

1194 |   toQueuingStrategySize cb = primJS $ prim__toQueuingStrategySize cb

1198 | namespace TransformerFlushCallback

1200 |   export

1201 |   toTransformerFlushCallback :

1202 |        (TransformStreamDefaultController -> IO (Promise Undefined))

1203 |     -> JSIO TransformerFlushCallback

1204 |   toTransformerFlushCallback cb = primJS $ prim__toTransformerFlushCallback cb

1208 | namespace TransformerStartCallback

1210 |   export

1211 |   toTransformerStartCallback :

1212 |        (TransformStreamDefaultController -> IO AnyPtr)

1213 |     -> JSIO TransformerStartCallback

1214 |   toTransformerStartCallback cb = primJS $ prim__toTransformerStartCallback cb

1218 | namespace TransformerTransformCallback

1220 |   export

1221 |   toTransformerTransformCallback :

1222 |        (AnyPtr -> TransformStreamDefaultController -> IO (Promise Undefined))

1223 |     -> JSIO TransformerTransformCallback

1224 |   toTransformerTransformCallback cb = primJS $ prim__toTransformerTransformCallback cb

1228 | namespace UnderlyingSinkAbortCallback

1230 |   export

1231 |   toUnderlyingSinkAbortCallback :

1232 |        (UndefOr AnyPtr -> IO (Promise Undefined))

1233 |     -> JSIO UnderlyingSinkAbortCallback

1234 |   toUnderlyingSinkAbortCallback cb = primJS $ prim__toUnderlyingSinkAbortCallback cb

1238 | namespace UnderlyingSinkCloseCallback

1240 |   export

1241 |   toUnderlyingSinkCloseCallback :

1242 |        (() -> IO (Promise Undefined))

1243 |     -> JSIO UnderlyingSinkCloseCallback

1244 |   toUnderlyingSinkCloseCallback cb = primJS $ prim__toUnderlyingSinkCloseCallback cb

1248 | namespace UnderlyingSinkStartCallback

1250 |   export

1251 |   toUnderlyingSinkStartCallback :

1252 |        (WritableStreamDefaultController -> IO AnyPtr)

1253 |     -> JSIO UnderlyingSinkStartCallback

1254 |   toUnderlyingSinkStartCallback cb = primJS $ prim__toUnderlyingSinkStartCallback cb

1258 | namespace UnderlyingSinkWriteCallback

1260 |   export

1261 |   toUnderlyingSinkWriteCallback :

1262 |        (AnyPtr -> WritableStreamDefaultController -> IO (Promise Undefined))

1263 |     -> JSIO UnderlyingSinkWriteCallback

1264 |   toUnderlyingSinkWriteCallback cb = primJS $ prim__toUnderlyingSinkWriteCallback cb

1268 | namespace UnderlyingSourceCancelCallback

1270 |   export

1271 |   toUnderlyingSourceCancelCallback :

1272 |        (UndefOr AnyPtr -> IO (Promise Undefined))

1273 |     -> JSIO UnderlyingSourceCancelCallback

1274 |   toUnderlyingSourceCancelCallback cb = primJS $ prim__toUnderlyingSourceCancelCallback cb

1278 | namespace UnderlyingSourcePullCallback

1280 |   export

1281 |   toUnderlyingSourcePullCallback :

1282 |        (  Union2 ReadableStreamDefaultController ReadableByteStreamController

1283 |        -> IO (Promise Undefined)

1284 |        )

1285 |     -> JSIO UnderlyingSourcePullCallback

1286 |   toUnderlyingSourcePullCallback cb = primJS $ prim__toUnderlyingSourcePullCallback cb

1290 | namespace UnderlyingSourceStartCallback

1292 |   export

1293 |   toUnderlyingSourceStartCallback :

1294 |        (  Union2 ReadableStreamDefaultController ReadableByteStreamController

1295 |        -> IO AnyPtr

1296 |        )

1297 |     -> JSIO UnderlyingSourceStartCallback

1298 |   toUnderlyingSourceStartCallback cb = primJS $ prim__toUnderlyingSourceStartCallback cb