namespace UnityPeripherals.Lowlevel

open Stdlib.Asyncseq

module Unsafe =
  open Frduino.Lib.Unsafe

  val cast<'Caster, 'T, 'a when 'Caster :> Caster<'T>> : 'Caster -> 'a expr -> 'T expr

module Double =
  open Frduino.Lib.Unsafe

  val return_ : System.Double -> (System.Double expr)
  val from_any<'Caster, 'T, 'a when 'Caster :> Caster<'T>> : 'a expr -> 'T expr

module Caster =
  val double : Frduino.Lib.Unsafe.Caster<System.Double>

namespace UnityPeripherals

open Stdlib

module Seq =
  open Stdlib.Asyncseq

  /// <summary>
  /// <c>Seq.append a b</c> wraps the two coroutines <c>a</c> and <c>b</c> as a single concatenated coroutine.
  /// </summary>
  val append<'T, 'K> : a:M<'T, 'K> -> b:M<'T, 'K> -> M<'T, 'K>

type syntax<'T, 'TParam, 'TSerializer when 'TSerializer :> Serializable<'T, 'TParam>> =
  new : 'TSerializer -> syntax<'T, 'TParam, 'TSerializer>
  /// <summary>
  /// <c>async { cexpr }</c> builds an asynchronous workflow using computation expression syntax.
  /// </summary>
  member async : Asyncseq.AsynBuilder

  /// <summary>
  /// <c>(seq+async) { cexpr }</c> builds a sequence, as a variant equipped with asynchronous working capabilities, using sequence expression syntax.
  /// </summary>
  member asyncseq : Asyncseq.AsyncseqBuilder<'T, 'TParam, 'TSerializer>

  member seq : unit

  /// algebra appendage
  member ( + ) : 'a -> Asyncseq.AsynBuilder -> Asyncseq.AsyncseqBuilder<'T, 'TParam, 'TSerializer>

  member lit : 'a -> Asyncseq.expr<'a>

  member float : float -> Asyncseq.expr<float>

  member int : int -> Asyncseq.expr<int>

  member double : System.Double -> Asyncseq.expr<System.Double>

  /// <summary>
  /// An <c>o.tuple</c> is a grouping of unnamed but ordered values, possibly of different types. It is a reference type.
  /// </summary>
  member tuple : ('a Asyncseq.expr * 'b Asyncseq.expr * 'c Asyncseq.expr) -> (('a * 'b * 'c) Asyncseq.expr)