CallbackOption

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[A](cb: CallbackTo[Option[A]]): CallbackOption[A]

final def asInstanceOf[T0]: T0

implicit def callbackOptionCovariance[A, B >: A](c: CallbackOption[A]): CallbackOption[B]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail[A]: CallbackOption[A]

def finalize(): Unit

implicit def fromCallback(c: Callback): CallbackOption[Unit]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def keyCodeSwitch[A](e: react.ReactKeyboardEvent, altKey: Boolean = false, ctrlKey: Boolean = false, metaKey: Boolean = false, shiftKey: Boolean = false)(switch: PartialFunction[Int, CallbackTo[A]]): CallbackOption[A]

def keyEventSwitch[A, B](e: react.ReactKeyboardEvent, a: A, altKey: Boolean = false, ctrlKey: Boolean = false, metaKey: Boolean = false, shiftKey: Boolean = false)(switch: PartialFunction[A, CallbackTo[B]]): CallbackOption[B]

def liftCallback[A](cb: CallbackTo[A]): CallbackOption[A]

def liftOption[A](oa: ⇒ Option[A]): CallbackOption[A]

def liftOptionCallback[A](oc: ⇒ Option[CallbackTo[A]]): CallbackOption[A]

def liftOptionLike[O[_], A](oa: ⇒ O[A])(implicit O: OptionLike[O]): CallbackOption[A]

def liftOptionLikeCallback[O[_], A](oa: ⇒ O[CallbackTo[A]])(implicit O: OptionLike[O]): CallbackOption[A]

def liftValue[A](a: ⇒ A): CallbackOption[A]

def matchPF[A, B](a: ⇒ A)(pf: PartialFunction[A, B]): CallbackOption[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pass: CallbackOption[Unit]

def pure[A](a: A): CallbackOption[A]

def require(condition: ⇒ Boolean): CallbackOption[Unit]

def sequence[T[X] <: TraversableOnce[X], A](tca: ⇒ T[CallbackOption[A]])(implicit cbf: CanBuildFrom[T[CallbackOption[A]], A, T[A]]): CallbackOption[T[A]]

def sequenceOption[A](oca: ⇒ Option[CallbackOption[A]]): CallbackOption[A]

NOTE: Technically a proper, lawful sequence should return CallbackOption[Option[A]].

final def synchronized[T0](arg0: ⇒ T0): T0

def tailrec[A, B](a: A)(f: (A) ⇒ CallbackOption[Either[A, B]]): CallbackOption[B]

Tail-recursive callback.

implicit def toCallback(co: CallbackOption[Unit]): Callback

def toString(): String

def traverse[T[X] <: TraversableOnce[X], A, B](ta: ⇒ T[A])(f: (A) ⇒ CallbackOption[B])(implicit cbf: CanBuildFrom[T[A], B, T[B]]): CallbackOption[T[B]]

def traverseOption[A, B](oa: ⇒ Option[A])(f: (A) ⇒ CallbackOption[B]): CallbackOption[B]

NOTE: Technically a proper, lawful traversal should return CallbackOption[Option[B]].

def unless(condition: ⇒ Boolean): CallbackOption[Unit]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def asEventDefault[A](e: react.ReactEvent, co: CallbackOption[A]): CallbackOption[A]

Wraps a CallbackOption[A] so that: