Struct react_html::html_components::th::TableHeaderCellComponentProps

pub struct TableHeaderCellComponentProps(_);

Trait Implementations

impl AsMut<AnyJsStaticProps> for TableHeaderCellComponentProps

fn as_mut(&mut self) -> &mut AnyJsStaticProps

Performs the conversion.

impl AsRef<AnyJsStaticProps> for TableHeaderCellComponentProps

fn as_ref(&self) -> &AnyJsStaticProps

Performs the conversion.

impl Clone for TableHeaderCellComponentProps

fn clone(&self) -> TableHeaderCellComponentProps

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TableHeaderCellComponentProps

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TableHeaderCellComponentProps

fn default() -> Self

Returns the “default value” for a type.

impl HtmlCommonSharedPropsBuilder<HtmlTableCellElement> for TableHeaderCellComponentProps

fn children<TNode: Node>(self, v: Option<TNode>) -> Self

fn ref_el<TWriteRef: 'static + WriteRef<TElement> + SafeIntoJsRuntime>(
    self,
    v: Option<TWriteRef>
) -> Self

fn default_checked(self, v: Option<bool>) -> Self

fn class(self, v: Option<&str>) -> Self

fn draggable(self, v: Option<bool>) -> Self

fn hidden(self, v: Option<bool>) -> Self

fn id(self, v: Option<&str>) -> Self

fn lang(self, v: Option<&str>) -> Self

fn placeholder(self, v: Option<&str>) -> Self

fn style(self, v: Option<CssProperties>) -> Self

fn tab_index(self, v: Option<i32>) -> Self

fn title(self, v: Option<&str>) -> Self

fn suppress_content_editable_warning(self, v: Option<bool>) -> Self

fn suppress_hydration_warning(self, v: Option<bool>) -> Self

fn access_key(self, v: Option<&str>) -> Self

fn content_editable(self, v: Option<Inheritable<bool>>) -> Self

fn context_menu(self, v: Option<&str>) -> Self

fn dir(self, v: Option<&str>) -> Self

fn slot(self, v: Option<&str>) -> Self

fn spell_check(self, v: Option<bool>) -> Self

fn translate(self, v: Option<&str>) -> Self

fn radio_group(self, v: Option<&str>) -> Self

fn role(self, v: Option<Role>) -> Self

fn about(self, v: Option<&str>) -> Self

fn datatype(self, v: Option<&str>) -> Self

fn inlist(self, v: Option<&JsValue>) -> Self

fn prefix(self, v: Option<&str>) -> Self

fn property(self, v: Option<&str>) -> Self

fn resource(self, v: Option<&str>) -> Self

fn type_of(self, v: Option<&str>) -> Self

fn vocab(self, v: Option<&str>) -> Self

fn auto_capitalize(self, v: Option<&str>) -> Self

fn auto_correct(self, v: Option<&str>) -> Self

fn auto_save(self, v: Option<&str>) -> Self

fn color(self, v: Option<&str>) -> Self

fn item_prop(self, v: Option<&str>) -> Self

fn item_scope(self, v: Option<bool>) -> Self

fn item_type(self, v: Option<&str>) -> Self

fn item_id(self, v: Option<&str>) -> Self

fn item_ref(self, v: Option<&str>) -> Self

fn results(self, v: Option<i32>) -> Self

fn security(self, v: Option<&str>) -> Self

fn unselectable(self, v: Option<&str>) -> Self

fn input_mode(self, v: Option<HtmlInputMode>) -> Self

fn is(self, v: Option<&str>) -> Self

fn on_copy<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<ClipboardEvent<TElement>>, 

fn on_copy_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<ClipboardEvent<TElement>>, 

fn on_cut<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<ClipboardEvent<TElement>>, 

fn on_cut_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<ClipboardEvent<TElement>>, 

fn on_paste<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<ClipboardEvent<TElement>>, 

fn on_paste_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<ClipboardEvent<TElement>>, 

fn on_composition_end<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<CompositionEvent<TElement>>, 

fn on_composition_end_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<CompositionEvent<TElement>>, 

fn on_composition_start<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<CompositionEvent<TElement>>, 

fn on_composition_start_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<CompositionEvent<TElement>>, 

fn on_composition_update<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<CompositionEvent<TElement>>, 

fn on_composition_update_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<CompositionEvent<TElement>>, 

fn on_focus<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FocusEvent<TElement>>, 

fn on_focus_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FocusEvent<TElement>>, 

fn on_blur<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FocusEvent<TElement>>, 

fn on_blur_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FocusEvent<TElement>>, 

