Attributes

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

lazy val accept: Builders.Attribute[String, String]

lazy val accessKey: Builders.Attribute[String, String]

lazy val action: Builders.Attribute[String, String]

lazy val alt: Builders.Attribute[String, String]

final def asInstanceOf[T0]: T0

def attr[T](key: String, convert: (T) ⇒ Value = (t: T) => t.toString : Attr.Value): AttributeBuilder[T]

def attr[V](key: String, codec: Codec[V, String]): AttributeBuilder[V]

lazy val autoCapitalize: Builders.Attribute[String, String]

lazy val autoComplete: Builders.Attribute[Boolean, String]

lazy val autoFocus: Builders.Attribute[Boolean, Boolean]

def booleanReflectedAttr(key: String, attrCodec: Codec[Boolean, String]): Builders.Attribute[Boolean, Boolean]

def booleanReflectedAttr(attrKey: String, propKey: String, attrCodec: Codec[Boolean, String]): Builders.Attribute[Boolean, Boolean]

lazy val charset: AttributeBuilder[String]

lazy val checked: Builders.Property[Boolean, Boolean]

lazy val child: ChildStreamReceiverBuilder.type

A special attribute that takes a stream of single child nodes.

lazy val children: ChildrenStreamReceiverBuilder.type

A special attribute that takes a stream of lists of child nodes.

lazy val class: AccumAttributeBuilder[String]

lazy val className: AccumAttributeBuilder[String]

lazy val classNames: Builders.Attribute[Iterable[String], String]

def clone(): AnyRef

lazy val cls: Builders.Attribute[String, String]

lazy val colSpan: Builders.Attribute[Int, Int]

lazy val cols: Builders.Attribute[Int, Int]

lazy val contentAttr: Builders.Attribute[String, String]

lazy val contentEditable: AttributeBuilder[Boolean]

lazy val contextMenuId: AttributeBuilder[String]

lazy val data: DynamicAttributeBuilder[Any]

def dataAttr(suffix: String): AttributeBuilder[String]

lazy val defaultChecked: Builders.Attribute[Boolean, Boolean]

lazy val defaultSelected: Builders.Attribute[Boolean, Boolean]

lazy val defaultValue: Builders.Attribute[String, String]

lazy val dir: Builders.Attribute[String, String]

lazy val disabled: Builders.Attribute[Boolean, Boolean]

def doubleAttr(key: String): AttributeBuilder[Double]

def doubleProp(key: String): Builders.Property[Double, Double]

def doubleReflectedAttr(key: String): Builders.Attribute[Double, Double]

lazy val draggable: Builders.Attribute[Boolean, Boolean]

lazy val dropZone: AttributeBuilder[String]

lazy val encType: Builders.Attribute[String, String]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eventProp[V <: Event](key: String): EventEmitter[V]

def finalize(): Unit

lazy val for: Builders.Attribute[String, String]

lazy val forId: Builders.Attribute[String, String]

lazy val formAction: Builders.Attribute[String, String]

lazy val formEncType: Builders.Attribute[String, String]

lazy val formId: AttributeBuilder[String]

lazy val formMethod: Builders.Attribute[String, String]

lazy val formNoValidate: Builders.Attribute[Boolean, Boolean]

lazy val formTarget: Builders.Attribute[String, String]

final def getClass(): Class[_]

def hashCode(): Int

lazy val heightAttr: AttributeBuilder[Int]

lazy val hidden: Builders.Attribute[Boolean, Boolean]

lazy val high: Builders.Attribute[Double, Double]

lazy val href: Builders.Attribute[String, String]

lazy val httpEquiv: Builders.Attribute[String, String]

lazy val id: Builders.Attribute[String, String]

lazy val indeterminate: Builders.Property[Boolean, Boolean]

def intAttr(key: String): AttributeBuilder[Int]

def intProp(key: String): Builders.Property[Int, Int]

def intReflectedAttr(key: String): Builders.Attribute[Int, Int]

def intReflectedAttr(attrKey: String, propKey: String): Builders.Attribute[Int, Int]

final def isInstanceOf[T0]: Boolean

lazy val key: KeyBuilder.type

lazy val lang: Builders.Attribute[String, String]

lazy val listId: AttributeBuilder[String]

lazy val low: Builders.Attribute[Double, Double]

lazy val max: AttributeBuilder[String]

lazy val maxLength: Builders.Attribute[Int, Int]

lazy val media: Builders.Attribute[String, String]

lazy val method: Builders.Attribute[String, String]

lazy val min: AttributeBuilder[String]

lazy val minLength: Builders.Attribute[Int, Int]

lazy val multiple: Builders.Attribute[Boolean, Boolean]

lazy val name: Builders.Attribute[String, String]

final def ne(arg0: AnyRef): Boolean

lazy val noValidate: Builders.Attribute[Boolean, Boolean]

final def notify(): Unit

final def notifyAll(): Unit

lazy val onAbort: EventEmitter[Event]

lazy val onBlur: EventEmitter[FocusEvent with TypedTargetEvent[Element]]

lazy val onCanPlay: EventEmitter[Event]

lazy val onCanPlayThrough: EventEmitter[Event]

lazy val onChange: EventEmitter[TypedTargetEvent[Element]]

lazy val onClick: EventEmitter[MouseEvent with TypedTargetEvent[Element]]

lazy val onContextMenu: EventEmitter[MouseEvent]

lazy val onCopy: EventEmitter[ClipboardEvent]

lazy val onCueChange: EventEmitter[Event]

lazy val onCut: EventEmitter[ClipboardEvent]

lazy val onDblClick: EventEmitter[MouseEvent with TypedTargetEvent[Element]]

lazy val onDestroy: SimpleEmitterBuilder[Element, DestroyHook]

Lifecycle hook for component destruction.

lazy val onDrag: EventEmitter[DragEvent]

lazy val onDragEnd: EventEmitter[DragEvent]

lazy val onDragEnter: EventEmitter[DragEvent]

lazy val onDragLeave: EventEmitter[DragEvent]

lazy val onDragOver: EventEmitter[DragEvent]

lazy val onDragStart: EventEmitter[DragEvent]

lazy val onDrop: EventEmitter[DragEvent]

lazy val onDurationChange: EventEmitter[Event]

lazy val onEmptied: EventEmitter[Event]

lazy val onEnded: EventEmitter[Event]

lazy val onError: EventEmitter[ErrorEvent]

lazy val onFocus: EventEmitter[FocusEvent with TypedTargetEvent[Element]]

lazy val onInput: EventEmitter[TypedTargetEvent[Element]]

lazy val onInsert: SimpleEmitterBuilder[Element, InsertHook]

Lifecycle hook for component insertion.

lazy val onInvalid: EventEmitter[TypedTargetEvent[Element]]

lazy val onKeyDown: EventEmitter[KeyboardEvent]

lazy val onKeyPress: EventEmitter[KeyboardEvent]

lazy val onKeyUp: EventEmitter[KeyboardEvent]

lazy val onLoad: EventEmitter[UIEvent]

lazy val onLoadStart: EventEmitter[Event]

lazy val onLoadedData: EventEmitter[Event]

lazy val onLoadedMetadata: EventEmitter[Event]

lazy val onMouseDown: EventEmitter[MouseEvent with TypedTargetEvent[Element]]

lazy val onMouseEnter: EventEmitter[MouseEvent with TypedTargetEvent[Element]]

lazy val onMouseLeave: EventEmitter[MouseEvent with TypedTargetEvent[Element]]

lazy val onMouseMove: EventEmitter[MouseEvent with TypedTargetEvent[Element]]

lazy val onMouseOut: EventEmitter[MouseEvent with TypedTargetEvent[Element]]

lazy val onMouseOver: EventEmitter[MouseEvent with TypedTargetEvent[Element]]

lazy val onMouseUp: EventEmitter[MouseEvent with TypedTargetEvent[Element]]

lazy val onPaste: EventEmitter[ClipboardEvent]

lazy val onPause: EventEmitter[Event]

lazy val onPlay: EventEmitter[Event]

lazy val onPlaying: EventEmitter[Event]

lazy val onPostPatch: SimpleEmitterBuilder[(Element, Element), PostPatchHook]

Lifecycle hook for component postpatch.

lazy val onPrePatch: SimpleEmitterBuilder[(Option[Element], Option[Element]), PrePatchHook]

Lifecycle hook for component prepatch.

lazy val onProgress: EventEmitter[Event]

lazy val onRateChange: EventEmitter[Event]

lazy val onReset: EventEmitter[TypedTargetEvent[Form]]

lazy val onResize: EventEmitter[UIEvent]

lazy val onScroll: EventEmitter[UIEvent]