fn on_change<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_change_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_before_input<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_before_input_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_input<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_input_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_reset<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_reset_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_submit<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_submit_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_invalid<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_invalid_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<FormEvent<TElement>>, 

fn on_load<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_load_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_error<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_error_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_key_down<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<KeyboardEvent<TElement>>, 

fn on_key_down_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<KeyboardEvent<TElement>>, 

fn on_key_press<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<KeyboardEvent<TElement>>, 

fn on_key_press_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<KeyboardEvent<TElement>>, 

fn on_key_up<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<KeyboardEvent<TElement>>, 

fn on_key_up_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<KeyboardEvent<TElement>>, 

fn on_abort<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_abort_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_can_play<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_can_play_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_can_play_through<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_can_play_through_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_duration_change<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_duration_change_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_emptied<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_emptied_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_encrypted<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_encrypted_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_ended<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_ended_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_loaded_data<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_loaded_data_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_loaded_metadata<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_loaded_metadata_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_load_start<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_load_start_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_pause<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_pause_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_play<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_play_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_playing<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_playing_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_progress<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_progress_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_rate_change<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_rate_change_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_seeked<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_seeked_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_seeking<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_seeking_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_stalled<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_stalled_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_suspend<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_suspend_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_time_update<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_time_update_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_volume_change<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_volume_change_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_waiting<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_waiting_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_aux_click<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_aux_click_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_click<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_click_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_context_menu<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_context_menu_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_double_click<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_double_click_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_drag<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_end<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_end_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_enter<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_enter_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_exit<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_exit_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_leave<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_leave_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_over<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_over_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_start<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drag_start_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drop<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_drop_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<DragEvent<TElement>>, 

fn on_mouse_down<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_down_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_enter<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_leave<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_move<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_move_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_out<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_out_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_over<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_over_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_up<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_mouse_up_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<MouseEvent<TElement>>, 

fn on_select<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_select_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<SyntheticEvent<TElement>>, 

fn on_touch_cancel<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<TouchEvent<TElement>>, 

fn on_touch_cancel_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<TouchEvent<TElement>>, 

fn on_touch_end<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<TouchEvent<TElement>>, 

fn on_touch_end_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<TouchEvent<TElement>>, 

fn on_touch_move<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<TouchEvent<TElement>>, 

fn on_touch_move_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<TouchEvent<TElement>>, 

fn on_touch_start<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<TouchEvent<TElement>>, 

fn on_touch_start_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<TouchEvent<TElement>>, 

fn on_pointer_down<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_down_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_move<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_move_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_up<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_up_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_cancel<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_cancel_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_enter<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_enter_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_leave<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_leave_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_over<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_over_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_out<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_pointer_out_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_got_pointer_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_got_pointer_capture_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_lost_pointer_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_lost_pointer_capture_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<PointerEvent<TElement>>, 

fn on_scroll<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<UiEvent<TElement>>, 

fn on_scroll_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<UiEvent<TElement>>, 

fn on_wheel<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<WheelEvent<TElement>>, 

fn on_wheel_capture<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<WheelEvent<TElement>>, 

fn on_animation_start<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<AnimationEvent<TElement>>, 

fn on_animation_start_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<AnimationEvent<TElement>>, 

fn on_animation_end<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<AnimationEvent<TElement>>, 

fn on_animation_end_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<AnimationEvent<TElement>>, 

fn on_animation_iteration<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<AnimationEvent<TElement>>, 

fn on_animation_iteration_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<AnimationEvent<TElement>>, 

fn on_transition_end<F, A>(self, event_handler: Option<WrapFn<F, A>>) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<TransitionEvent<TElement>>, 

fn on_transition_end_capture<F, A>(
    self,
    event_handler: Option<WrapFn<F, A>>
) -> Self where
    WrapFn<F, A>: IntoJsEventHandler<TransitionEvent<TElement>>, 

impl HtmlTableCellSharedPropsBuilder<HtmlTableCellElement> for TableHeaderCellComponentProps

fn align(self, v: Option<TableCellAlign>) -> Self

fn col_span(self, v: Option<usize>) -> Self

fn headers(self, v: Option<&str>) -> Self

fn row_span(self, v: Option<f64>) -> Self

fn scope(self, v: Option<&str>) -> Self

fn abbr(self, v: Option<&str>) -> Self

impl Props for TableHeaderCellComponentProps

type InitialBuilder = Self

fn init_builder() -> Self

impl PropsBuilder<TableHeaderCellComponentProps> for TableHeaderCellComponentProps

fn build(self) -> Self

impl TableHeaderCellComponentPropsBuilder for TableHeaderCellComponentProps