lazy val onSearch: EventEmitter[TypedTargetEvent[Input]]

lazy val onSeeked: EventEmitter[Event]

lazy val onSeeking: EventEmitter[Event]

lazy val onSelect: EventEmitter[TypedTargetEvent[Element]]

lazy val onShow: EventEmitter[Event]

lazy val onStalled: EventEmitter[Event]

lazy val onSubmit: EventEmitter[TypedTargetEvent[Form]]

lazy val onSuspend: EventEmitter[Event]

lazy val onTimeUpdate: EventEmitter[Event]

lazy val onToggle: EventEmitter[Event]

lazy val onUpdate: SimpleEmitterBuilder[(Element, Element), UpdateHook]

Lifecycle hook for component updates.

lazy val onVolumeChange: EventEmitter[Event]

lazy val onWaiting: EventEmitter[Event]

lazy val onWheel: EventEmitter[MouseEvent]

lazy val optimum: Builders.Attribute[Double, Double]

lazy val pattern: Builders.Attribute[String, String]

lazy val placeholder: Builders.Attribute[String, String]

def prop[T](key: String, convert: (T) ⇒ Value = (t: T) => t): PropertyBuilder[T]

def prop[V, DomV](key: String, codec: Codec[V, DomV]): PropertyBuilder[V]

lazy val readOnly: Builders.Attribute[Boolean, Boolean]

def reflectedAttr[V, DomPropV](attrKey: String, propKey: String, attrCodec: Codec[V, String], propCodec: Codec[V, DomPropV]): AttributeBuilder[V]

lazy val rel: Builders.Attribute[String, String]

lazy val required: Builders.Attribute[Boolean, Boolean]

lazy val role: Builders.Attribute[String, String]

lazy val rowSpan: Builders.Attribute[Int, Int]

lazy val rows: Builders.Attribute[Int, Int]

lazy val scoped: Builders.Attribute[Boolean, Boolean]

lazy val selected: Builders.Property[Boolean, Boolean]

lazy val size: Builders.Attribute[Int, Int]

lazy val spellCheck: Builders.Attribute[Boolean, Boolean]

lazy val src: Builders.Attribute[String, String]

lazy val step: AttributeBuilder[String]

def stringAttr(key: String): AttributeBuilder[String]

def stringProp(key: String): Builders.Property[String, String]

def stringReflectedAttr(key: String): Builders.Attribute[String, String]

def stringReflectedAttr(attrKey: String, propKey: String): Builders.Attribute[String, String]

def style[T](key: String): BasicStyleBuilder[T]

lazy val styleAttr: AttributeBuilder[String]

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

lazy val tabIndex: Builders.Attribute[Int, Int]

lazy val target: Builders.Attribute[String, String]

lazy val textContent: Builders.Property[String, String]

lazy val title: Builders.Attribute[String, String]

def toString(): String

lazy val tpe: AttributeBuilder[String]

lazy val translate: Builders.Attribute[Boolean, Boolean]

lazy val typ: AttributeBuilder[String]

lazy val type: AttributeBuilder[String]

lazy val unselectable: AttributeBuilder[Boolean]

lazy val value: Builders.Property[String, String]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

lazy val widthAttr: AttributeBuilder[Int]

lazy val xmlns: Builders.Attribute[String, String]

lazy val click: EventEmitter[MouseEvent with TypedTargetEvent[Element]]

lazy val content: Builders.Attribute[String, String]

lazy val destroy: SimpleEmitterBuilder[Element, DestroyHook]

lazy val inputChecked: EmitterBuilder[TypedTargetEvent[Element], Boolean, Emitter]

lazy val inputNumber: EmitterBuilder[TypedTargetEvent[Element], Int, Emitter]

lazy val inputString: EmitterBuilder[TypedTargetEvent[Element], String, Emitter]

lazy val inputType: AttributeBuilder[String]

lazy val insert: SimpleEmitterBuilder[Element, InsertHook]

lazy val keydown: EventEmitter[KeyboardEvent]

lazy val list: AttributeBuilder[String]

lazy val postpatch: SimpleEmitterBuilder[(Element, Element), PostPatchHook]

lazy val prepatch: SimpleEmitterBuilder[(Option[Element], Option[Element]), PrePatchHook]

lazy val style: AttributeBuilder[String]

lazy val update: SimpleEmitterBuilder[(Element, Element), UpdateHook]