icons 0.7.2

use leptos::prelude::*;

use super::icon_component::LeptosIcon;
use crate::common::icon_type::IconType;

// * 🧪 cargo check --features leptos

/// AArrowDown icon component (compatibility wrapper)
#[component]
pub fn AArrowDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AArrowDown class=class /> }
}

/// AArrowUp icon component (compatibility wrapper)
#[component]
pub fn AArrowUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AArrowUp class=class /> }
}

/// ALargeSmall icon component (compatibility wrapper)
#[component]
pub fn ALargeSmall(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ALargeSmall class=class /> }
}

/// Accessibility icon component (compatibility wrapper)
#[component]
pub fn Accessibility(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Accessibility class=class /> }
}

/// Activity icon component (compatibility wrapper)
#[component]
pub fn Activity(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Activity class=class /> }
}

/// AirVent icon component (compatibility wrapper)
#[component]
pub fn AirVent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AirVent class=class /> }
}

/// Airplay icon component (compatibility wrapper)
#[component]
pub fn Airplay(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Airplay class=class /> }
}

/// AlarmClock icon component (compatibility wrapper)
#[component]
pub fn AlarmClock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlarmClock class=class /> }
}

/// AlarmClockCheck icon component (compatibility wrapper)
#[component]
pub fn AlarmClockCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlarmClockCheck class=class /> }
}

/// AlarmClockMinus icon component (compatibility wrapper)
#[component]
pub fn AlarmClockMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlarmClockMinus class=class /> }
}

/// AlarmClockOff icon component (compatibility wrapper)
#[component]
pub fn AlarmClockOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlarmClockOff class=class /> }
}

/// AlarmClockPlus icon component (compatibility wrapper)
#[component]
pub fn AlarmClockPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlarmClockPlus class=class /> }
}

/// AlarmSmoke icon component (compatibility wrapper)
#[component]
pub fn AlarmSmoke(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlarmSmoke class=class /> }
}

/// Album icon component (compatibility wrapper)
#[component]
pub fn Album(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Album class=class /> }
}

/// AlignCenter icon component (compatibility wrapper)
#[component]
pub fn AlignCenter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignCenter class=class /> }
}

/// AlignCenterHorizontal icon component (compatibility wrapper)
#[component]
pub fn AlignCenterHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignCenterHorizontal class=class /> }
}

/// AlignCenterVertical icon component (compatibility wrapper)
#[component]
pub fn AlignCenterVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignCenterVertical class=class /> }
}

/// AlignEndHorizontal icon component (compatibility wrapper)
#[component]
pub fn AlignEndHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignEndHorizontal class=class /> }
}

/// AlignEndVertical icon component (compatibility wrapper)
#[component]
pub fn AlignEndVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignEndVertical class=class /> }
}

/// AlignHorizontalDistributeCenter icon component (compatibility wrapper)
#[component]
pub fn AlignHorizontalDistributeCenter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignHorizontalDistributeCenter class=class /> }
}

/// AlignHorizontalDistributeEnd icon component (compatibility wrapper)
#[component]
pub fn AlignHorizontalDistributeEnd(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignHorizontalDistributeEnd class=class /> }
}

/// AlignHorizontalDistributeStart icon component (compatibility wrapper)
#[component]
pub fn AlignHorizontalDistributeStart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignHorizontalDistributeStart class=class /> }
}

/// AlignHorizontalJustifyCenter icon component (compatibility wrapper)
#[component]
pub fn AlignHorizontalJustifyCenter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignHorizontalJustifyCenter class=class /> }
}

/// AlignHorizontalJustifyEnd icon component (compatibility wrapper)
#[component]
pub fn AlignHorizontalJustifyEnd(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignHorizontalJustifyEnd class=class /> }
}

/// AlignHorizontalJustifyStart icon component (compatibility wrapper)
#[component]
pub fn AlignHorizontalJustifyStart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignHorizontalJustifyStart class=class /> }
}

/// AlignHorizontalSpaceAround icon component (compatibility wrapper)
#[component]
pub fn AlignHorizontalSpaceAround(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignHorizontalSpaceAround class=class /> }
}

/// AlignHorizontalSpaceBetween icon component (compatibility wrapper)
#[component]
pub fn AlignHorizontalSpaceBetween(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignHorizontalSpaceBetween class=class /> }
}

/// AlignJustify icon component (compatibility wrapper)
#[component]
pub fn AlignJustify(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignJustify class=class /> }
}

/// AlignLeft icon component (compatibility wrapper)
#[component]
pub fn AlignLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignLeft class=class /> }
}

/// AlignRight icon component (compatibility wrapper)
#[component]
pub fn AlignRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignRight class=class /> }
}

/// AlignStartHorizontal icon component (compatibility wrapper)
#[component]
pub fn AlignStartHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignStartHorizontal class=class /> }
}

/// AlignStartVertical icon component (compatibility wrapper)
#[component]
pub fn AlignStartVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignStartVertical class=class /> }
}

/// AlignVerticalDistributeCenter icon component (compatibility wrapper)
#[component]
pub fn AlignVerticalDistributeCenter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignVerticalDistributeCenter class=class /> }
}

/// AlignVerticalDistributeEnd icon component (compatibility wrapper)
#[component]
pub fn AlignVerticalDistributeEnd(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignVerticalDistributeEnd class=class /> }
}

/// AlignVerticalDistributeStart icon component (compatibility wrapper)
#[component]
pub fn AlignVerticalDistributeStart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignVerticalDistributeStart class=class /> }
}

/// AlignVerticalJustifyCenter icon component (compatibility wrapper)
#[component]
pub fn AlignVerticalJustifyCenter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignVerticalJustifyCenter class=class /> }
}

/// AlignVerticalJustifyEnd icon component (compatibility wrapper)
#[component]
pub fn AlignVerticalJustifyEnd(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignVerticalJustifyEnd class=class /> }
}

/// AlignVerticalJustifyStart icon component (compatibility wrapper)
#[component]
pub fn AlignVerticalJustifyStart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignVerticalJustifyStart class=class /> }
}

/// AlignVerticalSpaceAround icon component (compatibility wrapper)
#[component]
pub fn AlignVerticalSpaceAround(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignVerticalSpaceAround class=class /> }
}

/// AlignVerticalSpaceBetween icon component (compatibility wrapper)
#[component]
pub fn AlignVerticalSpaceBetween(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AlignVerticalSpaceBetween class=class /> }
}

/// Ambulance icon component (compatibility wrapper)
#[component]
pub fn Ambulance(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ambulance class=class /> }
}

/// Ampersand icon component (compatibility wrapper)
#[component]
pub fn Ampersand(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ampersand class=class /> }
}

/// Ampersands icon component (compatibility wrapper)
#[component]
pub fn Ampersands(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ampersands class=class /> }
}

/// Amphora icon component (compatibility wrapper)
#[component]
pub fn Amphora(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Amphora class=class /> }
}

/// Anchor icon component (compatibility wrapper)
#[component]
pub fn Anchor(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Anchor class=class /> }
}

/// Angry icon component (compatibility wrapper)
#[component]
pub fn Angry(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Angry class=class /> }
}

/// Annoyed icon component (compatibility wrapper)
#[component]
pub fn Annoyed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Annoyed class=class /> }
}

/// Antenna icon component (compatibility wrapper)
#[component]
pub fn Antenna(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Antenna class=class /> }
}

/// Anvil icon component (compatibility wrapper)
#[component]
pub fn Anvil(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Anvil class=class /> }
}

/// Aperture icon component (compatibility wrapper)
#[component]
pub fn Aperture(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Aperture class=class /> }
}

/// AppWindow icon component (compatibility wrapper)
#[component]
pub fn AppWindow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AppWindow class=class /> }
}

/// AppWindowMac icon component (compatibility wrapper)
#[component]
pub fn AppWindowMac(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AppWindowMac class=class /> }
}

/// Apple icon component (compatibility wrapper)
#[component]
pub fn Apple(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Apple class=class /> }
}

/// Archive icon component (compatibility wrapper)
#[component]
pub fn Archive(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Archive class=class /> }
}

/// ArchiveRestore icon component (compatibility wrapper)
#[component]
pub fn ArchiveRestore(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArchiveRestore class=class /> }
}

/// ArchiveX icon component (compatibility wrapper)
#[component]
pub fn ArchiveX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArchiveX class=class /> }
}

/// Armchair icon component (compatibility wrapper)
#[component]
pub fn Armchair(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Armchair class=class /> }
}

/// ArrowBigDown icon component (compatibility wrapper)
#[component]
pub fn ArrowBigDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowBigDown class=class /> }
}

/// ArrowBigDownDash icon component (compatibility wrapper)
#[component]
pub fn ArrowBigDownDash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowBigDownDash class=class /> }
}

/// ArrowBigLeft icon component (compatibility wrapper)
#[component]
pub fn ArrowBigLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowBigLeft class=class /> }
}

/// ArrowBigLeftDash icon component (compatibility wrapper)
#[component]
pub fn ArrowBigLeftDash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowBigLeftDash class=class /> }
}

/// ArrowBigRight icon component (compatibility wrapper)
#[component]
pub fn ArrowBigRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowBigRight class=class /> }
}

/// ArrowBigRightDash icon component (compatibility wrapper)
#[component]
pub fn ArrowBigRightDash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowBigRightDash class=class /> }
}

/// ArrowBigUp icon component (compatibility wrapper)
#[component]
pub fn ArrowBigUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowBigUp class=class /> }
}

/// ArrowBigUpDash icon component (compatibility wrapper)
#[component]
pub fn ArrowBigUpDash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowBigUpDash class=class /> }
}

/// ArrowDown icon component (compatibility wrapper)
#[component]
pub fn ArrowDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDown class=class /> }
}

/// ArrowDown01 icon component (compatibility wrapper)
#[component]
pub fn ArrowDown01(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDown01 class=class /> }
}

/// ArrowDown10 icon component (compatibility wrapper)
#[component]
pub fn ArrowDown10(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDown10 class=class /> }
}

/// ArrowDownAZ icon component (compatibility wrapper)
#[component]
pub fn ArrowDownAZ(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDownAZ class=class /> }
}

/// ArrowDownFromLine icon component (compatibility wrapper)
#[component]
pub fn ArrowDownFromLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDownFromLine class=class /> }
}

/// ArrowDownLeft icon component (compatibility wrapper)
#[component]
pub fn ArrowDownLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDownLeft class=class /> }
}

/// ArrowDownNarrowWide icon component (compatibility wrapper)
#[component]
pub fn ArrowDownNarrowWide(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDownNarrowWide class=class /> }
}

/// ArrowDownRight icon component (compatibility wrapper)
#[component]
pub fn ArrowDownRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDownRight class=class /> }
}

/// ArrowDownToDot icon component (compatibility wrapper)
#[component]
pub fn ArrowDownToDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDownToDot class=class /> }
}

/// ArrowDownToLine icon component (compatibility wrapper)
#[component]
pub fn ArrowDownToLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDownToLine class=class /> }
}

/// ArrowDownUp icon component (compatibility wrapper)
#[component]
pub fn ArrowDownUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDownUp class=class /> }
}

/// ArrowDownWideNarrow icon component (compatibility wrapper)
#[component]
pub fn ArrowDownWideNarrow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDownWideNarrow class=class /> }
}

/// ArrowDownZA icon component (compatibility wrapper)
#[component]
pub fn ArrowDownZA(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowDownZA class=class /> }
}

/// ArrowLeft icon component (compatibility wrapper)
#[component]
pub fn ArrowLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowLeft class=class /> }
}

/// ArrowLeftFromLine icon component (compatibility wrapper)
#[component]
pub fn ArrowLeftFromLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowLeftFromLine class=class /> }
}

/// ArrowLeftRight icon component (compatibility wrapper)
#[component]
pub fn ArrowLeftRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowLeftRight class=class /> }
}

/// ArrowLeftToLine icon component (compatibility wrapper)
#[component]
pub fn ArrowLeftToLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowLeftToLine class=class /> }
}

/// ArrowRight icon component (compatibility wrapper)
#[component]
pub fn ArrowRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowRight class=class /> }
}

/// ArrowRightFromLine icon component (compatibility wrapper)
#[component]
pub fn ArrowRightFromLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowRightFromLine class=class /> }
}

/// ArrowRightLeft icon component (compatibility wrapper)
#[component]
pub fn ArrowRightLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowRightLeft class=class /> }
}

/// ArrowRightToLine icon component (compatibility wrapper)
#[component]
pub fn ArrowRightToLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowRightToLine class=class /> }
}

/// ArrowUp icon component (compatibility wrapper)
#[component]
pub fn ArrowUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUp class=class /> }
}

/// ArrowUp01 icon component (compatibility wrapper)
#[component]
pub fn ArrowUp01(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUp01 class=class /> }
}

/// ArrowUp10 icon component (compatibility wrapper)
#[component]
pub fn ArrowUp10(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUp10 class=class /> }
}

/// ArrowUpAZ icon component (compatibility wrapper)
#[component]
pub fn ArrowUpAZ(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUpAZ class=class /> }
}

/// ArrowUpDown icon component (compatibility wrapper)
#[component]
pub fn ArrowUpDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUpDown class=class /> }
}

/// ArrowUpFromDot icon component (compatibility wrapper)
#[component]
pub fn ArrowUpFromDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUpFromDot class=class /> }
}

/// ArrowUpFromLine icon component (compatibility wrapper)
#[component]
pub fn ArrowUpFromLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUpFromLine class=class /> }
}

/// ArrowUpLeft icon component (compatibility wrapper)
#[component]
pub fn ArrowUpLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUpLeft class=class /> }
}

/// ArrowUpNarrowWide icon component (compatibility wrapper)
#[component]
pub fn ArrowUpNarrowWide(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUpNarrowWide class=class /> }
}

/// ArrowUpRight icon component (compatibility wrapper)
#[component]
pub fn ArrowUpRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUpRight class=class /> }
}

/// ArrowUpToLine icon component (compatibility wrapper)
#[component]
pub fn ArrowUpToLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUpToLine class=class /> }
}

/// ArrowUpWideNarrow icon component (compatibility wrapper)
#[component]
pub fn ArrowUpWideNarrow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUpWideNarrow class=class /> }
}

/// ArrowUpZA icon component (compatibility wrapper)
#[component]
pub fn ArrowUpZA(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowUpZA class=class /> }
}

/// ArrowsUpFromLine icon component (compatibility wrapper)
#[component]
pub fn ArrowsUpFromLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ArrowsUpFromLine class=class /> }
}

/// Asterisk icon component (compatibility wrapper)
#[component]
pub fn Asterisk(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Asterisk class=class /> }
}

/// AtSign icon component (compatibility wrapper)
#[component]
pub fn AtSign(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AtSign class=class /> }
}

/// Atom icon component (compatibility wrapper)
#[component]
pub fn Atom(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Atom class=class /> }
}

/// AudioLines icon component (compatibility wrapper)
#[component]
pub fn AudioLines(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AudioLines class=class /> }
}

/// AudioWaveform icon component (compatibility wrapper)
#[component]
pub fn AudioWaveform(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::AudioWaveform class=class /> }
}

/// Award icon component (compatibility wrapper)
#[component]
pub fn Award(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Award class=class /> }
}

/// Axe icon component (compatibility wrapper)
#[component]
pub fn Axe(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Axe class=class /> }
}

/// Axis3D icon component (compatibility wrapper)
#[component]
pub fn Axis3D(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Axis3D class=class /> }
}

/// Baby icon component (compatibility wrapper)
#[component]
pub fn Baby(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Baby class=class /> }
}

/// Backpack icon component (compatibility wrapper)
#[component]
pub fn Backpack(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Backpack class=class /> }
}

/// Badge icon component (compatibility wrapper)
#[component]
pub fn Badge(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Badge class=class /> }
}

/// BadgeAlert icon component (compatibility wrapper)
#[component]
pub fn BadgeAlert(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeAlert class=class /> }
}

/// BadgeCent icon component (compatibility wrapper)
#[component]
pub fn BadgeCent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeCent class=class /> }
}

/// BadgeCheck icon component (compatibility wrapper)
#[component]
pub fn BadgeCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeCheck class=class /> }
}

/// BadgeDollarSign icon component (compatibility wrapper)
#[component]
pub fn BadgeDollarSign(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeDollarSign class=class /> }
}

/// BadgeEuro icon component (compatibility wrapper)
#[component]
pub fn BadgeEuro(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeEuro class=class /> }
}

/// BadgeHelp icon component (compatibility wrapper)
#[component]
pub fn BadgeHelp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeHelp class=class /> }
}

/// BadgeIndianRupee icon component (compatibility wrapper)
#[component]
pub fn BadgeIndianRupee(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeIndianRupee class=class /> }
}

/// BadgeInfo icon component (compatibility wrapper)
#[component]
pub fn BadgeInfo(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeInfo class=class /> }
}

/// BadgeJapaneseYen icon component (compatibility wrapper)
#[component]
pub fn BadgeJapaneseYen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeJapaneseYen class=class /> }
}

/// BadgeMinus icon component (compatibility wrapper)
#[component]
pub fn BadgeMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeMinus class=class /> }
}

/// BadgePercent icon component (compatibility wrapper)
#[component]
pub fn BadgePercent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgePercent class=class /> }
}

/// BadgePlus icon component (compatibility wrapper)
#[component]
pub fn BadgePlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgePlus class=class /> }
}

/// BadgePoundSterling icon component (compatibility wrapper)
#[component]
pub fn BadgePoundSterling(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgePoundSterling class=class /> }
}

/// BadgeQuestionMark icon component (compatibility wrapper)
#[component]
pub fn BadgeQuestionMark(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeQuestionMark class=class /> }
}

/// BadgeRussianRuble icon component (compatibility wrapper)
#[component]
pub fn BadgeRussianRuble(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeRussianRuble class=class /> }
}

/// BadgeSwissFranc icon component (compatibility wrapper)
#[component]
pub fn BadgeSwissFranc(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeSwissFranc class=class /> }
}

/// BadgeTurkishLira icon component (compatibility wrapper)
#[component]
pub fn BadgeTurkishLira(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeTurkishLira class=class /> }
}

/// BadgeX icon component (compatibility wrapper)
#[component]
pub fn BadgeX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BadgeX class=class /> }
}

/// BaggageClaim icon component (compatibility wrapper)
#[component]
pub fn BaggageClaim(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BaggageClaim class=class /> }
}

/// Ban icon component (compatibility wrapper)
#[component]
pub fn Ban(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ban class=class /> }
}

/// Banana icon component (compatibility wrapper)
#[component]
pub fn Banana(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Banana class=class /> }
}

/// Bandage icon component (compatibility wrapper)
#[component]
pub fn Bandage(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bandage class=class /> }
}

/// Banknote icon component (compatibility wrapper)
#[component]
pub fn Banknote(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Banknote class=class /> }
}

/// BanknoteArrowDown icon component (compatibility wrapper)
#[component]
pub fn BanknoteArrowDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BanknoteArrowDown class=class /> }
}

/// BanknoteArrowUp icon component (compatibility wrapper)
#[component]
pub fn BanknoteArrowUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BanknoteArrowUp class=class /> }
}

/// BanknoteX icon component (compatibility wrapper)
#[component]
pub fn BanknoteX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BanknoteX class=class /> }
}

/// Barcode icon component (compatibility wrapper)
#[component]
pub fn Barcode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Barcode class=class /> }
}

/// Barrel icon component (compatibility wrapper)
#[component]
pub fn Barrel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Barrel class=class /> }
}

/// Baseline icon component (compatibility wrapper)
#[component]
pub fn Baseline(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Baseline class=class /> }
}

/// Bath icon component (compatibility wrapper)
#[component]
pub fn Bath(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bath class=class /> }
}

/// Battery icon component (compatibility wrapper)
#[component]
pub fn Battery(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Battery class=class /> }
}

/// BatteryCharging icon component (compatibility wrapper)
#[component]
pub fn BatteryCharging(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BatteryCharging class=class /> }
}

/// BatteryFull icon component (compatibility wrapper)
#[component]
pub fn BatteryFull(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BatteryFull class=class /> }
}

/// BatteryLow icon component (compatibility wrapper)
#[component]
pub fn BatteryLow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BatteryLow class=class /> }
}

/// BatteryMedium icon component (compatibility wrapper)
#[component]
pub fn BatteryMedium(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BatteryMedium class=class /> }
}

/// BatteryPlus icon component (compatibility wrapper)
#[component]
pub fn BatteryPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BatteryPlus class=class /> }
}

/// BatteryWarning icon component (compatibility wrapper)
#[component]
pub fn BatteryWarning(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BatteryWarning class=class /> }
}

/// Beaker icon component (compatibility wrapper)
#[component]
pub fn Beaker(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Beaker class=class /> }
}

/// Bean icon component (compatibility wrapper)
#[component]
pub fn Bean(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bean class=class /> }
}

/// BeanOff icon component (compatibility wrapper)
#[component]
pub fn BeanOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BeanOff class=class /> }
}

/// Bed icon component (compatibility wrapper)
#[component]
pub fn Bed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bed class=class /> }
}

/// BedDouble icon component (compatibility wrapper)
#[component]
pub fn BedDouble(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BedDouble class=class /> }
}

/// BedSingle icon component (compatibility wrapper)
#[component]
pub fn BedSingle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BedSingle class=class /> }
}

/// Beef icon component (compatibility wrapper)
#[component]
pub fn Beef(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Beef class=class /> }
}

/// Beer icon component (compatibility wrapper)
#[component]
pub fn Beer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Beer class=class /> }
}

/// BeerOff icon component (compatibility wrapper)
#[component]
pub fn BeerOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BeerOff class=class /> }
}

/// Bell icon component (compatibility wrapper)
#[component]
pub fn Bell(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bell class=class /> }
}

/// BellDot icon component (compatibility wrapper)
#[component]
pub fn BellDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BellDot class=class /> }
}

/// BellElectric icon component (compatibility wrapper)
#[component]
pub fn BellElectric(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BellElectric class=class /> }
}

/// BellMinus icon component (compatibility wrapper)
#[component]
pub fn BellMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BellMinus class=class /> }
}

/// BellOff icon component (compatibility wrapper)
#[component]
pub fn BellOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BellOff class=class /> }
}

/// BellPlus icon component (compatibility wrapper)
#[component]
pub fn BellPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BellPlus class=class /> }
}

/// BellRing icon component (compatibility wrapper)
#[component]
pub fn BellRing(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BellRing class=class /> }
}

/// BetweenHorizontalEnd icon component (compatibility wrapper)
#[component]
pub fn BetweenHorizontalEnd(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BetweenHorizontalEnd class=class /> }
}

/// BetweenHorizontalStart icon component (compatibility wrapper)
#[component]
pub fn BetweenHorizontalStart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BetweenHorizontalStart class=class /> }
}

/// BetweenVerticalEnd icon component (compatibility wrapper)
#[component]
pub fn BetweenVerticalEnd(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BetweenVerticalEnd class=class /> }
}

/// BetweenVerticalStart icon component (compatibility wrapper)
#[component]
pub fn BetweenVerticalStart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BetweenVerticalStart class=class /> }
}

/// BicepsFlexed icon component (compatibility wrapper)
#[component]
pub fn BicepsFlexed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BicepsFlexed class=class /> }
}

/// Bike icon component (compatibility wrapper)
#[component]
pub fn Bike(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bike class=class /> }
}

/// Binary icon component (compatibility wrapper)
#[component]
pub fn Binary(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Binary class=class /> }
}

/// Binoculars icon component (compatibility wrapper)
#[component]
pub fn Binoculars(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Binoculars class=class /> }
}

/// Biohazard icon component (compatibility wrapper)
#[component]
pub fn Biohazard(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Biohazard class=class /> }
}

/// Bird icon component (compatibility wrapper)
#[component]
pub fn Bird(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bird class=class /> }
}

/// Bitcoin icon component (compatibility wrapper)
#[component]
pub fn Bitcoin(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bitcoin class=class /> }
}

/// Blend icon component (compatibility wrapper)
#[component]
pub fn Blend(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Blend class=class /> }
}

/// Blinds icon component (compatibility wrapper)
#[component]
pub fn Blinds(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Blinds class=class /> }
}

/// Blocks icon component (compatibility wrapper)
#[component]
pub fn Blocks(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Blocks class=class /> }
}

/// Bluetooth icon component (compatibility wrapper)
#[component]
pub fn Bluetooth(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bluetooth class=class /> }
}

/// BluetoothConnected icon component (compatibility wrapper)
#[component]
pub fn BluetoothConnected(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BluetoothConnected class=class /> }
}

/// BluetoothOff icon component (compatibility wrapper)
#[component]
pub fn BluetoothOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BluetoothOff class=class /> }
}

/// BluetoothSearching icon component (compatibility wrapper)
#[component]
pub fn BluetoothSearching(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BluetoothSearching class=class /> }
}

/// Bold icon component (compatibility wrapper)
#[component]
pub fn Bold(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bold class=class /> }
}

/// Bolt icon component (compatibility wrapper)
#[component]
pub fn Bolt(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bolt class=class /> }
}

/// Bomb icon component (compatibility wrapper)
#[component]
pub fn Bomb(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bomb class=class /> }
}

/// Bone icon component (compatibility wrapper)
#[component]
pub fn Bone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bone class=class /> }
}

/// Book icon component (compatibility wrapper)
#[component]
pub fn Book(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Book class=class /> }
}

/// BookA icon component (compatibility wrapper)
#[component]
pub fn BookA(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookA class=class /> }
}

/// BookAlert icon component (compatibility wrapper)
#[component]
pub fn BookAlert(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookAlert class=class /> }
}

/// BookAudio icon component (compatibility wrapper)
#[component]
pub fn BookAudio(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookAudio class=class /> }
}

/// BookCheck icon component (compatibility wrapper)
#[component]
pub fn BookCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookCheck class=class /> }
}

/// BookCopy icon component (compatibility wrapper)
#[component]
pub fn BookCopy(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookCopy class=class /> }
}

/// BookDashed icon component (compatibility wrapper)
#[component]
pub fn BookDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookDashed class=class /> }
}

/// BookDown icon component (compatibility wrapper)
#[component]
pub fn BookDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookDown class=class /> }
}

/// BookHeadphones icon component (compatibility wrapper)
#[component]
pub fn BookHeadphones(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookHeadphones class=class /> }
}

/// BookHeart icon component (compatibility wrapper)
#[component]
pub fn BookHeart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookHeart class=class /> }
}

/// BookImage icon component (compatibility wrapper)
#[component]
pub fn BookImage(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookImage class=class /> }
}

/// BookKey icon component (compatibility wrapper)
#[component]
pub fn BookKey(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookKey class=class /> }
}

/// BookLock icon component (compatibility wrapper)
#[component]
pub fn BookLock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookLock class=class /> }
}

/// BookMarked icon component (compatibility wrapper)
#[component]
pub fn BookMarked(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookMarked class=class /> }
}

/// BookMinus icon component (compatibility wrapper)
#[component]
pub fn BookMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookMinus class=class /> }
}

/// BookOpen icon component (compatibility wrapper)
#[component]
pub fn BookOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookOpen class=class /> }
}

/// BookOpenCheck icon component (compatibility wrapper)
#[component]
pub fn BookOpenCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookOpenCheck class=class /> }
}

/// BookOpenText icon component (compatibility wrapper)
#[component]
pub fn BookOpenText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookOpenText class=class /> }
}

/// BookPlus icon component (compatibility wrapper)
#[component]
pub fn BookPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookPlus class=class /> }
}

/// BookText icon component (compatibility wrapper)
#[component]
pub fn BookText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookText class=class /> }
}

/// BookType icon component (compatibility wrapper)
#[component]
pub fn BookType(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookType class=class /> }
}

/// BookUp icon component (compatibility wrapper)
#[component]
pub fn BookUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookUp class=class /> }
}

/// BookUp2 icon component (compatibility wrapper)
#[component]
pub fn BookUp2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookUp2 class=class /> }
}

/// BookUser icon component (compatibility wrapper)
#[component]
pub fn BookUser(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookUser class=class /> }
}

/// BookX icon component (compatibility wrapper)
#[component]
pub fn BookX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookX class=class /> }
}

/// Bookmark icon component (compatibility wrapper)
#[component]
pub fn Bookmark(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bookmark class=class /> }
}

/// BookmarkCheck icon component (compatibility wrapper)
#[component]
pub fn BookmarkCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookmarkCheck class=class /> }
}

/// BookmarkMinus icon component (compatibility wrapper)
#[component]
pub fn BookmarkMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookmarkMinus class=class /> }
}

/// BookmarkPlus icon component (compatibility wrapper)
#[component]
pub fn BookmarkPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookmarkPlus class=class /> }
}

/// BookmarkX icon component (compatibility wrapper)
#[component]
pub fn BookmarkX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BookmarkX class=class /> }
}

/// BoomBox icon component (compatibility wrapper)
#[component]
pub fn BoomBox(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BoomBox class=class /> }
}

/// Bot icon component (compatibility wrapper)
#[component]
pub fn Bot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bot class=class /> }
}

/// BotMessageSquare icon component (compatibility wrapper)
#[component]
pub fn BotMessageSquare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BotMessageSquare class=class /> }
}

/// BotOff icon component (compatibility wrapper)
#[component]
pub fn BotOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BotOff class=class /> }
}

/// BottleWine icon component (compatibility wrapper)
#[component]
pub fn BottleWine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BottleWine class=class /> }
}

/// BowArrow icon component (compatibility wrapper)
#[component]
pub fn BowArrow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BowArrow class=class /> }
}

/// BoxIcon icon component (compatibility wrapper)
#[component]
pub fn BoxIcon(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BoxIcon class=class /> }
}

/// Boxes icon component (compatibility wrapper)
#[component]
pub fn Boxes(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Boxes class=class /> }
}

/// Braces icon component (compatibility wrapper)
#[component]
pub fn Braces(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Braces class=class /> }
}

/// Brackets icon component (compatibility wrapper)
#[component]
pub fn Brackets(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Brackets class=class /> }
}

/// Brain icon component (compatibility wrapper)
#[component]
pub fn Brain(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Brain class=class /> }
}

/// BrainCircuit icon component (compatibility wrapper)
#[component]
pub fn BrainCircuit(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BrainCircuit class=class /> }
}

/// BrainCog icon component (compatibility wrapper)
#[component]
pub fn BrainCog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BrainCog class=class /> }
}

/// BrickWall icon component (compatibility wrapper)
#[component]
pub fn BrickWall(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BrickWall class=class /> }
}

/// BrickWallFire icon component (compatibility wrapper)
#[component]
pub fn BrickWallFire(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BrickWallFire class=class /> }
}

/// Briefcase icon component (compatibility wrapper)
#[component]
pub fn Briefcase(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Briefcase class=class /> }
}

/// BriefcaseBusiness icon component (compatibility wrapper)
#[component]
pub fn BriefcaseBusiness(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BriefcaseBusiness class=class /> }
}

/// BriefcaseConveyorBelt icon component (compatibility wrapper)
#[component]
pub fn BriefcaseConveyorBelt(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BriefcaseConveyorBelt class=class /> }
}

/// BriefcaseMedical icon component (compatibility wrapper)
#[component]
pub fn BriefcaseMedical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BriefcaseMedical class=class /> }
}

/// BringToFront icon component (compatibility wrapper)
#[component]
pub fn BringToFront(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BringToFront class=class /> }
}

/// Brush icon component (compatibility wrapper)
#[component]
pub fn Brush(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Brush class=class /> }
}

/// BrushCleaning icon component (compatibility wrapper)
#[component]
pub fn BrushCleaning(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BrushCleaning class=class /> }
}

/// Bubbles icon component (compatibility wrapper)
#[component]
pub fn Bubbles(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bubbles class=class /> }
}

/// Bug icon component (compatibility wrapper)
#[component]
pub fn Bug(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bug class=class /> }
}

/// BugOff icon component (compatibility wrapper)
#[component]
pub fn BugOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BugOff class=class /> }
}

/// BugPlay icon component (compatibility wrapper)
#[component]
pub fn BugPlay(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BugPlay class=class /> }
}

/// Building icon component (compatibility wrapper)
#[component]
pub fn Building(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Building class=class /> }
}

/// Building2 icon component (compatibility wrapper)
#[component]
pub fn Building2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Building2 class=class /> }
}

/// Bus icon component (compatibility wrapper)
#[component]
pub fn Bus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Bus class=class /> }
}

/// BusFront icon component (compatibility wrapper)
#[component]
pub fn BusFront(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::BusFront class=class /> }
}

/// Cable icon component (compatibility wrapper)
#[component]
pub fn Cable(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cable class=class /> }
}

/// CableCar icon component (compatibility wrapper)
#[component]
pub fn CableCar(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CableCar class=class /> }
}

/// Cake icon component (compatibility wrapper)
#[component]
pub fn Cake(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cake class=class /> }
}

/// CakeSlice icon component (compatibility wrapper)
#[component]
pub fn CakeSlice(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CakeSlice class=class /> }
}

/// Calculator icon component (compatibility wrapper)
#[component]
pub fn Calculator(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Calculator class=class /> }
}

/// Calendar icon component (compatibility wrapper)
#[component]
pub fn Calendar(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Calendar class=class /> }
}

/// Calendar1 icon component (compatibility wrapper)
#[component]
pub fn Calendar1(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Calendar1 class=class /> }
}

/// CalendarArrowDown icon component (compatibility wrapper)
#[component]
pub fn CalendarArrowDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarArrowDown class=class /> }
}

/// CalendarArrowUp icon component (compatibility wrapper)
#[component]
pub fn CalendarArrowUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarArrowUp class=class /> }
}

/// CalendarCheck icon component (compatibility wrapper)
#[component]
pub fn CalendarCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarCheck class=class /> }
}

/// CalendarCheck2 icon component (compatibility wrapper)
#[component]
pub fn CalendarCheck2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarCheck2 class=class /> }
}

/// CalendarClock icon component (compatibility wrapper)
#[component]
pub fn CalendarClock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarClock class=class /> }
}

/// CalendarCog icon component (compatibility wrapper)
#[component]
pub fn CalendarCog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarCog class=class /> }
}

/// CalendarDays icon component (compatibility wrapper)
#[component]
pub fn CalendarDays(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarDays class=class /> }
}

/// CalendarFold icon component (compatibility wrapper)
#[component]
pub fn CalendarFold(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarFold class=class /> }
}

/// CalendarHeart icon component (compatibility wrapper)
#[component]
pub fn CalendarHeart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarHeart class=class /> }
}

/// CalendarMinus icon component (compatibility wrapper)
#[component]
pub fn CalendarMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarMinus class=class /> }
}

/// CalendarMinus2 icon component (compatibility wrapper)
#[component]
pub fn CalendarMinus2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarMinus2 class=class /> }
}

/// CalendarOff icon component (compatibility wrapper)
#[component]
pub fn CalendarOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarOff class=class /> }
}

/// CalendarPlus icon component (compatibility wrapper)
#[component]
pub fn CalendarPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarPlus class=class /> }
}

/// CalendarPlus2 icon component (compatibility wrapper)
#[component]
pub fn CalendarPlus2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarPlus2 class=class /> }
}

/// CalendarRange icon component (compatibility wrapper)
#[component]
pub fn CalendarRange(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarRange class=class /> }
}

/// CalendarSearch icon component (compatibility wrapper)
#[component]
pub fn CalendarSearch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarSearch class=class /> }
}

/// CalendarSync icon component (compatibility wrapper)
#[component]
pub fn CalendarSync(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarSync class=class /> }
}

/// CalendarX icon component (compatibility wrapper)
#[component]
pub fn CalendarX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarX class=class /> }
}

/// CalendarX2 icon component (compatibility wrapper)
#[component]
pub fn CalendarX2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CalendarX2 class=class /> }
}

/// Camera icon component (compatibility wrapper)
#[component]
pub fn Camera(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Camera class=class /> }
}

/// CameraOff icon component (compatibility wrapper)
#[component]
pub fn CameraOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CameraOff class=class /> }
}

/// Candy icon component (compatibility wrapper)
#[component]
pub fn Candy(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Candy class=class /> }
}

/// CandyCane icon component (compatibility wrapper)
#[component]
pub fn CandyCane(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CandyCane class=class /> }
}

/// CandyOff icon component (compatibility wrapper)
#[component]
pub fn CandyOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CandyOff class=class /> }
}

/// Cannabis icon component (compatibility wrapper)
#[component]
pub fn Cannabis(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cannabis class=class /> }
}

/// Captions icon component (compatibility wrapper)
#[component]
pub fn Captions(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Captions class=class /> }
}

/// CaptionsOff icon component (compatibility wrapper)
#[component]
pub fn CaptionsOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CaptionsOff class=class /> }
}

/// Car icon component (compatibility wrapper)
#[component]
pub fn Car(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Car class=class /> }
}

/// CarFront icon component (compatibility wrapper)
#[component]
pub fn CarFront(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CarFront class=class /> }
}

/// CarTaxiFront icon component (compatibility wrapper)
#[component]
pub fn CarTaxiFront(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CarTaxiFront class=class /> }
}

/// Caravan icon component (compatibility wrapper)
#[component]
pub fn Caravan(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Caravan class=class /> }
}

/// CardSim icon component (compatibility wrapper)
#[component]
pub fn CardSim(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CardSim class=class /> }
}

/// Carrot icon component (compatibility wrapper)
#[component]
pub fn Carrot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Carrot class=class /> }
}

/// CaseLower icon component (compatibility wrapper)
#[component]
pub fn CaseLower(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CaseLower class=class /> }
}

/// CaseSensitive icon component (compatibility wrapper)
#[component]
pub fn CaseSensitive(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CaseSensitive class=class /> }
}

/// CaseUpper icon component (compatibility wrapper)
#[component]
pub fn CaseUpper(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CaseUpper class=class /> }
}

/// CassetteTape icon component (compatibility wrapper)
#[component]
pub fn CassetteTape(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CassetteTape class=class /> }
}

/// Cast icon component (compatibility wrapper)
#[component]
pub fn Cast(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cast class=class /> }
}

/// Castle icon component (compatibility wrapper)
#[component]
pub fn Castle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Castle class=class /> }
}

/// Cat icon component (compatibility wrapper)
#[component]
pub fn Cat(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cat class=class /> }
}

/// Cctv icon component (compatibility wrapper)
#[component]
pub fn Cctv(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cctv class=class /> }
}

/// ChartArea icon component (compatibility wrapper)
#[component]
pub fn ChartArea(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartArea class=class /> }
}

/// ChartBar icon component (compatibility wrapper)
#[component]
pub fn ChartBar(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartBar class=class /> }
}

/// ChartBarBig icon component (compatibility wrapper)
#[component]
pub fn ChartBarBig(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartBarBig class=class /> }
}

/// ChartBarDecreasing icon component (compatibility wrapper)
#[component]
pub fn ChartBarDecreasing(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartBarDecreasing class=class /> }
}

/// ChartBarIncreasing icon component (compatibility wrapper)
#[component]
pub fn ChartBarIncreasing(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartBarIncreasing class=class /> }
}

/// ChartBarStacked icon component (compatibility wrapper)
#[component]
pub fn ChartBarStacked(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartBarStacked class=class /> }
}

/// ChartCandlestick icon component (compatibility wrapper)
#[component]
pub fn ChartCandlestick(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartCandlestick class=class /> }
}

/// ChartColumn icon component (compatibility wrapper)
#[component]
pub fn ChartColumn(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartColumn class=class /> }
}

/// ChartColumnBig icon component (compatibility wrapper)
#[component]
pub fn ChartColumnBig(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartColumnBig class=class /> }
}

/// ChartColumnDecreasing icon component (compatibility wrapper)
#[component]
pub fn ChartColumnDecreasing(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartColumnDecreasing class=class /> }
}

/// ChartColumnIncreasing icon component (compatibility wrapper)
#[component]
pub fn ChartColumnIncreasing(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartColumnIncreasing class=class /> }
}

/// ChartColumnStacked icon component (compatibility wrapper)
#[component]
pub fn ChartColumnStacked(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartColumnStacked class=class /> }
}

/// ChartGantt icon component (compatibility wrapper)
#[component]
pub fn ChartGantt(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartGantt class=class /> }
}

/// ChartLine icon component (compatibility wrapper)
#[component]
pub fn ChartLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartLine class=class /> }
}

/// ChartNetwork icon component (compatibility wrapper)
#[component]
pub fn ChartNetwork(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartNetwork class=class /> }
}

/// ChartNoAxesColumn icon component (compatibility wrapper)
#[component]
pub fn ChartNoAxesColumn(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartNoAxesColumn class=class /> }
}

/// ChartNoAxesColumnDecreasing icon component (compatibility wrapper)
#[component]
pub fn ChartNoAxesColumnDecreasing(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartNoAxesColumnDecreasing class=class /> }
}

/// ChartNoAxesColumnIncreasing icon component (compatibility wrapper)
#[component]
pub fn ChartNoAxesColumnIncreasing(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartNoAxesColumnIncreasing class=class /> }
}

/// ChartNoAxesCombined icon component (compatibility wrapper)
#[component]
pub fn ChartNoAxesCombined(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartNoAxesCombined class=class /> }
}

/// ChartNoAxesGantt icon component (compatibility wrapper)
#[component]
pub fn ChartNoAxesGantt(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartNoAxesGantt class=class /> }
}

/// ChartPie icon component (compatibility wrapper)
#[component]
pub fn ChartPie(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartPie class=class /> }
}

/// ChartScatter icon component (compatibility wrapper)
#[component]
pub fn ChartScatter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartScatter class=class /> }
}

/// ChartSpline icon component (compatibility wrapper)
#[component]
pub fn ChartSpline(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChartSpline class=class /> }
}

/// Check icon component (compatibility wrapper)
#[component]
pub fn Check(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Check class=class /> }
}

/// CheckCheck icon component (compatibility wrapper)
#[component]
pub fn CheckCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CheckCheck class=class /> }
}

/// CheckLine icon component (compatibility wrapper)
#[component]
pub fn CheckLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CheckLine class=class /> }
}

/// ChefHat icon component (compatibility wrapper)
#[component]
pub fn ChefHat(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChefHat class=class /> }
}

/// Cherry icon component (compatibility wrapper)
#[component]
pub fn Cherry(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cherry class=class /> }
}

/// ChevronDown icon component (compatibility wrapper)
#[component]
pub fn ChevronDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronDown class=class /> }
}

/// ChevronFirst icon component (compatibility wrapper)
#[component]
pub fn ChevronFirst(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronFirst class=class /> }
}

/// ChevronLast icon component (compatibility wrapper)
#[component]
pub fn ChevronLast(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronLast class=class /> }
}

/// ChevronLeft icon component (compatibility wrapper)
#[component]
pub fn ChevronLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronLeft class=class /> }
}

/// ChevronRight icon component (compatibility wrapper)
#[component]
pub fn ChevronRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronRight class=class /> }
}

/// ChevronUp icon component (compatibility wrapper)
#[component]
pub fn ChevronUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronUp class=class /> }
}

/// ChevronsDown icon component (compatibility wrapper)
#[component]
pub fn ChevronsDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronsDown class=class /> }
}

/// ChevronsDownUp icon component (compatibility wrapper)
#[component]
pub fn ChevronsDownUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronsDownUp class=class /> }
}

/// ChevronsLeft icon component (compatibility wrapper)
#[component]
pub fn ChevronsLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronsLeft class=class /> }
}

/// ChevronsLeftRight icon component (compatibility wrapper)
#[component]
pub fn ChevronsLeftRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronsLeftRight class=class /> }
}

/// ChevronsLeftRightEllipsis icon component (compatibility wrapper)
#[component]
pub fn ChevronsLeftRightEllipsis(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronsLeftRightEllipsis class=class /> }
}

/// ChevronsRight icon component (compatibility wrapper)
#[component]
pub fn ChevronsRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronsRight class=class /> }
}

/// ChevronsRightLeft icon component (compatibility wrapper)
#[component]
pub fn ChevronsRightLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronsRightLeft class=class /> }
}

/// ChevronsUp icon component (compatibility wrapper)
#[component]
pub fn ChevronsUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronsUp class=class /> }
}

/// ChevronsUpDown icon component (compatibility wrapper)
#[component]
pub fn ChevronsUpDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ChevronsUpDown class=class /> }
}

/// Chrome icon component (compatibility wrapper)
#[component]
pub fn Chrome(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Chrome class=class /> }
}

/// Church icon component (compatibility wrapper)
#[component]
pub fn Church(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Church class=class /> }
}

/// Cigarette icon component (compatibility wrapper)
#[component]
pub fn Cigarette(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cigarette class=class /> }
}

/// CigaretteOff icon component (compatibility wrapper)
#[component]
pub fn CigaretteOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CigaretteOff class=class /> }
}

/// Circle icon component (compatibility wrapper)
#[component]
pub fn Circle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Circle class=class /> }
}

/// CircleAlert icon component (compatibility wrapper)
#[component]
pub fn CircleAlert(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleAlert class=class /> }
}

/// CircleArrowDown icon component (compatibility wrapper)
#[component]
pub fn CircleArrowDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleArrowDown class=class /> }
}

/// CircleArrowLeft icon component (compatibility wrapper)
#[component]
pub fn CircleArrowLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleArrowLeft class=class /> }
}

/// CircleArrowOutDownLeft icon component (compatibility wrapper)
#[component]
pub fn CircleArrowOutDownLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleArrowOutDownLeft class=class /> }
}

/// CircleArrowOutDownRight icon component (compatibility wrapper)
#[component]
pub fn CircleArrowOutDownRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleArrowOutDownRight class=class /> }
}

/// CircleArrowOutUpLeft icon component (compatibility wrapper)
#[component]
pub fn CircleArrowOutUpLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleArrowOutUpLeft class=class /> }
}

/// CircleArrowOutUpRight icon component (compatibility wrapper)
#[component]
pub fn CircleArrowOutUpRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleArrowOutUpRight class=class /> }
}

/// CircleArrowRight icon component (compatibility wrapper)
#[component]
pub fn CircleArrowRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleArrowRight class=class /> }
}

/// CircleArrowUp icon component (compatibility wrapper)
#[component]
pub fn CircleArrowUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleArrowUp class=class /> }
}

/// CircleCheck icon component (compatibility wrapper)
#[component]
pub fn CircleCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleCheck class=class /> }
}

/// CircleCheckBig icon component (compatibility wrapper)
#[component]
pub fn CircleCheckBig(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleCheckBig class=class /> }
}

/// CircleChevronDown icon component (compatibility wrapper)
#[component]
pub fn CircleChevronDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleChevronDown class=class /> }
}

/// CircleChevronLeft icon component (compatibility wrapper)
#[component]
pub fn CircleChevronLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleChevronLeft class=class /> }
}

/// CircleChevronRight icon component (compatibility wrapper)
#[component]
pub fn CircleChevronRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleChevronRight class=class /> }
}

/// CircleChevronUp icon component (compatibility wrapper)
#[component]
pub fn CircleChevronUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleChevronUp class=class /> }
}

/// CircleDashed icon component (compatibility wrapper)
#[component]
pub fn CircleDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleDashed class=class /> }
}

/// CircleDivide icon component (compatibility wrapper)
#[component]
pub fn CircleDivide(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleDivide class=class /> }
}

/// CircleDollarSign icon component (compatibility wrapper)
#[component]
pub fn CircleDollarSign(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleDollarSign class=class /> }
}

/// CircleDot icon component (compatibility wrapper)
#[component]
pub fn CircleDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleDot class=class /> }
}

/// CircleDotDashed icon component (compatibility wrapper)
#[component]
pub fn CircleDotDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleDotDashed class=class /> }
}

/// CircleEllipsis icon component (compatibility wrapper)
#[component]
pub fn CircleEllipsis(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleEllipsis class=class /> }
}

/// CircleEqual icon component (compatibility wrapper)
#[component]
pub fn CircleEqual(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleEqual class=class /> }
}

/// CircleFadingArrowUp icon component (compatibility wrapper)
#[component]
pub fn CircleFadingArrowUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleFadingArrowUp class=class /> }
}

/// CircleFadingPlus icon component (compatibility wrapper)
#[component]
pub fn CircleFadingPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleFadingPlus class=class /> }
}

/// CircleGauge icon component (compatibility wrapper)
#[component]
pub fn CircleGauge(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleGauge class=class /> }
}

/// CircleHelp icon component (compatibility wrapper)
#[component]
pub fn CircleHelp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleHelp class=class /> }
}

/// CircleMinus icon component (compatibility wrapper)
#[component]
pub fn CircleMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleMinus class=class /> }
}

/// CircleOff icon component (compatibility wrapper)
#[component]
pub fn CircleOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleOff class=class /> }
}

/// CircleParking icon component (compatibility wrapper)
#[component]
pub fn CircleParking(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleParking class=class /> }
}

/// CircleParkingOff icon component (compatibility wrapper)
#[component]
pub fn CircleParkingOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleParkingOff class=class /> }
}

/// CirclePause icon component (compatibility wrapper)
#[component]
pub fn CirclePause(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CirclePause class=class /> }
}

/// CirclePercent icon component (compatibility wrapper)
#[component]
pub fn CirclePercent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CirclePercent class=class /> }
}

/// CirclePlay icon component (compatibility wrapper)
#[component]
pub fn CirclePlay(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CirclePlay class=class /> }
}

/// CirclePlus icon component (compatibility wrapper)
#[component]
pub fn CirclePlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CirclePlus class=class /> }
}

/// CirclePoundSterling icon component (compatibility wrapper)
#[component]
pub fn CirclePoundSterling(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CirclePoundSterling class=class /> }
}

/// CirclePower icon component (compatibility wrapper)
#[component]
pub fn CirclePower(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CirclePower class=class /> }
}

/// CircleQuestionMark icon component (compatibility wrapper)
#[component]
pub fn CircleQuestionMark(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleQuestionMark class=class /> }
}

/// CircleSlash icon component (compatibility wrapper)
#[component]
pub fn CircleSlash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleSlash class=class /> }
}

/// CircleSlash2 icon component (compatibility wrapper)
#[component]
pub fn CircleSlash2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleSlash2 class=class /> }
}

/// CircleSmall icon component (compatibility wrapper)
#[component]
pub fn CircleSmall(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleSmall class=class /> }
}

/// CircleStop icon component (compatibility wrapper)
#[component]
pub fn CircleStop(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleStop class=class /> }
}

/// CircleUser icon component (compatibility wrapper)
#[component]
pub fn CircleUser(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleUser class=class /> }
}

/// CircleUserRound icon component (compatibility wrapper)
#[component]
pub fn CircleUserRound(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleUserRound class=class /> }
}

/// CircleX icon component (compatibility wrapper)
#[component]
pub fn CircleX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircleX class=class /> }
}

/// CircuitBoard icon component (compatibility wrapper)
#[component]
pub fn CircuitBoard(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CircuitBoard class=class /> }
}

/// Citrus icon component (compatibility wrapper)
#[component]
pub fn Citrus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Citrus class=class /> }
}

/// Clapperboard icon component (compatibility wrapper)
#[component]
pub fn Clapperboard(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clapperboard class=class /> }
}

/// Clipboard icon component (compatibility wrapper)
#[component]
pub fn Clipboard(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clipboard class=class /> }
}

/// ClipboardCheck icon component (compatibility wrapper)
#[component]
pub fn ClipboardCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardCheck class=class /> }
}

/// ClipboardClock icon component (compatibility wrapper)
#[component]
pub fn ClipboardClock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardClock class=class /> }
}

/// ClipboardCopy icon component (compatibility wrapper)
#[component]
pub fn ClipboardCopy(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardCopy class=class /> }
}

/// ClipboardList icon component (compatibility wrapper)
#[component]
pub fn ClipboardList(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardList class=class /> }
}

/// ClipboardMinus icon component (compatibility wrapper)
#[component]
pub fn ClipboardMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardMinus class=class /> }
}

/// ClipboardPaste icon component (compatibility wrapper)
#[component]
pub fn ClipboardPaste(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardPaste class=class /> }
}

/// ClipboardPen icon component (compatibility wrapper)
#[component]
pub fn ClipboardPen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardPen class=class /> }
}

/// ClipboardPenLine icon component (compatibility wrapper)
#[component]
pub fn ClipboardPenLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardPenLine class=class /> }
}

/// ClipboardPlus icon component (compatibility wrapper)
#[component]
pub fn ClipboardPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardPlus class=class /> }
}

/// ClipboardType icon component (compatibility wrapper)
#[component]
pub fn ClipboardType(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardType class=class /> }
}

/// ClipboardX icon component (compatibility wrapper)
#[component]
pub fn ClipboardX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClipboardX class=class /> }
}

/// Clock icon component (compatibility wrapper)
#[component]
pub fn Clock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock class=class /> }
}

/// Clock1 icon component (compatibility wrapper)
#[component]
pub fn Clock1(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock1 class=class /> }
}

/// Clock10 icon component (compatibility wrapper)
#[component]
pub fn Clock10(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock10 class=class /> }
}

/// Clock11 icon component (compatibility wrapper)
#[component]
pub fn Clock11(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock11 class=class /> }
}

/// Clock12 icon component (compatibility wrapper)
#[component]
pub fn Clock12(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock12 class=class /> }
}

/// Clock2 icon component (compatibility wrapper)
#[component]
pub fn Clock2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock2 class=class /> }
}

/// Clock3 icon component (compatibility wrapper)
#[component]
pub fn Clock3(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock3 class=class /> }
}

/// Clock4 icon component (compatibility wrapper)
#[component]
pub fn Clock4(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock4 class=class /> }
}

/// Clock5 icon component (compatibility wrapper)
#[component]
pub fn Clock5(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock5 class=class /> }
}

/// Clock6 icon component (compatibility wrapper)
#[component]
pub fn Clock6(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock6 class=class /> }
}

/// Clock7 icon component (compatibility wrapper)
#[component]
pub fn Clock7(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock7 class=class /> }
}

/// Clock8 icon component (compatibility wrapper)
#[component]
pub fn Clock8(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock8 class=class /> }
}

/// Clock9 icon component (compatibility wrapper)
#[component]
pub fn Clock9(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clock9 class=class /> }
}

/// ClockAlert icon component (compatibility wrapper)
#[component]
pub fn ClockAlert(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClockAlert class=class /> }
}

/// ClockArrowDown icon component (compatibility wrapper)
#[component]
pub fn ClockArrowDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClockArrowDown class=class /> }
}

/// ClockArrowUp icon component (compatibility wrapper)
#[component]
pub fn ClockArrowUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClockArrowUp class=class /> }
}

/// ClockFading icon component (compatibility wrapper)
#[component]
pub fn ClockFading(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClockFading class=class /> }
}

/// ClockPlus icon component (compatibility wrapper)
#[component]
pub fn ClockPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ClockPlus class=class /> }
}

/// Cloud icon component (compatibility wrapper)
#[component]
pub fn Cloud(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cloud class=class /> }
}

/// CloudAlert icon component (compatibility wrapper)
#[component]
pub fn CloudAlert(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudAlert class=class /> }
}

/// CloudCheck icon component (compatibility wrapper)
#[component]
pub fn CloudCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudCheck class=class /> }
}

/// CloudCog icon component (compatibility wrapper)
#[component]
pub fn CloudCog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudCog class=class /> }
}

/// CloudDownload icon component (compatibility wrapper)
#[component]
pub fn CloudDownload(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudDownload class=class /> }
}

/// CloudDrizzle icon component (compatibility wrapper)
#[component]
pub fn CloudDrizzle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudDrizzle class=class /> }
}

/// CloudFog icon component (compatibility wrapper)
#[component]
pub fn CloudFog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudFog class=class /> }
}

/// CloudHail icon component (compatibility wrapper)
#[component]
pub fn CloudHail(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudHail class=class /> }
}

/// CloudLightning icon component (compatibility wrapper)
#[component]
pub fn CloudLightning(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudLightning class=class /> }
}

/// CloudMoon icon component (compatibility wrapper)
#[component]
pub fn CloudMoon(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudMoon class=class /> }
}

/// CloudMoonRain icon component (compatibility wrapper)
#[component]
pub fn CloudMoonRain(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudMoonRain class=class /> }
}

/// CloudOff icon component (compatibility wrapper)
#[component]
pub fn CloudOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudOff class=class /> }
}

/// CloudRain icon component (compatibility wrapper)
#[component]
pub fn CloudRain(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudRain class=class /> }
}

/// CloudRainWind icon component (compatibility wrapper)
#[component]
pub fn CloudRainWind(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudRainWind class=class /> }
}

/// CloudSnow icon component (compatibility wrapper)
#[component]
pub fn CloudSnow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudSnow class=class /> }
}

/// CloudSun icon component (compatibility wrapper)
#[component]
pub fn CloudSun(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudSun class=class /> }
}

/// CloudSunRain icon component (compatibility wrapper)
#[component]
pub fn CloudSunRain(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudSunRain class=class /> }
}

/// CloudUpload icon component (compatibility wrapper)
#[component]
pub fn CloudUpload(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CloudUpload class=class /> }
}

/// Cloudy icon component (compatibility wrapper)
#[component]
pub fn Cloudy(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cloudy class=class /> }
}

/// Clover icon component (compatibility wrapper)
#[component]
pub fn Clover(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Clover class=class /> }
}

/// Club icon component (compatibility wrapper)
#[component]
pub fn Club(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Club class=class /> }
}

/// Code icon component (compatibility wrapper)
#[component]
pub fn Code(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Code class=class /> }
}

/// CodeXml icon component (compatibility wrapper)
#[component]
pub fn CodeXml(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CodeXml class=class /> }
}

/// Codepen icon component (compatibility wrapper)
#[component]
pub fn Codepen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Codepen class=class /> }
}

/// Codesandbox icon component (compatibility wrapper)
#[component]
pub fn Codesandbox(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Codesandbox class=class /> }
}

/// Coffee icon component (compatibility wrapper)
#[component]
pub fn Coffee(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Coffee class=class /> }
}

/// Cog icon component (compatibility wrapper)
#[component]
pub fn Cog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cog class=class /> }
}

/// Coins icon component (compatibility wrapper)
#[component]
pub fn Coins(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Coins class=class /> }
}

/// Columns2 icon component (compatibility wrapper)
#[component]
pub fn Columns2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Columns2 class=class /> }
}

/// Columns3 icon component (compatibility wrapper)
#[component]
pub fn Columns3(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Columns3 class=class /> }
}

/// Columns3Cog icon component (compatibility wrapper)
#[component]
pub fn Columns3Cog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Columns3Cog class=class /> }
}

/// Columns4 icon component (compatibility wrapper)
#[component]
pub fn Columns4(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Columns4 class=class /> }
}

/// Combine icon component (compatibility wrapper)
#[component]
pub fn Combine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Combine class=class /> }
}

/// Command icon component (compatibility wrapper)
#[component]
pub fn Command(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Command class=class /> }
}

/// Compass icon component (compatibility wrapper)
#[component]
pub fn Compass(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Compass class=class /> }
}

/// Component icon component (compatibility wrapper)
#[component]
pub fn Component(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Component class=class /> }
}

/// Computer icon component (compatibility wrapper)
#[component]
pub fn Computer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Computer class=class /> }
}

/// ConciergeBell icon component (compatibility wrapper)
#[component]
pub fn ConciergeBell(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ConciergeBell class=class /> }
}

/// Cone icon component (compatibility wrapper)
#[component]
pub fn Cone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cone class=class /> }
}

/// Construction icon component (compatibility wrapper)
#[component]
pub fn Construction(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Construction class=class /> }
}

/// Contact icon component (compatibility wrapper)
#[component]
pub fn Contact(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Contact class=class /> }
}

/// ContactRound icon component (compatibility wrapper)
#[component]
pub fn ContactRound(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ContactRound class=class /> }
}

/// Container icon component (compatibility wrapper)
#[component]
pub fn Container(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Container class=class /> }
}

/// Contrast icon component (compatibility wrapper)
#[component]
pub fn Contrast(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Contrast class=class /> }
}

/// Cookie icon component (compatibility wrapper)
#[component]
pub fn Cookie(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cookie class=class /> }
}

/// CookingPot icon component (compatibility wrapper)
#[component]
pub fn CookingPot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CookingPot class=class /> }
}

/// Copy icon component (compatibility wrapper)
#[component]
pub fn Copy(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Copy class=class /> }
}

/// CopyCheck icon component (compatibility wrapper)
#[component]
pub fn CopyCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CopyCheck class=class /> }
}

/// CopyMinus icon component (compatibility wrapper)
#[component]
pub fn CopyMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CopyMinus class=class /> }
}

/// CopyPlus icon component (compatibility wrapper)
#[component]
pub fn CopyPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CopyPlus class=class /> }
}

/// CopySlash icon component (compatibility wrapper)
#[component]
pub fn CopySlash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CopySlash class=class /> }
}

/// CopyX icon component (compatibility wrapper)
#[component]
pub fn CopyX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CopyX class=class /> }
}

/// Copyleft icon component (compatibility wrapper)
#[component]
pub fn Copyleft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Copyleft class=class /> }
}

/// Copyright icon component (compatibility wrapper)
#[component]
pub fn Copyright(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Copyright class=class /> }
}

/// CornerDownLeft icon component (compatibility wrapper)
#[component]
pub fn CornerDownLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CornerDownLeft class=class /> }
}

/// CornerDownRight icon component (compatibility wrapper)
#[component]
pub fn CornerDownRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CornerDownRight class=class /> }
}

/// CornerLeftDown icon component (compatibility wrapper)
#[component]
pub fn CornerLeftDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CornerLeftDown class=class /> }
}

/// CornerLeftUp icon component (compatibility wrapper)
#[component]
pub fn CornerLeftUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CornerLeftUp class=class /> }
}

/// CornerRightDown icon component (compatibility wrapper)
#[component]
pub fn CornerRightDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CornerRightDown class=class /> }
}

/// CornerRightUp icon component (compatibility wrapper)
#[component]
pub fn CornerRightUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CornerRightUp class=class /> }
}

/// CornerUpLeft icon component (compatibility wrapper)
#[component]
pub fn CornerUpLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CornerUpLeft class=class /> }
}

/// CornerUpRight icon component (compatibility wrapper)
#[component]
pub fn CornerUpRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CornerUpRight class=class /> }
}

/// Cpu icon component (compatibility wrapper)
#[component]
pub fn Cpu(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cpu class=class /> }
}

/// CreativeCommons icon component (compatibility wrapper)
#[component]
pub fn CreativeCommons(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CreativeCommons class=class /> }
}

/// CreditCard icon component (compatibility wrapper)
#[component]
pub fn CreditCard(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CreditCard class=class /> }
}

/// Croissant icon component (compatibility wrapper)
#[component]
pub fn Croissant(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Croissant class=class /> }
}

/// Crop icon component (compatibility wrapper)
#[component]
pub fn Crop(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Crop class=class /> }
}

/// Cross icon component (compatibility wrapper)
#[component]
pub fn Cross(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cross class=class /> }
}

/// Crosshair icon component (compatibility wrapper)
#[component]
pub fn Crosshair(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Crosshair class=class /> }
}

/// Crown icon component (compatibility wrapper)
#[component]
pub fn Crown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Crown class=class /> }
}

/// Cuboid icon component (compatibility wrapper)
#[component]
pub fn Cuboid(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cuboid class=class /> }
}

/// CupSoda icon component (compatibility wrapper)
#[component]
pub fn CupSoda(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::CupSoda class=class /> }
}

/// Currency icon component (compatibility wrapper)
#[component]
pub fn Currency(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Currency class=class /> }
}

/// Cylinder icon component (compatibility wrapper)
#[component]
pub fn Cylinder(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Cylinder class=class /> }
}

/// Dam icon component (compatibility wrapper)
#[component]
pub fn Dam(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dam class=class /> }
}

/// Database icon component (compatibility wrapper)
#[component]
pub fn Database(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Database class=class /> }
}

/// DatabaseBackup icon component (compatibility wrapper)
#[component]
pub fn DatabaseBackup(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DatabaseBackup class=class /> }
}

/// DatabaseZap icon component (compatibility wrapper)
#[component]
pub fn DatabaseZap(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DatabaseZap class=class /> }
}

/// DecimalsArrowLeft icon component (compatibility wrapper)
#[component]
pub fn DecimalsArrowLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DecimalsArrowLeft class=class /> }
}

/// DecimalsArrowRight icon component (compatibility wrapper)
#[component]
pub fn DecimalsArrowRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DecimalsArrowRight class=class /> }
}

/// Delete icon component (compatibility wrapper)
#[component]
pub fn Delete(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Delete class=class /> }
}

/// Dessert icon component (compatibility wrapper)
#[component]
pub fn Dessert(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dessert class=class /> }
}

/// Diameter icon component (compatibility wrapper)
#[component]
pub fn Diameter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Diameter class=class /> }
}

/// Diamond icon component (compatibility wrapper)
#[component]
pub fn Diamond(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Diamond class=class /> }
}

/// DiamondMinus icon component (compatibility wrapper)
#[component]
pub fn DiamondMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DiamondMinus class=class /> }
}

/// DiamondPercent icon component (compatibility wrapper)
#[component]
pub fn DiamondPercent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DiamondPercent class=class /> }
}

/// DiamondPlus icon component (compatibility wrapper)
#[component]
pub fn DiamondPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DiamondPlus class=class /> }
}

/// Dice1 icon component (compatibility wrapper)
#[component]
pub fn Dice1(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dice1 class=class /> }
}

/// Dice2 icon component (compatibility wrapper)
#[component]
pub fn Dice2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dice2 class=class /> }
}

/// Dice3 icon component (compatibility wrapper)
#[component]
pub fn Dice3(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dice3 class=class /> }
}

/// Dice4 icon component (compatibility wrapper)
#[component]
pub fn Dice4(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dice4 class=class /> }
}

/// Dice5 icon component (compatibility wrapper)
#[component]
pub fn Dice5(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dice5 class=class /> }
}

/// Dice6 icon component (compatibility wrapper)
#[component]
pub fn Dice6(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dice6 class=class /> }
}

/// Dices icon component (compatibility wrapper)
#[component]
pub fn Dices(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dices class=class /> }
}

/// Diff icon component (compatibility wrapper)
#[component]
pub fn Diff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Diff class=class /> }
}

/// Disc icon component (compatibility wrapper)
#[component]
pub fn Disc(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Disc class=class /> }
}

/// Disc2 icon component (compatibility wrapper)
#[component]
pub fn Disc2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Disc2 class=class /> }
}

/// Disc3 icon component (compatibility wrapper)
#[component]
pub fn Disc3(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Disc3 class=class /> }
}

/// DiscAlbum icon component (compatibility wrapper)
#[component]
pub fn DiscAlbum(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DiscAlbum class=class /> }
}

/// Divide icon component (compatibility wrapper)
#[component]
pub fn Divide(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Divide class=class /> }
}

/// Dna icon component (compatibility wrapper)
#[component]
pub fn Dna(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dna class=class /> }
}

/// DnaOff icon component (compatibility wrapper)
#[component]
pub fn DnaOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DnaOff class=class /> }
}

/// Dock icon component (compatibility wrapper)
#[component]
pub fn Dock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dock class=class /> }
}

/// Dog icon component (compatibility wrapper)
#[component]
pub fn Dog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dog class=class /> }
}

/// DollarSign icon component (compatibility wrapper)
#[component]
pub fn DollarSign(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DollarSign class=class /> }
}

/// Donut icon component (compatibility wrapper)
#[component]
pub fn Donut(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Donut class=class /> }
}

/// DoorClosed icon component (compatibility wrapper)
#[component]
pub fn DoorClosed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DoorClosed class=class /> }
}

/// DoorClosedLocked icon component (compatibility wrapper)
#[component]
pub fn DoorClosedLocked(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DoorClosedLocked class=class /> }
}

/// DoorOpen icon component (compatibility wrapper)
#[component]
pub fn DoorOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DoorOpen class=class /> }
}

/// Dot icon component (compatibility wrapper)
#[component]
pub fn Dot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dot class=class /> }
}

/// Download icon component (compatibility wrapper)
#[component]
pub fn Download(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Download class=class /> }
}

/// DraftingCompass icon component (compatibility wrapper)
#[component]
pub fn DraftingCompass(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DraftingCompass class=class /> }
}

/// Drama icon component (compatibility wrapper)
#[component]
pub fn Drama(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Drama class=class /> }
}

/// Dribbble icon component (compatibility wrapper)
#[component]
pub fn Dribbble(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dribbble class=class /> }
}

/// Drill icon component (compatibility wrapper)
#[component]
pub fn Drill(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Drill class=class /> }
}

/// Drone icon component (compatibility wrapper)
#[component]
pub fn Drone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Drone class=class /> }
}

/// Droplet icon component (compatibility wrapper)
#[component]
pub fn Droplet(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Droplet class=class /> }
}

/// DropletOff icon component (compatibility wrapper)
#[component]
pub fn DropletOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::DropletOff class=class /> }
}

/// Droplets icon component (compatibility wrapper)
#[component]
pub fn Droplets(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Droplets class=class /> }
}

/// Drum icon component (compatibility wrapper)
#[component]
pub fn Drum(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Drum class=class /> }
}

/// Drumstick icon component (compatibility wrapper)
#[component]
pub fn Drumstick(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Drumstick class=class /> }
}

/// Dumbbell icon component (compatibility wrapper)
#[component]
pub fn Dumbbell(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Dumbbell class=class /> }
}

/// Ear icon component (compatibility wrapper)
#[component]
pub fn Ear(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ear class=class /> }
}

/// EarOff icon component (compatibility wrapper)
#[component]
pub fn EarOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::EarOff class=class /> }
}

/// Earth icon component (compatibility wrapper)
#[component]
pub fn Earth(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Earth class=class /> }
}

/// EarthLock icon component (compatibility wrapper)
#[component]
pub fn EarthLock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::EarthLock class=class /> }
}

/// Eclipse icon component (compatibility wrapper)
#[component]
pub fn Eclipse(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Eclipse class=class /> }
}

/// Egg icon component (compatibility wrapper)
#[component]
pub fn Egg(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Egg class=class /> }
}

/// EggFried icon component (compatibility wrapper)
#[component]
pub fn EggFried(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::EggFried class=class /> }
}

/// EggOff icon component (compatibility wrapper)
#[component]
pub fn EggOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::EggOff class=class /> }
}

/// Ellipsis icon component (compatibility wrapper)
#[component]
pub fn Ellipsis(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ellipsis class=class /> }
}

/// EllipsisVertical icon component (compatibility wrapper)
#[component]
pub fn EllipsisVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::EllipsisVertical class=class /> }
}

/// Equal icon component (compatibility wrapper)
#[component]
pub fn Equal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Equal class=class /> }
}

/// EqualApproximately icon component (compatibility wrapper)
#[component]
pub fn EqualApproximately(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::EqualApproximately class=class /> }
}

/// EqualNot icon component (compatibility wrapper)
#[component]
pub fn EqualNot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::EqualNot class=class /> }
}

/// Eraser icon component (compatibility wrapper)
#[component]
pub fn Eraser(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Eraser class=class /> }
}

/// EthernetPort icon component (compatibility wrapper)
#[component]
pub fn EthernetPort(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::EthernetPort class=class /> }
}

/// Euro icon component (compatibility wrapper)
#[component]
pub fn Euro(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Euro class=class /> }
}

/// Expand icon component (compatibility wrapper)
#[component]
pub fn Expand(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Expand class=class /> }
}

/// ExternalLink icon component (compatibility wrapper)
#[component]
pub fn ExternalLink(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ExternalLink class=class /> }
}

/// Eye icon component (compatibility wrapper)
#[component]
pub fn Eye(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Eye class=class /> }
}

/// EyeClosed icon component (compatibility wrapper)
#[component]
pub fn EyeClosed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::EyeClosed class=class /> }
}

/// EyeOff icon component (compatibility wrapper)
#[component]
pub fn EyeOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::EyeOff class=class /> }
}

/// Facebook icon component (compatibility wrapper)
#[component]
pub fn Facebook(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Facebook class=class /> }
}

/// Factory icon component (compatibility wrapper)
#[component]
pub fn Factory(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Factory class=class /> }
}

/// Fan icon component (compatibility wrapper)
#[component]
pub fn Fan(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Fan class=class /> }
}

/// FastForward icon component (compatibility wrapper)
#[component]
pub fn FastForward(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FastForward class=class /> }
}

/// Feather icon component (compatibility wrapper)
#[component]
pub fn Feather(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Feather class=class /> }
}

/// Fence icon component (compatibility wrapper)
#[component]
pub fn Fence(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Fence class=class /> }
}

/// FerrisWheel icon component (compatibility wrapper)
#[component]
pub fn FerrisWheel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FerrisWheel class=class /> }
}

/// Figma icon component (compatibility wrapper)
#[component]
pub fn Figma(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Figma class=class /> }
}

/// File icon component (compatibility wrapper)
#[component]
pub fn File(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::File class=class /> }
}

/// FileArchive icon component (compatibility wrapper)
#[component]
pub fn FileArchive(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileArchive class=class /> }
}

/// FileAudio icon component (compatibility wrapper)
#[component]
pub fn FileAudio(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileAudio class=class /> }
}

/// FileAudio2 icon component (compatibility wrapper)
#[component]
pub fn FileAudio2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileAudio2 class=class /> }
}

/// FileAxis3D icon component (compatibility wrapper)
#[component]
pub fn FileAxis3D(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileAxis3D class=class /> }
}

/// FileBadge icon component (compatibility wrapper)
#[component]
pub fn FileBadge(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileBadge class=class /> }
}

/// FileBadge2 icon component (compatibility wrapper)
#[component]
pub fn FileBadge2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileBadge2 class=class /> }
}

/// FileBox icon component (compatibility wrapper)
#[component]
pub fn FileBox(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileBox class=class /> }
}

/// FileChartColumn icon component (compatibility wrapper)
#[component]
pub fn FileChartColumn(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileChartColumn class=class /> }
}

/// FileChartColumnIncreasing icon component (compatibility wrapper)
#[component]
pub fn FileChartColumnIncreasing(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileChartColumnIncreasing class=class /> }
}

/// FileChartLine icon component (compatibility wrapper)
#[component]
pub fn FileChartLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileChartLine class=class /> }
}

/// FileChartPie icon component (compatibility wrapper)
#[component]
pub fn FileChartPie(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileChartPie class=class /> }
}

/// FileCheck icon component (compatibility wrapper)
#[component]
pub fn FileCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileCheck class=class /> }
}

/// FileCheck2 icon component (compatibility wrapper)
#[component]
pub fn FileCheck2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileCheck2 class=class /> }
}

/// FileClock icon component (compatibility wrapper)
#[component]
pub fn FileClock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileClock class=class /> }
}

/// FileCode icon component (compatibility wrapper)
#[component]
pub fn FileCode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileCode class=class /> }
}

/// FileCode2 icon component (compatibility wrapper)
#[component]
pub fn FileCode2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileCode2 class=class /> }
}

/// FileCog icon component (compatibility wrapper)
#[component]
pub fn FileCog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileCog class=class /> }
}

/// FileDiff icon component (compatibility wrapper)
#[component]
pub fn FileDiff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileDiff class=class /> }
}

/// FileDigit icon component (compatibility wrapper)
#[component]
pub fn FileDigit(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileDigit class=class /> }
}

/// FileDown icon component (compatibility wrapper)
#[component]
pub fn FileDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileDown class=class /> }
}

/// FileHeart icon component (compatibility wrapper)
#[component]
pub fn FileHeart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileHeart class=class /> }
}

/// FileImage icon component (compatibility wrapper)
#[component]
pub fn FileImage(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileImage class=class /> }
}

/// FileInput icon component (compatibility wrapper)
#[component]
pub fn FileInput(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileInput class=class /> }
}

/// FileJson icon component (compatibility wrapper)
#[component]
pub fn FileJson(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileJson class=class /> }
}

/// FileJson2 icon component (compatibility wrapper)
#[component]
pub fn FileJson2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileJson2 class=class /> }
}

/// FileKey icon component (compatibility wrapper)
#[component]
pub fn FileKey(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileKey class=class /> }
}

/// FileKey2 icon component (compatibility wrapper)
#[component]
pub fn FileKey2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileKey2 class=class /> }
}

/// FileLock icon component (compatibility wrapper)
#[component]
pub fn FileLock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileLock class=class /> }
}

/// FileLock2 icon component (compatibility wrapper)
#[component]
pub fn FileLock2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileLock2 class=class /> }
}

/// FileMinus icon component (compatibility wrapper)
#[component]
pub fn FileMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileMinus class=class /> }
}

/// FileMinus2 icon component (compatibility wrapper)
#[component]
pub fn FileMinus2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileMinus2 class=class /> }
}

/// FileMusic icon component (compatibility wrapper)
#[component]
pub fn FileMusic(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileMusic class=class /> }
}

/// FileOutput icon component (compatibility wrapper)
#[component]
pub fn FileOutput(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileOutput class=class /> }
}

/// FilePen icon component (compatibility wrapper)
#[component]
pub fn FilePen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FilePen class=class /> }
}

/// FilePenLine icon component (compatibility wrapper)
#[component]
pub fn FilePenLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FilePenLine class=class /> }
}

/// FilePlay icon component (compatibility wrapper)
#[component]
pub fn FilePlay(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FilePlay class=class /> }
}

/// FilePlus icon component (compatibility wrapper)
#[component]
pub fn FilePlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FilePlus class=class /> }
}

/// FilePlus2 icon component (compatibility wrapper)
#[component]
pub fn FilePlus2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FilePlus2 class=class /> }
}

/// FileQuestion icon component (compatibility wrapper)
#[component]
pub fn FileQuestion(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileQuestion class=class /> }
}

/// FileQuestionMark icon component (compatibility wrapper)
#[component]
pub fn FileQuestionMark(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileQuestionMark class=class /> }
}

/// FileScan icon component (compatibility wrapper)
#[component]
pub fn FileScan(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileScan class=class /> }
}

/// FileSearch icon component (compatibility wrapper)
#[component]
pub fn FileSearch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileSearch class=class /> }
}

/// FileSearch2 icon component (compatibility wrapper)
#[component]
pub fn FileSearch2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileSearch2 class=class /> }
}

/// FileSliders icon component (compatibility wrapper)
#[component]
pub fn FileSliders(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileSliders class=class /> }
}

/// FileSpreadsheet icon component (compatibility wrapper)
#[component]
pub fn FileSpreadsheet(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileSpreadsheet class=class /> }
}

/// FileStack icon component (compatibility wrapper)
#[component]
pub fn FileStack(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileStack class=class /> }
}

/// FileSymlink icon component (compatibility wrapper)
#[component]
pub fn FileSymlink(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileSymlink class=class /> }
}

/// FileTerminal icon component (compatibility wrapper)
#[component]
pub fn FileTerminal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileTerminal class=class /> }
}

/// FileText icon component (compatibility wrapper)
#[component]
pub fn FileText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileText class=class /> }
}

/// FileType icon component (compatibility wrapper)
#[component]
pub fn FileType(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileType class=class /> }
}

/// FileType2 icon component (compatibility wrapper)
#[component]
pub fn FileType2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileType2 class=class /> }
}

/// FileUp icon component (compatibility wrapper)
#[component]
pub fn FileUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileUp class=class /> }
}

/// FileUser icon component (compatibility wrapper)
#[component]
pub fn FileUser(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileUser class=class /> }
}

/// FileVideo icon component (compatibility wrapper)
#[component]
pub fn FileVideo(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileVideo class=class /> }
}

/// FileVideo2 icon component (compatibility wrapper)
#[component]
pub fn FileVideo2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileVideo2 class=class /> }
}

/// FileVideoCamera icon component (compatibility wrapper)
#[component]
pub fn FileVideoCamera(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileVideoCamera class=class /> }
}

/// FileVolume icon component (compatibility wrapper)
#[component]
pub fn FileVolume(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileVolume class=class /> }
}

/// FileVolume2 icon component (compatibility wrapper)
#[component]
pub fn FileVolume2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileVolume2 class=class /> }
}

/// FileWarning icon component (compatibility wrapper)
#[component]
pub fn FileWarning(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileWarning class=class /> }
}

/// FileX icon component (compatibility wrapper)
#[component]
pub fn FileX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileX class=class /> }
}

/// FileX2 icon component (compatibility wrapper)
#[component]
pub fn FileX2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FileX2 class=class /> }
}

/// Files icon component (compatibility wrapper)
#[component]
pub fn Files(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Files class=class /> }
}

/// Film icon component (compatibility wrapper)
#[component]
pub fn Film(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Film class=class /> }
}

/// Filter icon component (compatibility wrapper)
#[component]
pub fn Filter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Filter class=class /> }
}

/// FilterX icon component (compatibility wrapper)
#[component]
pub fn FilterX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FilterX class=class /> }
}

/// Fingerprint icon component (compatibility wrapper)
#[component]
pub fn Fingerprint(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Fingerprint class=class /> }
}

/// FireExtinguisher icon component (compatibility wrapper)
#[component]
pub fn FireExtinguisher(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FireExtinguisher class=class /> }
}

/// Fish icon component (compatibility wrapper)
#[component]
pub fn Fish(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Fish class=class /> }
}

/// FishOff icon component (compatibility wrapper)
#[component]
pub fn FishOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FishOff class=class /> }
}

/// FishSymbol icon component (compatibility wrapper)
#[component]
pub fn FishSymbol(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FishSymbol class=class /> }
}

/// Flag icon component (compatibility wrapper)
#[component]
pub fn Flag(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Flag class=class /> }
}

/// FlagOff icon component (compatibility wrapper)
#[component]
pub fn FlagOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlagOff class=class /> }
}

/// FlagTriangleLeft icon component (compatibility wrapper)
#[component]
pub fn FlagTriangleLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlagTriangleLeft class=class /> }
}

/// FlagTriangleRight icon component (compatibility wrapper)
#[component]
pub fn FlagTriangleRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlagTriangleRight class=class /> }
}

/// Flame icon component (compatibility wrapper)
#[component]
pub fn Flame(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Flame class=class /> }
}

/// FlameKindling icon component (compatibility wrapper)
#[component]
pub fn FlameKindling(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlameKindling class=class /> }
}

/// Flashlight icon component (compatibility wrapper)
#[component]
pub fn Flashlight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Flashlight class=class /> }
}

/// FlashlightOff icon component (compatibility wrapper)
#[component]
pub fn FlashlightOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlashlightOff class=class /> }
}

/// FlaskConical icon component (compatibility wrapper)
#[component]
pub fn FlaskConical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlaskConical class=class /> }
}

/// FlaskConicalOff icon component (compatibility wrapper)
#[component]
pub fn FlaskConicalOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlaskConicalOff class=class /> }
}

/// FlaskRound icon component (compatibility wrapper)
#[component]
pub fn FlaskRound(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlaskRound class=class /> }
}

/// FlipHorizontal icon component (compatibility wrapper)
#[component]
pub fn FlipHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlipHorizontal class=class /> }
}

/// FlipHorizontal2 icon component (compatibility wrapper)
#[component]
pub fn FlipHorizontal2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlipHorizontal2 class=class /> }
}

/// FlipVertical icon component (compatibility wrapper)
#[component]
pub fn FlipVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlipVertical class=class /> }
}

/// FlipVertical2 icon component (compatibility wrapper)
#[component]
pub fn FlipVertical2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FlipVertical2 class=class /> }
}

/// Flower icon component (compatibility wrapper)
#[component]
pub fn Flower(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Flower class=class /> }
}

/// Flower2 icon component (compatibility wrapper)
#[component]
pub fn Flower2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Flower2 class=class /> }
}

/// Focus icon component (compatibility wrapper)
#[component]
pub fn Focus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Focus class=class /> }
}

/// FoldHorizontal icon component (compatibility wrapper)
#[component]
pub fn FoldHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FoldHorizontal class=class /> }
}

/// FoldVertical icon component (compatibility wrapper)
#[component]
pub fn FoldVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FoldVertical class=class /> }
}

/// Folder icon component (compatibility wrapper)
#[component]
pub fn Folder(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Folder class=class /> }
}

/// FolderArchive icon component (compatibility wrapper)
#[component]
pub fn FolderArchive(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderArchive class=class /> }
}

/// FolderCheck icon component (compatibility wrapper)
#[component]
pub fn FolderCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderCheck class=class /> }
}

/// FolderClock icon component (compatibility wrapper)
#[component]
pub fn FolderClock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderClock class=class /> }
}

/// FolderClosed icon component (compatibility wrapper)
#[component]
pub fn FolderClosed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderClosed class=class /> }
}

/// FolderCode icon component (compatibility wrapper)
#[component]
pub fn FolderCode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderCode class=class /> }
}

/// FolderCog icon component (compatibility wrapper)
#[component]
pub fn FolderCog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderCog class=class /> }
}

/// FolderDot icon component (compatibility wrapper)
#[component]
pub fn FolderDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderDot class=class /> }
}

/// FolderDown icon component (compatibility wrapper)
#[component]
pub fn FolderDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderDown class=class /> }
}

/// FolderGit icon component (compatibility wrapper)
#[component]
pub fn FolderGit(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderGit class=class /> }
}

/// FolderGit2 icon component (compatibility wrapper)
#[component]
pub fn FolderGit2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderGit2 class=class /> }
}

/// FolderHeart icon component (compatibility wrapper)
#[component]
pub fn FolderHeart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderHeart class=class /> }
}

/// FolderInput icon component (compatibility wrapper)
#[component]
pub fn FolderInput(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderInput class=class /> }
}

/// FolderKanban icon component (compatibility wrapper)
#[component]
pub fn FolderKanban(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderKanban class=class /> }
}

/// FolderKey icon component (compatibility wrapper)
#[component]
pub fn FolderKey(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderKey class=class /> }
}

/// FolderLock icon component (compatibility wrapper)
#[component]
pub fn FolderLock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderLock class=class /> }
}

/// FolderMinus icon component (compatibility wrapper)
#[component]
pub fn FolderMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderMinus class=class /> }
}

/// FolderOpen icon component (compatibility wrapper)
#[component]
pub fn FolderOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderOpen class=class /> }
}

/// FolderOpenDot icon component (compatibility wrapper)
#[component]
pub fn FolderOpenDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderOpenDot class=class /> }
}

/// FolderOutput icon component (compatibility wrapper)
#[component]
pub fn FolderOutput(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderOutput class=class /> }
}

/// FolderPen icon component (compatibility wrapper)
#[component]
pub fn FolderPen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderPen class=class /> }
}

/// FolderPlus icon component (compatibility wrapper)
#[component]
pub fn FolderPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderPlus class=class /> }
}

/// FolderRoot icon component (compatibility wrapper)
#[component]
pub fn FolderRoot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderRoot class=class /> }
}

/// FolderSearch icon component (compatibility wrapper)
#[component]
pub fn FolderSearch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderSearch class=class /> }
}

/// FolderSearch2 icon component (compatibility wrapper)
#[component]
pub fn FolderSearch2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderSearch2 class=class /> }
}

/// FolderSymlink icon component (compatibility wrapper)
#[component]
pub fn FolderSymlink(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderSymlink class=class /> }
}

/// FolderSync icon component (compatibility wrapper)
#[component]
pub fn FolderSync(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderSync class=class /> }
}

/// FolderTree icon component (compatibility wrapper)
#[component]
pub fn FolderTree(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderTree class=class /> }
}

/// FolderUp icon component (compatibility wrapper)
#[component]
pub fn FolderUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderUp class=class /> }
}

/// FolderX icon component (compatibility wrapper)
#[component]
pub fn FolderX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FolderX class=class /> }
}

/// Folders icon component (compatibility wrapper)
#[component]
pub fn Folders(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Folders class=class /> }
}

/// Footprints icon component (compatibility wrapper)
#[component]
pub fn Footprints(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Footprints class=class /> }
}

/// Forklift icon component (compatibility wrapper)
#[component]
pub fn Forklift(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Forklift class=class /> }
}

/// Forward icon component (compatibility wrapper)
#[component]
pub fn Forward(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Forward class=class /> }
}

/// Frame icon component (compatibility wrapper)
#[component]
pub fn Frame(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Frame class=class /> }
}

/// Framer icon component (compatibility wrapper)
#[component]
pub fn Framer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Framer class=class /> }
}

/// Frown icon component (compatibility wrapper)
#[component]
pub fn Frown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Frown class=class /> }
}

/// Fuel icon component (compatibility wrapper)
#[component]
pub fn Fuel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Fuel class=class /> }
}

/// Fullscreen icon component (compatibility wrapper)
#[component]
pub fn Fullscreen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Fullscreen class=class /> }
}

/// Funnel icon component (compatibility wrapper)
#[component]
pub fn Funnel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Funnel class=class /> }
}

/// FunnelPlus icon component (compatibility wrapper)
#[component]
pub fn FunnelPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FunnelPlus class=class /> }
}

/// FunnelX icon component (compatibility wrapper)
#[component]
pub fn FunnelX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::FunnelX class=class /> }
}

/// GalleryHorizontal icon component (compatibility wrapper)
#[component]
pub fn GalleryHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GalleryHorizontal class=class /> }
}

/// GalleryHorizontalEnd icon component (compatibility wrapper)
#[component]
pub fn GalleryHorizontalEnd(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GalleryHorizontalEnd class=class /> }
}

/// GalleryThumbnails icon component (compatibility wrapper)
#[component]
pub fn GalleryThumbnails(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GalleryThumbnails class=class /> }
}

/// GalleryVertical icon component (compatibility wrapper)
#[component]
pub fn GalleryVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GalleryVertical class=class /> }
}

/// GalleryVerticalEnd icon component (compatibility wrapper)
#[component]
pub fn GalleryVerticalEnd(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GalleryVerticalEnd class=class /> }
}

/// Gamepad icon component (compatibility wrapper)
#[component]
pub fn Gamepad(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Gamepad class=class /> }
}

/// Gamepad2 icon component (compatibility wrapper)
#[component]
pub fn Gamepad2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Gamepad2 class=class /> }
}

/// Gauge icon component (compatibility wrapper)
#[component]
pub fn Gauge(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Gauge class=class /> }
}

/// Gavel icon component (compatibility wrapper)
#[component]
pub fn Gavel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Gavel class=class /> }
}

/// Gem icon component (compatibility wrapper)
#[component]
pub fn Gem(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Gem class=class /> }
}

/// GeorgianLari icon component (compatibility wrapper)
#[component]
pub fn GeorgianLari(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GeorgianLari class=class /> }
}

/// Ghost icon component (compatibility wrapper)
#[component]
pub fn Ghost(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ghost class=class /> }
}

/// Gift icon component (compatibility wrapper)
#[component]
pub fn Gift(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Gift class=class /> }
}

/// GitBranch icon component (compatibility wrapper)
#[component]
pub fn GitBranch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitBranch class=class /> }
}

/// GitBranchPlus icon component (compatibility wrapper)
#[component]
pub fn GitBranchPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitBranchPlus class=class /> }
}

/// GitCommitHorizontal icon component (compatibility wrapper)
#[component]
pub fn GitCommitHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitCommitHorizontal class=class /> }
}

/// GitCommitVertical icon component (compatibility wrapper)
#[component]
pub fn GitCommitVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitCommitVertical class=class /> }
}

/// GitCompare icon component (compatibility wrapper)
#[component]
pub fn GitCompare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitCompare class=class /> }
}

/// GitCompareArrows icon component (compatibility wrapper)
#[component]
pub fn GitCompareArrows(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitCompareArrows class=class /> }
}

/// GitFork icon component (compatibility wrapper)
#[component]
pub fn GitFork(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitFork class=class /> }
}

/// GitGraph icon component (compatibility wrapper)
#[component]
pub fn GitGraph(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitGraph class=class /> }
}

/// GitMerge icon component (compatibility wrapper)
#[component]
pub fn GitMerge(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitMerge class=class /> }
}

/// GitPullRequest icon component (compatibility wrapper)
#[component]
pub fn GitPullRequest(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitPullRequest class=class /> }
}

/// GitPullRequestArrow icon component (compatibility wrapper)
#[component]
pub fn GitPullRequestArrow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitPullRequestArrow class=class /> }
}

/// GitPullRequestClosed icon component (compatibility wrapper)
#[component]
pub fn GitPullRequestClosed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitPullRequestClosed class=class /> }
}

/// GitPullRequestCreate icon component (compatibility wrapper)
#[component]
pub fn GitPullRequestCreate(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitPullRequestCreate class=class /> }
}

/// GitPullRequestCreateArrow icon component (compatibility wrapper)
#[component]
pub fn GitPullRequestCreateArrow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitPullRequestCreateArrow class=class /> }
}

/// GitPullRequestDraft icon component (compatibility wrapper)
#[component]
pub fn GitPullRequestDraft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GitPullRequestDraft class=class /> }
}

/// Github icon component (compatibility wrapper)
#[component]
pub fn Github(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Github class=class /> }
}

/// Gitlab icon component (compatibility wrapper)
#[component]
pub fn Gitlab(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Gitlab class=class /> }
}

/// GlassWater icon component (compatibility wrapper)
#[component]
pub fn GlassWater(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GlassWater class=class /> }
}

/// Glasses icon component (compatibility wrapper)
#[component]
pub fn Glasses(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Glasses class=class /> }
}

/// Globe icon component (compatibility wrapper)
#[component]
pub fn Globe(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Globe class=class /> }
}

/// GlobeLock icon component (compatibility wrapper)
#[component]
pub fn GlobeLock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GlobeLock class=class /> }
}

/// Goal icon component (compatibility wrapper)
#[component]
pub fn Goal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Goal class=class /> }
}

/// Gpu icon component (compatibility wrapper)
#[component]
pub fn Gpu(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Gpu class=class /> }
}

/// Grab icon component (compatibility wrapper)
#[component]
pub fn Grab(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Grab class=class /> }
}

/// GraduationCap icon component (compatibility wrapper)
#[component]
pub fn GraduationCap(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GraduationCap class=class /> }
}

/// Grape icon component (compatibility wrapper)
#[component]
pub fn Grape(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Grape class=class /> }
}

/// Grid2X2 icon component (compatibility wrapper)
#[component]
pub fn Grid2X2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Grid2X2 class=class /> }
}

/// Grid2X2Check icon component (compatibility wrapper)
#[component]
pub fn Grid2X2Check(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Grid2X2Check class=class /> }
}

/// Grid2X2Plus icon component (compatibility wrapper)
#[component]
pub fn Grid2X2Plus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Grid2X2Plus class=class /> }
}

/// Grid2X2X icon component (compatibility wrapper)
#[component]
pub fn Grid2X2X(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Grid2X2X class=class /> }
}

/// Grid3X2 icon component (compatibility wrapper)
#[component]
pub fn Grid3X2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Grid3X2 class=class /> }
}

/// Grid3X3 icon component (compatibility wrapper)
#[component]
pub fn Grid3X3(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Grid3X3 class=class /> }
}

/// Grip icon component (compatibility wrapper)
#[component]
pub fn Grip(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Grip class=class /> }
}

/// GripHorizontal icon component (compatibility wrapper)
#[component]
pub fn GripHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GripHorizontal class=class /> }
}

/// GripVertical icon component (compatibility wrapper)
#[component]
pub fn GripVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::GripVertical class=class /> }
}

/// Group icon component (compatibility wrapper)
#[component]
pub fn Group(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Group class=class /> }
}

/// Guitar icon component (compatibility wrapper)
#[component]
pub fn Guitar(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Guitar class=class /> }
}

/// Ham icon component (compatibility wrapper)
#[component]
pub fn Ham(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ham class=class /> }
}

/// Hamburger icon component (compatibility wrapper)
#[component]
pub fn Hamburger(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Hamburger class=class /> }
}

/// Hammer icon component (compatibility wrapper)
#[component]
pub fn Hammer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Hammer class=class /> }
}

/// Hand icon component (compatibility wrapper)
#[component]
pub fn Hand(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Hand class=class /> }
}

/// HandCoins icon component (compatibility wrapper)
#[component]
pub fn HandCoins(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HandCoins class=class /> }
}

/// HandHeart icon component (compatibility wrapper)
#[component]
pub fn HandHeart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HandHeart class=class /> }
}

/// HandHelping icon component (compatibility wrapper)
#[component]
pub fn HandHelping(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HandHelping class=class /> }
}

/// HandMetal icon component (compatibility wrapper)
#[component]
pub fn HandMetal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HandMetal class=class /> }
}

/// HandPlatter icon component (compatibility wrapper)
#[component]
pub fn HandPlatter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HandPlatter class=class /> }
}

/// Handbag icon component (compatibility wrapper)
#[component]
pub fn Handbag(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Handbag class=class /> }
}

/// Handshake icon component (compatibility wrapper)
#[component]
pub fn Handshake(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Handshake class=class /> }
}

/// HardDrive icon component (compatibility wrapper)
#[component]
pub fn HardDrive(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HardDrive class=class /> }
}

/// HardDriveDownload icon component (compatibility wrapper)
#[component]
pub fn HardDriveDownload(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HardDriveDownload class=class /> }
}

/// HardDriveUpload icon component (compatibility wrapper)
#[component]
pub fn HardDriveUpload(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HardDriveUpload class=class /> }
}

/// HardHat icon component (compatibility wrapper)
#[component]
pub fn HardHat(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HardHat class=class /> }
}

/// Hash icon component (compatibility wrapper)
#[component]
pub fn Hash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Hash class=class /> }
}

/// HatGlasses icon component (compatibility wrapper)
#[component]
pub fn HatGlasses(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HatGlasses class=class /> }
}

/// Haze icon component (compatibility wrapper)
#[component]
pub fn Haze(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Haze class=class /> }
}

/// HdmiPort icon component (compatibility wrapper)
#[component]
pub fn HdmiPort(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HdmiPort class=class /> }
}

/// Heading icon component (compatibility wrapper)
#[component]
pub fn Heading(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Heading class=class /> }
}

/// Heading1 icon component (compatibility wrapper)
#[component]
pub fn Heading1(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Heading1 class=class /> }
}

/// Heading2 icon component (compatibility wrapper)
#[component]
pub fn Heading2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Heading2 class=class /> }
}

/// Heading3 icon component (compatibility wrapper)
#[component]
pub fn Heading3(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Heading3 class=class /> }
}

/// Heading4 icon component (compatibility wrapper)
#[component]
pub fn Heading4(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Heading4 class=class /> }
}

/// Heading5 icon component (compatibility wrapper)
#[component]
pub fn Heading5(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Heading5 class=class /> }
}

/// Heading6 icon component (compatibility wrapper)
#[component]
pub fn Heading6(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Heading6 class=class /> }
}

/// HeadphoneOff icon component (compatibility wrapper)
#[component]
pub fn HeadphoneOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HeadphoneOff class=class /> }
}

/// Headphones icon component (compatibility wrapper)
#[component]
pub fn Headphones(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Headphones class=class /> }
}

/// Headset icon component (compatibility wrapper)
#[component]
pub fn Headset(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Headset class=class /> }
}

/// Heart icon component (compatibility wrapper)
#[component]
pub fn Heart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Heart class=class /> }
}

/// HeartCrack icon component (compatibility wrapper)
#[component]
pub fn HeartCrack(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HeartCrack class=class /> }
}

/// HeartHandshake icon component (compatibility wrapper)
#[component]
pub fn HeartHandshake(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HeartHandshake class=class /> }
}

/// HeartMinus icon component (compatibility wrapper)
#[component]
pub fn HeartMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HeartMinus class=class /> }
}

/// HeartOff icon component (compatibility wrapper)
#[component]
pub fn HeartOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HeartOff class=class /> }
}

/// HeartPlus icon component (compatibility wrapper)
#[component]
pub fn HeartPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HeartPlus class=class /> }
}

/// HeartPulse icon component (compatibility wrapper)
#[component]
pub fn HeartPulse(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HeartPulse class=class /> }
}

/// Heater icon component (compatibility wrapper)
#[component]
pub fn Heater(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Heater class=class /> }
}

/// Hexagon icon component (compatibility wrapper)
#[component]
pub fn Hexagon(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Hexagon class=class /> }
}

/// Highlighter icon component (compatibility wrapper)
#[component]
pub fn Highlighter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Highlighter class=class /> }
}

/// History icon component (compatibility wrapper)
#[component]
pub fn History(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::History class=class /> }
}

/// Hop icon component (compatibility wrapper)
#[component]
pub fn Hop(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Hop class=class /> }
}

/// HopOff icon component (compatibility wrapper)
#[component]
pub fn HopOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HopOff class=class /> }
}

/// Hospital icon component (compatibility wrapper)
#[component]
pub fn Hospital(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Hospital class=class /> }
}

/// Hotel icon component (compatibility wrapper)
#[component]
pub fn Hotel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Hotel class=class /> }
}

/// Hourglass icon component (compatibility wrapper)
#[component]
pub fn Hourglass(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Hourglass class=class /> }
}

/// House icon component (compatibility wrapper)
#[component]
pub fn House(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::House class=class /> }
}

/// HousePlug icon component (compatibility wrapper)
#[component]
pub fn HousePlug(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HousePlug class=class /> }
}

/// HousePlus icon component (compatibility wrapper)
#[component]
pub fn HousePlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HousePlus class=class /> }
}

/// HouseWifi icon component (compatibility wrapper)
#[component]
pub fn HouseWifi(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::HouseWifi class=class /> }
}

/// IceCreamBowl icon component (compatibility wrapper)
#[component]
pub fn IceCreamBowl(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::IceCreamBowl class=class /> }
}

/// IceCreamCone icon component (compatibility wrapper)
#[component]
pub fn IceCreamCone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::IceCreamCone class=class /> }
}

/// IdCard icon component (compatibility wrapper)
#[component]
pub fn IdCard(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::IdCard class=class /> }
}

/// IdCardLanyard icon component (compatibility wrapper)
#[component]
pub fn IdCardLanyard(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::IdCardLanyard class=class /> }
}

/// Image icon component (compatibility wrapper)
#[component]
pub fn Image(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Image class=class /> }
}

/// ImageDown icon component (compatibility wrapper)
#[component]
pub fn ImageDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ImageDown class=class /> }
}

/// ImageMinus icon component (compatibility wrapper)
#[component]
pub fn ImageMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ImageMinus class=class /> }
}

/// ImageOff icon component (compatibility wrapper)
#[component]
pub fn ImageOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ImageOff class=class /> }
}

/// ImagePlay icon component (compatibility wrapper)
#[component]
pub fn ImagePlay(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ImagePlay class=class /> }
}

/// ImagePlus icon component (compatibility wrapper)
#[component]
pub fn ImagePlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ImagePlus class=class /> }
}

/// ImageUp icon component (compatibility wrapper)
#[component]
pub fn ImageUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ImageUp class=class /> }
}

/// ImageUpscale icon component (compatibility wrapper)
#[component]
pub fn ImageUpscale(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ImageUpscale class=class /> }
}

/// Images icon component (compatibility wrapper)
#[component]
pub fn Images(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Images class=class /> }
}

/// Import icon component (compatibility wrapper)
#[component]
pub fn Import(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Import class=class /> }
}

/// Inbox icon component (compatibility wrapper)
#[component]
pub fn Inbox(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Inbox class=class /> }
}

/// IndentDecrease icon component (compatibility wrapper)
#[component]
pub fn IndentDecrease(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::IndentDecrease class=class /> }
}

/// IndentIncrease icon component (compatibility wrapper)
#[component]
pub fn IndentIncrease(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::IndentIncrease class=class /> }
}

/// IndianRupee icon component (compatibility wrapper)
#[component]
pub fn IndianRupee(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::IndianRupee class=class /> }
}

/// Infinity icon component (compatibility wrapper)
#[component]
pub fn Infinity(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Infinity class=class /> }
}

/// Info icon component (compatibility wrapper)
#[component]
pub fn Info(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Info class=class /> }
}

/// InspectionPanel icon component (compatibility wrapper)
#[component]
pub fn InspectionPanel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::InspectionPanel class=class /> }
}

/// Instagram icon component (compatibility wrapper)
#[component]
pub fn Instagram(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Instagram class=class /> }
}

/// Italic icon component (compatibility wrapper)
#[component]
pub fn Italic(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Italic class=class /> }
}

/// IterationCcw icon component (compatibility wrapper)
#[component]
pub fn IterationCcw(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::IterationCcw class=class /> }
}

/// IterationCw icon component (compatibility wrapper)
#[component]
pub fn IterationCw(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::IterationCw class=class /> }
}

/// JapaneseYen icon component (compatibility wrapper)
#[component]
pub fn JapaneseYen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::JapaneseYen class=class /> }
}

/// Joystick icon component (compatibility wrapper)
#[component]
pub fn Joystick(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Joystick class=class /> }
}

/// Kanban icon component (compatibility wrapper)
#[component]
pub fn Kanban(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Kanban class=class /> }
}

/// Key icon component (compatibility wrapper)
#[component]
pub fn Key(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Key class=class /> }
}

/// KeyRound icon component (compatibility wrapper)
#[component]
pub fn KeyRound(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::KeyRound class=class /> }
}

/// KeySquare icon component (compatibility wrapper)
#[component]
pub fn KeySquare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::KeySquare class=class /> }
}

/// Keyboard icon component (compatibility wrapper)
#[component]
pub fn Keyboard(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Keyboard class=class /> }
}

/// KeyboardMusic icon component (compatibility wrapper)
#[component]
pub fn KeyboardMusic(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::KeyboardMusic class=class /> }
}

/// KeyboardOff icon component (compatibility wrapper)
#[component]
pub fn KeyboardOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::KeyboardOff class=class /> }
}

/// Lamp icon component (compatibility wrapper)
#[component]
pub fn Lamp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Lamp class=class /> }
}

/// LampCeiling icon component (compatibility wrapper)
#[component]
pub fn LampCeiling(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LampCeiling class=class /> }
}

/// LampDesk icon component (compatibility wrapper)
#[component]
pub fn LampDesk(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LampDesk class=class /> }
}

/// LampFloor icon component (compatibility wrapper)
#[component]
pub fn LampFloor(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LampFloor class=class /> }
}

/// LampWallDown icon component (compatibility wrapper)
#[component]
pub fn LampWallDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LampWallDown class=class /> }
}

/// LampWallUp icon component (compatibility wrapper)
#[component]
pub fn LampWallUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LampWallUp class=class /> }
}

/// LandPlot icon component (compatibility wrapper)
#[component]
pub fn LandPlot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LandPlot class=class /> }
}

/// Landmark icon component (compatibility wrapper)
#[component]
pub fn Landmark(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Landmark class=class /> }
}

/// Languages icon component (compatibility wrapper)
#[component]
pub fn Languages(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Languages class=class /> }
}

/// Laptop icon component (compatibility wrapper)
#[component]
pub fn Laptop(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Laptop class=class /> }
}

/// LaptopMinimal icon component (compatibility wrapper)
#[component]
pub fn LaptopMinimal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LaptopMinimal class=class /> }
}

/// LaptopMinimalCheck icon component (compatibility wrapper)
#[component]
pub fn LaptopMinimalCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LaptopMinimalCheck class=class /> }
}

/// Lasso icon component (compatibility wrapper)
#[component]
pub fn Lasso(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Lasso class=class /> }
}

/// LassoSelect icon component (compatibility wrapper)
#[component]
pub fn LassoSelect(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LassoSelect class=class /> }
}

/// Laugh icon component (compatibility wrapper)
#[component]
pub fn Laugh(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Laugh class=class /> }
}

/// Layers icon component (compatibility wrapper)
#[component]
pub fn Layers(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Layers class=class /> }
}

/// Layers2 icon component (compatibility wrapper)
#[component]
pub fn Layers2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Layers2 class=class /> }
}

/// Layers3 icon component (compatibility wrapper)
#[component]
pub fn Layers3(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Layers3 class=class /> }
}

/// LayoutDashboard icon component (compatibility wrapper)
#[component]
pub fn LayoutDashboard(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LayoutDashboard class=class /> }
}

/// LayoutGrid icon component (compatibility wrapper)
#[component]
pub fn LayoutGrid(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LayoutGrid class=class /> }
}

/// LayoutList icon component (compatibility wrapper)
#[component]
pub fn LayoutList(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LayoutList class=class /> }
}

/// LayoutPanelLeft icon component (compatibility wrapper)
#[component]
pub fn LayoutPanelLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LayoutPanelLeft class=class /> }
}

/// LayoutPanelTop icon component (compatibility wrapper)
#[component]
pub fn LayoutPanelTop(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LayoutPanelTop class=class /> }
}

/// LayoutTemplate icon component (compatibility wrapper)
#[component]
pub fn LayoutTemplate(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LayoutTemplate class=class /> }
}

/// Leaf icon component (compatibility wrapper)
#[component]
pub fn Leaf(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Leaf class=class /> }
}

/// LeafyGreen icon component (compatibility wrapper)
#[component]
pub fn LeafyGreen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LeafyGreen class=class /> }
}

/// Lectern icon component (compatibility wrapper)
#[component]
pub fn Lectern(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Lectern class=class /> }
}

/// LetterText icon component (compatibility wrapper)
#[component]
pub fn LetterText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LetterText class=class /> }
}

/// Library icon component (compatibility wrapper)
#[component]
pub fn Library(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Library class=class /> }
}

/// LibraryBig icon component (compatibility wrapper)
#[component]
pub fn LibraryBig(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LibraryBig class=class /> }
}

/// LifeBuoy icon component (compatibility wrapper)
#[component]
pub fn LifeBuoy(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LifeBuoy class=class /> }
}

/// Ligature icon component (compatibility wrapper)
#[component]
pub fn Ligature(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ligature class=class /> }
}

/// Lightbulb icon component (compatibility wrapper)
#[component]
pub fn Lightbulb(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Lightbulb class=class /> }
}

/// LightbulbOff icon component (compatibility wrapper)
#[component]
pub fn LightbulbOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LightbulbOff class=class /> }
}

/// LineSquiggle icon component (compatibility wrapper)
#[component]
pub fn LineSquiggle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LineSquiggle class=class /> }
}

/// Link icon component (compatibility wrapper)
#[component]
pub fn Link(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Link class=class /> }
}

/// Link2 icon component (compatibility wrapper)
#[component]
pub fn Link2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Link2 class=class /> }
}

/// Link2Off icon component (compatibility wrapper)
#[component]
pub fn Link2Off(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Link2Off class=class /> }
}

/// Linkedin icon component (compatibility wrapper)
#[component]
pub fn Linkedin(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Linkedin class=class /> }
}

/// List icon component (compatibility wrapper)
#[component]
pub fn List(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::List class=class /> }
}

/// ListCheck icon component (compatibility wrapper)
#[component]
pub fn ListCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListCheck class=class /> }
}

/// ListChecks icon component (compatibility wrapper)
#[component]
pub fn ListChecks(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListChecks class=class /> }
}

/// ListCollapse icon component (compatibility wrapper)
#[component]
pub fn ListCollapse(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListCollapse class=class /> }
}

/// ListEnd icon component (compatibility wrapper)
#[component]
pub fn ListEnd(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListEnd class=class /> }
}

/// ListFilter icon component (compatibility wrapper)
#[component]
pub fn ListFilter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListFilter class=class /> }
}

/// ListFilterPlus icon component (compatibility wrapper)
#[component]
pub fn ListFilterPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListFilterPlus class=class /> }
}

/// ListMinus icon component (compatibility wrapper)
#[component]
pub fn ListMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListMinus class=class /> }
}

/// ListMusic icon component (compatibility wrapper)
#[component]
pub fn ListMusic(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListMusic class=class /> }
}

/// ListOrdered icon component (compatibility wrapper)
#[component]
pub fn ListOrdered(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListOrdered class=class /> }
}

/// ListPlus icon component (compatibility wrapper)
#[component]
pub fn ListPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListPlus class=class /> }
}

/// ListRestart icon component (compatibility wrapper)
#[component]
pub fn ListRestart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListRestart class=class /> }
}

/// ListStart icon component (compatibility wrapper)
#[component]
pub fn ListStart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListStart class=class /> }
}

/// ListTodo icon component (compatibility wrapper)
#[component]
pub fn ListTodo(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListTodo class=class /> }
}

/// ListTree icon component (compatibility wrapper)
#[component]
pub fn ListTree(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListTree class=class /> }
}

/// ListVideo icon component (compatibility wrapper)
#[component]
pub fn ListVideo(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListVideo class=class /> }
}

/// ListX icon component (compatibility wrapper)
#[component]
pub fn ListX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ListX class=class /> }
}

/// Loader icon component (compatibility wrapper)
#[component]
pub fn Loader(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Loader class=class /> }
}

/// LoaderCircle icon component (compatibility wrapper)
#[component]
pub fn LoaderCircle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LoaderCircle class=class /> }
}

/// LoaderPinwheel icon component (compatibility wrapper)
#[component]
pub fn LoaderPinwheel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LoaderPinwheel class=class /> }
}

/// Locate icon component (compatibility wrapper)
#[component]
pub fn Locate(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Locate class=class /> }
}

/// LocateFixed icon component (compatibility wrapper)
#[component]
pub fn LocateFixed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LocateFixed class=class /> }
}

/// LocateOff icon component (compatibility wrapper)
#[component]
pub fn LocateOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LocateOff class=class /> }
}

/// LocationEdit icon component (compatibility wrapper)
#[component]
pub fn LocationEdit(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LocationEdit class=class /> }
}

/// Lock icon component (compatibility wrapper)
#[component]
pub fn Lock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Lock class=class /> }
}

/// LockKeyhole icon component (compatibility wrapper)
#[component]
pub fn LockKeyhole(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LockKeyhole class=class /> }
}

/// LockKeyholeOpen icon component (compatibility wrapper)
#[component]
pub fn LockKeyholeOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LockKeyholeOpen class=class /> }
}

/// LockOpen icon component (compatibility wrapper)
#[component]
pub fn LockOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LockOpen class=class /> }
}

/// LogIn icon component (compatibility wrapper)
#[component]
pub fn LogIn(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LogIn class=class /> }
}

/// LogOut icon component (compatibility wrapper)
#[component]
pub fn LogOut(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::LogOut class=class /> }
}

/// Logs icon component (compatibility wrapper)
#[component]
pub fn Logs(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Logs class=class /> }
}

/// Lollipop icon component (compatibility wrapper)
#[component]
pub fn Lollipop(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Lollipop class=class /> }
}

/// Luggage icon component (compatibility wrapper)
#[component]
pub fn Luggage(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Luggage class=class /> }
}

/// Magnet icon component (compatibility wrapper)
#[component]
pub fn Magnet(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Magnet class=class /> }
}

/// Mail icon component (compatibility wrapper)
#[component]
pub fn Mail(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Mail class=class /> }
}

/// MailCheck icon component (compatibility wrapper)
#[component]
pub fn MailCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MailCheck class=class /> }
}

/// MailMinus icon component (compatibility wrapper)
#[component]
pub fn MailMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MailMinus class=class /> }
}

/// MailOpen icon component (compatibility wrapper)
#[component]
pub fn MailOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MailOpen class=class /> }
}

/// MailPlus icon component (compatibility wrapper)
#[component]
pub fn MailPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MailPlus class=class /> }
}

/// MailQuestion icon component (compatibility wrapper)
#[component]
pub fn MailQuestion(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MailQuestion class=class /> }
}

/// MailQuestionMark icon component (compatibility wrapper)
#[component]
pub fn MailQuestionMark(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MailQuestionMark class=class /> }
}

/// MailSearch icon component (compatibility wrapper)
#[component]
pub fn MailSearch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MailSearch class=class /> }
}

/// MailWarning icon component (compatibility wrapper)
#[component]
pub fn MailWarning(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MailWarning class=class /> }
}

/// MailX icon component (compatibility wrapper)
#[component]
pub fn MailX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MailX class=class /> }
}

/// Mailbox icon component (compatibility wrapper)
#[component]
pub fn Mailbox(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Mailbox class=class /> }
}

/// Mails icon component (compatibility wrapper)
#[component]
pub fn Mails(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Mails class=class /> }
}

/// Map icon component (compatibility wrapper)
#[component]
pub fn Map(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Map class=class /> }
}

/// MapMinus icon component (compatibility wrapper)
#[component]
pub fn MapMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapMinus class=class /> }
}

/// MapPin icon component (compatibility wrapper)
#[component]
pub fn MapPin(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPin class=class /> }
}

/// MapPinCheck icon component (compatibility wrapper)
#[component]
pub fn MapPinCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinCheck class=class /> }
}

/// MapPinCheckInside icon component (compatibility wrapper)
#[component]
pub fn MapPinCheckInside(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinCheckInside class=class /> }
}

/// MapPinHouse icon component (compatibility wrapper)
#[component]
pub fn MapPinHouse(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinHouse class=class /> }
}

/// MapPinMinus icon component (compatibility wrapper)
#[component]
pub fn MapPinMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinMinus class=class /> }
}

/// MapPinMinusInside icon component (compatibility wrapper)
#[component]
pub fn MapPinMinusInside(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinMinusInside class=class /> }
}

/// MapPinOff icon component (compatibility wrapper)
#[component]
pub fn MapPinOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinOff class=class /> }
}

/// MapPinPen icon component (compatibility wrapper)
#[component]
pub fn MapPinPen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinPen class=class /> }
}

/// MapPinPlus icon component (compatibility wrapper)
#[component]
pub fn MapPinPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinPlus class=class /> }
}

/// MapPinPlusInside icon component (compatibility wrapper)
#[component]
pub fn MapPinPlusInside(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinPlusInside class=class /> }
}

/// MapPinX icon component (compatibility wrapper)
#[component]
pub fn MapPinX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinX class=class /> }
}

/// MapPinXInside icon component (compatibility wrapper)
#[component]
pub fn MapPinXInside(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinXInside class=class /> }
}

/// MapPinned icon component (compatibility wrapper)
#[component]
pub fn MapPinned(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPinned class=class /> }
}

/// MapPlus icon component (compatibility wrapper)
#[component]
pub fn MapPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MapPlus class=class /> }
}

/// Mars icon component (compatibility wrapper)
#[component]
pub fn Mars(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Mars class=class /> }
}

/// MarsStroke icon component (compatibility wrapper)
#[component]
pub fn MarsStroke(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MarsStroke class=class /> }
}

/// Martini icon component (compatibility wrapper)
#[component]
pub fn Martini(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Martini class=class /> }
}

/// Maximize icon component (compatibility wrapper)
#[component]
pub fn Maximize(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Maximize class=class /> }
}

/// Maximize2 icon component (compatibility wrapper)
#[component]
pub fn Maximize2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Maximize2 class=class /> }
}

/// Medal icon component (compatibility wrapper)
#[component]
pub fn Medal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Medal class=class /> }
}

/// Megaphone icon component (compatibility wrapper)
#[component]
pub fn Megaphone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Megaphone class=class /> }
}

/// MegaphoneOff icon component (compatibility wrapper)
#[component]
pub fn MegaphoneOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MegaphoneOff class=class /> }
}

/// Meh icon component (compatibility wrapper)
#[component]
pub fn Meh(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Meh class=class /> }
}

/// MemoryStick icon component (compatibility wrapper)
#[component]
pub fn MemoryStick(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MemoryStick class=class /> }
}

/// Menu icon component (compatibility wrapper)
#[component]
pub fn Menu(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Menu class=class /> }
}

/// Merge icon component (compatibility wrapper)
#[component]
pub fn Merge(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Merge class=class /> }
}

/// MessageCircle icon component (compatibility wrapper)
#[component]
pub fn MessageCircle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircle class=class /> }
}

/// MessageCircleCode icon component (compatibility wrapper)
#[component]
pub fn MessageCircleCode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircleCode class=class /> }
}

/// MessageCircleDashed icon component (compatibility wrapper)
#[component]
pub fn MessageCircleDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircleDashed class=class /> }
}

/// MessageCircleHeart icon component (compatibility wrapper)
#[component]
pub fn MessageCircleHeart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircleHeart class=class /> }
}

/// MessageCircleMore icon component (compatibility wrapper)
#[component]
pub fn MessageCircleMore(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircleMore class=class /> }
}

/// MessageCircleOff icon component (compatibility wrapper)
#[component]
pub fn MessageCircleOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircleOff class=class /> }
}

/// MessageCirclePlus icon component (compatibility wrapper)
#[component]
pub fn MessageCirclePlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCirclePlus class=class /> }
}

/// MessageCircleQuestion icon component (compatibility wrapper)
#[component]
pub fn MessageCircleQuestion(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircleQuestion class=class /> }
}

/// MessageCircleQuestionMark icon component (compatibility wrapper)
#[component]
pub fn MessageCircleQuestionMark(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircleQuestionMark class=class /> }
}

/// MessageCircleReply icon component (compatibility wrapper)
#[component]
pub fn MessageCircleReply(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircleReply class=class /> }
}

/// MessageCircleWarning icon component (compatibility wrapper)
#[component]
pub fn MessageCircleWarning(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircleWarning class=class /> }
}

/// MessageCircleX icon component (compatibility wrapper)
#[component]
pub fn MessageCircleX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageCircleX class=class /> }
}

/// MessageSquare icon component (compatibility wrapper)
#[component]
pub fn MessageSquare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquare class=class /> }
}

/// MessageSquareCode icon component (compatibility wrapper)
#[component]
pub fn MessageSquareCode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareCode class=class /> }
}

/// MessageSquareDashed icon component (compatibility wrapper)
#[component]
pub fn MessageSquareDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareDashed class=class /> }
}

/// MessageSquareDiff icon component (compatibility wrapper)
#[component]
pub fn MessageSquareDiff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareDiff class=class /> }
}

/// MessageSquareDot icon component (compatibility wrapper)
#[component]
pub fn MessageSquareDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareDot class=class /> }
}

/// MessageSquareHeart icon component (compatibility wrapper)
#[component]
pub fn MessageSquareHeart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareHeart class=class /> }
}

/// MessageSquareLock icon component (compatibility wrapper)
#[component]
pub fn MessageSquareLock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareLock class=class /> }
}

/// MessageSquareMore icon component (compatibility wrapper)
#[component]
pub fn MessageSquareMore(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareMore class=class /> }
}

/// MessageSquareOff icon component (compatibility wrapper)
#[component]
pub fn MessageSquareOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareOff class=class /> }
}

/// MessageSquarePlus icon component (compatibility wrapper)
#[component]
pub fn MessageSquarePlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquarePlus class=class /> }
}

/// MessageSquareQuote icon component (compatibility wrapper)
#[component]
pub fn MessageSquareQuote(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareQuote class=class /> }
}

/// MessageSquareReply icon component (compatibility wrapper)
#[component]
pub fn MessageSquareReply(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareReply class=class /> }
}

/// MessageSquareShare icon component (compatibility wrapper)
#[component]
pub fn MessageSquareShare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareShare class=class /> }
}

/// MessageSquareText icon component (compatibility wrapper)
#[component]
pub fn MessageSquareText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareText class=class /> }
}

/// MessageSquareWarning icon component (compatibility wrapper)
#[component]
pub fn MessageSquareWarning(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareWarning class=class /> }
}

/// MessageSquareX icon component (compatibility wrapper)
#[component]
pub fn MessageSquareX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessageSquareX class=class /> }
}

/// MessagesSquare icon component (compatibility wrapper)
#[component]
pub fn MessagesSquare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MessagesSquare class=class /> }
}

/// Mic icon component (compatibility wrapper)
#[component]
pub fn Mic(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Mic class=class /> }
}

/// MicOff icon component (compatibility wrapper)
#[component]
pub fn MicOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MicOff class=class /> }
}

/// MicVocal icon component (compatibility wrapper)
#[component]
pub fn MicVocal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MicVocal class=class /> }
}

/// Microchip icon component (compatibility wrapper)
#[component]
pub fn Microchip(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Microchip class=class /> }
}

/// Microscope icon component (compatibility wrapper)
#[component]
pub fn Microscope(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Microscope class=class /> }
}

/// Microwave icon component (compatibility wrapper)
#[component]
pub fn Microwave(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Microwave class=class /> }
}

/// Milestone icon component (compatibility wrapper)
#[component]
pub fn Milestone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Milestone class=class /> }
}

/// Milk icon component (compatibility wrapper)
#[component]
pub fn Milk(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Milk class=class /> }
}

/// MilkOff icon component (compatibility wrapper)
#[component]
pub fn MilkOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MilkOff class=class /> }
}

/// Minimize icon component (compatibility wrapper)
#[component]
pub fn Minimize(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Minimize class=class /> }
}

/// Minimize2 icon component (compatibility wrapper)
#[component]
pub fn Minimize2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Minimize2 class=class /> }
}

/// Minus icon component (compatibility wrapper)
#[component]
pub fn Minus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Minus class=class /> }
}

/// Monitor icon component (compatibility wrapper)
#[component]
pub fn Monitor(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Monitor class=class /> }
}

/// MonitorCheck icon component (compatibility wrapper)
#[component]
pub fn MonitorCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorCheck class=class /> }
}

/// MonitorCog icon component (compatibility wrapper)
#[component]
pub fn MonitorCog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorCog class=class /> }
}

/// MonitorDot icon component (compatibility wrapper)
#[component]
pub fn MonitorDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorDot class=class /> }
}

/// MonitorDown icon component (compatibility wrapper)
#[component]
pub fn MonitorDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorDown class=class /> }
}

/// MonitorOff icon component (compatibility wrapper)
#[component]
pub fn MonitorOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorOff class=class /> }
}

/// MonitorPause icon component (compatibility wrapper)
#[component]
pub fn MonitorPause(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorPause class=class /> }
}

/// MonitorPlay icon component (compatibility wrapper)
#[component]
pub fn MonitorPlay(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorPlay class=class /> }
}

/// MonitorSmartphone icon component (compatibility wrapper)
#[component]
pub fn MonitorSmartphone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorSmartphone class=class /> }
}

/// MonitorSpeaker icon component (compatibility wrapper)
#[component]
pub fn MonitorSpeaker(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorSpeaker class=class /> }
}

/// MonitorStop icon component (compatibility wrapper)
#[component]
pub fn MonitorStop(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorStop class=class /> }
}

/// MonitorUp icon component (compatibility wrapper)
#[component]
pub fn MonitorUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorUp class=class /> }
}

/// MonitorX icon component (compatibility wrapper)
#[component]
pub fn MonitorX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MonitorX class=class /> }
}

/// Moon icon component (compatibility wrapper)
#[component]
pub fn Moon(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Moon class=class /> }
}

/// MoonStar icon component (compatibility wrapper)
#[component]
pub fn MoonStar(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoonStar class=class /> }
}

/// Mountain icon component (compatibility wrapper)
#[component]
pub fn Mountain(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Mountain class=class /> }
}

/// MountainSnow icon component (compatibility wrapper)
#[component]
pub fn MountainSnow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MountainSnow class=class /> }
}

/// Mouse icon component (compatibility wrapper)
#[component]
pub fn Mouse(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Mouse class=class /> }
}

/// MouseOff icon component (compatibility wrapper)
#[component]
pub fn MouseOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MouseOff class=class /> }
}

/// MousePointer icon component (compatibility wrapper)
#[component]
pub fn MousePointer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MousePointer class=class /> }
}

/// MousePointer2 icon component (compatibility wrapper)
#[component]
pub fn MousePointer2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MousePointer2 class=class /> }
}

/// MousePointerBan icon component (compatibility wrapper)
#[component]
pub fn MousePointerBan(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MousePointerBan class=class /> }
}

/// MousePointerClick icon component (compatibility wrapper)
#[component]
pub fn MousePointerClick(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MousePointerClick class=class /> }
}

/// Move icon component (compatibility wrapper)
#[component]
pub fn Move(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Move class=class /> }
}

/// Move3D icon component (compatibility wrapper)
#[component]
pub fn Move3D(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Move3D class=class /> }
}

/// MoveDiagonal icon component (compatibility wrapper)
#[component]
pub fn MoveDiagonal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveDiagonal class=class /> }
}

/// MoveDiagonal2 icon component (compatibility wrapper)
#[component]
pub fn MoveDiagonal2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveDiagonal2 class=class /> }
}

/// MoveDown icon component (compatibility wrapper)
#[component]
pub fn MoveDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveDown class=class /> }
}

/// MoveDownLeft icon component (compatibility wrapper)
#[component]
pub fn MoveDownLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveDownLeft class=class /> }
}

/// MoveDownRight icon component (compatibility wrapper)
#[component]
pub fn MoveDownRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveDownRight class=class /> }
}

/// MoveHorizontal icon component (compatibility wrapper)
#[component]
pub fn MoveHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveHorizontal class=class /> }
}

/// MoveLeft icon component (compatibility wrapper)
#[component]
pub fn MoveLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveLeft class=class /> }
}

/// MoveRight icon component (compatibility wrapper)
#[component]
pub fn MoveRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveRight class=class /> }
}

/// MoveUp icon component (compatibility wrapper)
#[component]
pub fn MoveUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveUp class=class /> }
}

/// MoveUpLeft icon component (compatibility wrapper)
#[component]
pub fn MoveUpLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveUpLeft class=class /> }
}

/// MoveUpRight icon component (compatibility wrapper)
#[component]
pub fn MoveUpRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveUpRight class=class /> }
}

/// MoveVertical icon component (compatibility wrapper)
#[component]
pub fn MoveVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::MoveVertical class=class /> }
}

/// Music icon component (compatibility wrapper)
#[component]
pub fn Music(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Music class=class /> }
}

/// Music2 icon component (compatibility wrapper)
#[component]
pub fn Music2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Music2 class=class /> }
}

/// Music3 icon component (compatibility wrapper)
#[component]
pub fn Music3(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Music3 class=class /> }
}

/// Music4 icon component (compatibility wrapper)
#[component]
pub fn Music4(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Music4 class=class /> }
}

/// Navigation icon component (compatibility wrapper)
#[component]
pub fn Navigation(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Navigation class=class /> }
}

/// Navigation2 icon component (compatibility wrapper)
#[component]
pub fn Navigation2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Navigation2 class=class /> }
}

/// Navigation2Off icon component (compatibility wrapper)
#[component]
pub fn Navigation2Off(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Navigation2Off class=class /> }
}

/// NavigationOff icon component (compatibility wrapper)
#[component]
pub fn NavigationOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::NavigationOff class=class /> }
}

/// Network icon component (compatibility wrapper)
#[component]
pub fn Network(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Network class=class /> }
}

/// Newspaper icon component (compatibility wrapper)
#[component]
pub fn Newspaper(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Newspaper class=class /> }
}

/// Nfc icon component (compatibility wrapper)
#[component]
pub fn Nfc(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Nfc class=class /> }
}

/// NonBinary icon component (compatibility wrapper)
#[component]
pub fn NonBinary(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::NonBinary class=class /> }
}

/// Notebook icon component (compatibility wrapper)
#[component]
pub fn Notebook(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Notebook class=class /> }
}

/// NotebookPen icon component (compatibility wrapper)
#[component]
pub fn NotebookPen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::NotebookPen class=class /> }
}

/// NotebookTabs icon component (compatibility wrapper)
#[component]
pub fn NotebookTabs(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::NotebookTabs class=class /> }
}

/// NotebookText icon component (compatibility wrapper)
#[component]
pub fn NotebookText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::NotebookText class=class /> }
}

/// NotepadText icon component (compatibility wrapper)
#[component]
pub fn NotepadText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::NotepadText class=class /> }
}

/// NotepadTextDashed icon component (compatibility wrapper)
#[component]
pub fn NotepadTextDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::NotepadTextDashed class=class /> }
}

/// Nut icon component (compatibility wrapper)
#[component]
pub fn Nut(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Nut class=class /> }
}

/// NutOff icon component (compatibility wrapper)
#[component]
pub fn NutOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::NutOff class=class /> }
}

/// Octagon icon component (compatibility wrapper)
#[component]
pub fn Octagon(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Octagon class=class /> }
}

/// OctagonAlert icon component (compatibility wrapper)
#[component]
pub fn OctagonAlert(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::OctagonAlert class=class /> }
}

/// OctagonMinus icon component (compatibility wrapper)
#[component]
pub fn OctagonMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::OctagonMinus class=class /> }
}

/// OctagonPause icon component (compatibility wrapper)
#[component]
pub fn OctagonPause(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::OctagonPause class=class /> }
}

/// OctagonX icon component (compatibility wrapper)
#[component]
pub fn OctagonX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::OctagonX class=class /> }
}

/// Omega icon component (compatibility wrapper)
#[component]
pub fn Omega(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Omega class=class /> }
}

/// OptionIcon icon component (compatibility wrapper)
#[component]
pub fn OptionIcon(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::OptionIcon class=class /> }
}

/// Orbit icon component (compatibility wrapper)
#[component]
pub fn Orbit(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Orbit class=class /> }
}

/// Origami icon component (compatibility wrapper)
#[component]
pub fn Origami(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Origami class=class /> }
}

/// Package icon component (compatibility wrapper)
#[component]
pub fn Package(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Package class=class /> }
}

/// Package2 icon component (compatibility wrapper)
#[component]
pub fn Package2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Package2 class=class /> }
}

/// PackageCheck icon component (compatibility wrapper)
#[component]
pub fn PackageCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PackageCheck class=class /> }
}

/// PackageMinus icon component (compatibility wrapper)
#[component]
pub fn PackageMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PackageMinus class=class /> }
}

/// PackageOpen icon component (compatibility wrapper)
#[component]
pub fn PackageOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PackageOpen class=class /> }
}

/// PackagePlus icon component (compatibility wrapper)
#[component]
pub fn PackagePlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PackagePlus class=class /> }
}

/// PackageSearch icon component (compatibility wrapper)
#[component]
pub fn PackageSearch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PackageSearch class=class /> }
}

/// PackageX icon component (compatibility wrapper)
#[component]
pub fn PackageX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PackageX class=class /> }
}

/// PaintBucket icon component (compatibility wrapper)
#[component]
pub fn PaintBucket(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PaintBucket class=class /> }
}

/// PaintRoller icon component (compatibility wrapper)
#[component]
pub fn PaintRoller(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PaintRoller class=class /> }
}

/// Paintbrush icon component (compatibility wrapper)
#[component]
pub fn Paintbrush(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Paintbrush class=class /> }
}

/// PaintbrushVertical icon component (compatibility wrapper)
#[component]
pub fn PaintbrushVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PaintbrushVertical class=class /> }
}

/// Palette icon component (compatibility wrapper)
#[component]
pub fn Palette(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Palette class=class /> }
}

/// Panda icon component (compatibility wrapper)
#[component]
pub fn Panda(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Panda class=class /> }
}

/// PanelBottom icon component (compatibility wrapper)
#[component]
pub fn PanelBottom(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelBottom class=class /> }
}

/// PanelBottomClose icon component (compatibility wrapper)
#[component]
pub fn PanelBottomClose(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelBottomClose class=class /> }
}

/// PanelBottomDashed icon component (compatibility wrapper)
#[component]
pub fn PanelBottomDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelBottomDashed class=class /> }
}

/// PanelBottomOpen icon component (compatibility wrapper)
#[component]
pub fn PanelBottomOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelBottomOpen class=class /> }
}

/// PanelLeft icon component (compatibility wrapper)
#[component]
pub fn PanelLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelLeft class=class /> }
}

/// PanelLeftClose icon component (compatibility wrapper)
#[component]
pub fn PanelLeftClose(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelLeftClose class=class /> }
}

/// PanelLeftDashed icon component (compatibility wrapper)
#[component]
pub fn PanelLeftDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelLeftDashed class=class /> }
}

/// PanelLeftOpen icon component (compatibility wrapper)
#[component]
pub fn PanelLeftOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelLeftOpen class=class /> }
}

/// PanelRight icon component (compatibility wrapper)
#[component]
pub fn PanelRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelRight class=class /> }
}

/// PanelRightClose icon component (compatibility wrapper)
#[component]
pub fn PanelRightClose(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelRightClose class=class /> }
}

/// PanelRightDashed icon component (compatibility wrapper)
#[component]
pub fn PanelRightDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelRightDashed class=class /> }
}

/// PanelRightOpen icon component (compatibility wrapper)
#[component]
pub fn PanelRightOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelRightOpen class=class /> }
}

/// PanelTop icon component (compatibility wrapper)
#[component]
pub fn PanelTop(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelTop class=class /> }
}

/// PanelTopClose icon component (compatibility wrapper)
#[component]
pub fn PanelTopClose(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelTopClose class=class /> }
}

/// PanelTopDashed icon component (compatibility wrapper)
#[component]
pub fn PanelTopDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelTopDashed class=class /> }
}

/// PanelTopOpen icon component (compatibility wrapper)
#[component]
pub fn PanelTopOpen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelTopOpen class=class /> }
}

/// PanelsLeftBottom icon component (compatibility wrapper)
#[component]
pub fn PanelsLeftBottom(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelsLeftBottom class=class /> }
}

/// PanelsRightBottom icon component (compatibility wrapper)
#[component]
pub fn PanelsRightBottom(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelsRightBottom class=class /> }
}

/// PanelsTopLeft icon component (compatibility wrapper)
#[component]
pub fn PanelsTopLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PanelsTopLeft class=class /> }
}

/// Paperclip icon component (compatibility wrapper)
#[component]
pub fn Paperclip(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Paperclip class=class /> }
}

/// Parentheses icon component (compatibility wrapper)
#[component]
pub fn Parentheses(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Parentheses class=class /> }
}

/// ParkingMeter icon component (compatibility wrapper)
#[component]
pub fn ParkingMeter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ParkingMeter class=class /> }
}

/// PartyPopper icon component (compatibility wrapper)
#[component]
pub fn PartyPopper(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PartyPopper class=class /> }
}

/// Pause icon component (compatibility wrapper)
#[component]
pub fn Pause(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pause class=class /> }
}

/// PawPrint icon component (compatibility wrapper)
#[component]
pub fn PawPrint(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PawPrint class=class /> }
}

/// PcCase icon component (compatibility wrapper)
#[component]
pub fn PcCase(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PcCase class=class /> }
}

/// Pen icon component (compatibility wrapper)
#[component]
pub fn Pen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pen class=class /> }
}

/// PenLine icon component (compatibility wrapper)
#[component]
pub fn PenLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PenLine class=class /> }
}

/// PenOff icon component (compatibility wrapper)
#[component]
pub fn PenOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PenOff class=class /> }
}

/// PenTool icon component (compatibility wrapper)
#[component]
pub fn PenTool(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PenTool class=class /> }
}

/// Pencil icon component (compatibility wrapper)
#[component]
pub fn Pencil(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pencil class=class /> }
}

/// PencilLine icon component (compatibility wrapper)
#[component]
pub fn PencilLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PencilLine class=class /> }
}

/// PencilOff icon component (compatibility wrapper)
#[component]
pub fn PencilOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PencilOff class=class /> }
}

/// PencilRuler icon component (compatibility wrapper)
#[component]
pub fn PencilRuler(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PencilRuler class=class /> }
}

/// Pentagon icon component (compatibility wrapper)
#[component]
pub fn Pentagon(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pentagon class=class /> }
}

/// Percent icon component (compatibility wrapper)
#[component]
pub fn Percent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Percent class=class /> }
}

/// PersonStanding icon component (compatibility wrapper)
#[component]
pub fn PersonStanding(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PersonStanding class=class /> }
}

/// PhilippinePeso icon component (compatibility wrapper)
#[component]
pub fn PhilippinePeso(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PhilippinePeso class=class /> }
}

/// Phone icon component (compatibility wrapper)
#[component]
pub fn Phone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Phone class=class /> }
}

/// PhoneCall icon component (compatibility wrapper)
#[component]
pub fn PhoneCall(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PhoneCall class=class /> }
}

/// PhoneForwarded icon component (compatibility wrapper)
#[component]
pub fn PhoneForwarded(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PhoneForwarded class=class /> }
}

/// PhoneIncoming icon component (compatibility wrapper)
#[component]
pub fn PhoneIncoming(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PhoneIncoming class=class /> }
}

/// PhoneMissed icon component (compatibility wrapper)
#[component]
pub fn PhoneMissed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PhoneMissed class=class /> }
}

/// PhoneOff icon component (compatibility wrapper)
#[component]
pub fn PhoneOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PhoneOff class=class /> }
}

/// PhoneOutgoing icon component (compatibility wrapper)
#[component]
pub fn PhoneOutgoing(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PhoneOutgoing class=class /> }
}

/// Pi icon component (compatibility wrapper)
#[component]
pub fn Pi(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pi class=class /> }
}

/// Piano icon component (compatibility wrapper)
#[component]
pub fn Piano(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Piano class=class /> }
}

/// Pickaxe icon component (compatibility wrapper)
#[component]
pub fn Pickaxe(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pickaxe class=class /> }
}

/// PictureInPicture icon component (compatibility wrapper)
#[component]
pub fn PictureInPicture(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PictureInPicture class=class /> }
}

/// PictureInPicture2 icon component (compatibility wrapper)
#[component]
pub fn PictureInPicture2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PictureInPicture2 class=class /> }
}

/// PiggyBank icon component (compatibility wrapper)
#[component]
pub fn PiggyBank(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PiggyBank class=class /> }
}

/// Pilcrow icon component (compatibility wrapper)
#[component]
pub fn Pilcrow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pilcrow class=class /> }
}

/// PilcrowLeft icon component (compatibility wrapper)
#[component]
pub fn PilcrowLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PilcrowLeft class=class /> }
}

/// PilcrowRight icon component (compatibility wrapper)
#[component]
pub fn PilcrowRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PilcrowRight class=class /> }
}

/// Pill icon component (compatibility wrapper)
#[component]
pub fn Pill(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pill class=class /> }
}

/// PillBottle icon component (compatibility wrapper)
#[component]
pub fn PillBottle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PillBottle class=class /> }
}

/// Pin icon component (compatibility wrapper)
#[component]
pub fn Pin(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pin class=class /> }
}

/// PinOff icon component (compatibility wrapper)
#[component]
pub fn PinOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PinOff class=class /> }
}

/// Pipette icon component (compatibility wrapper)
#[component]
pub fn Pipette(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pipette class=class /> }
}

/// Pizza icon component (compatibility wrapper)
#[component]
pub fn Pizza(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pizza class=class /> }
}

/// Plane icon component (compatibility wrapper)
#[component]
pub fn Plane(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Plane class=class /> }
}

/// PlaneLanding icon component (compatibility wrapper)
#[component]
pub fn PlaneLanding(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PlaneLanding class=class /> }
}

/// PlaneTakeoff icon component (compatibility wrapper)
#[component]
pub fn PlaneTakeoff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PlaneTakeoff class=class /> }
}

/// Play icon component (compatibility wrapper)
#[component]
pub fn Play(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Play class=class /> }
}

/// Plug icon component (compatibility wrapper)
#[component]
pub fn Plug(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Plug class=class /> }
}

/// Plug2 icon component (compatibility wrapper)
#[component]
pub fn Plug2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Plug2 class=class /> }
}

/// PlugZap icon component (compatibility wrapper)
#[component]
pub fn PlugZap(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PlugZap class=class /> }
}

/// Plus icon component (compatibility wrapper)
#[component]
pub fn Plus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Plus class=class /> }
}

/// Pocket icon component (compatibility wrapper)
#[component]
pub fn Pocket(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pocket class=class /> }
}

/// PocketKnife icon component (compatibility wrapper)
#[component]
pub fn PocketKnife(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PocketKnife class=class /> }
}

/// Podcast icon component (compatibility wrapper)
#[component]
pub fn Podcast(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Podcast class=class /> }
}

/// Pointer icon component (compatibility wrapper)
#[component]
pub fn Pointer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pointer class=class /> }
}

/// PointerOff icon component (compatibility wrapper)
#[component]
pub fn PointerOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PointerOff class=class /> }
}

/// Popcorn icon component (compatibility wrapper)
#[component]
pub fn Popcorn(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Popcorn class=class /> }
}

/// Popsicle icon component (compatibility wrapper)
#[component]
pub fn Popsicle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Popsicle class=class /> }
}

/// PoundSterling icon component (compatibility wrapper)
#[component]
pub fn PoundSterling(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PoundSterling class=class /> }
}

/// Power icon component (compatibility wrapper)
#[component]
pub fn Power(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Power class=class /> }
}

/// PowerOff icon component (compatibility wrapper)
#[component]
pub fn PowerOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PowerOff class=class /> }
}

/// Presentation icon component (compatibility wrapper)
#[component]
pub fn Presentation(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Presentation class=class /> }
}

/// Printer icon component (compatibility wrapper)
#[component]
pub fn Printer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Printer class=class /> }
}

/// PrinterCheck icon component (compatibility wrapper)
#[component]
pub fn PrinterCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::PrinterCheck class=class /> }
}

/// Projector icon component (compatibility wrapper)
#[component]
pub fn Projector(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Projector class=class /> }
}

/// Proportions icon component (compatibility wrapper)
#[component]
pub fn Proportions(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Proportions class=class /> }
}

/// Puzzle icon component (compatibility wrapper)
#[component]
pub fn Puzzle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Puzzle class=class /> }
}

/// Pyramid icon component (compatibility wrapper)
#[component]
pub fn Pyramid(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Pyramid class=class /> }
}

/// QrCode icon component (compatibility wrapper)
#[component]
pub fn QrCode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::QrCode class=class /> }
}

/// Quote icon component (compatibility wrapper)
#[component]
pub fn Quote(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Quote class=class /> }
}

/// Rabbit icon component (compatibility wrapper)
#[component]
pub fn Rabbit(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Rabbit class=class /> }
}

/// Radar icon component (compatibility wrapper)
#[component]
pub fn Radar(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Radar class=class /> }
}

/// Radiation icon component (compatibility wrapper)
#[component]
pub fn Radiation(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Radiation class=class /> }
}

/// Radical icon component (compatibility wrapper)
#[component]
pub fn Radical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Radical class=class /> }
}

/// Radio icon component (compatibility wrapper)
#[component]
pub fn Radio(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Radio class=class /> }
}

/// RadioReceiver icon component (compatibility wrapper)
#[component]
pub fn RadioReceiver(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RadioReceiver class=class /> }
}

/// RadioTower icon component (compatibility wrapper)
#[component]
pub fn RadioTower(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RadioTower class=class /> }
}

/// Radius icon component (compatibility wrapper)
#[component]
pub fn Radius(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Radius class=class /> }
}

/// RailSymbol icon component (compatibility wrapper)
#[component]
pub fn RailSymbol(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RailSymbol class=class /> }
}

/// Rainbow icon component (compatibility wrapper)
#[component]
pub fn Rainbow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Rainbow class=class /> }
}

/// Rat icon component (compatibility wrapper)
#[component]
pub fn Rat(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Rat class=class /> }
}

/// Ratio icon component (compatibility wrapper)
#[component]
pub fn Ratio(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ratio class=class /> }
}

/// Receipt icon component (compatibility wrapper)
#[component]
pub fn Receipt(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Receipt class=class /> }
}

/// ReceiptCent icon component (compatibility wrapper)
#[component]
pub fn ReceiptCent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReceiptCent class=class /> }
}

/// ReceiptEuro icon component (compatibility wrapper)
#[component]
pub fn ReceiptEuro(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReceiptEuro class=class /> }
}

/// ReceiptIndianRupee icon component (compatibility wrapper)
#[component]
pub fn ReceiptIndianRupee(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReceiptIndianRupee class=class /> }
}

/// ReceiptJapaneseYen icon component (compatibility wrapper)
#[component]
pub fn ReceiptJapaneseYen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReceiptJapaneseYen class=class /> }
}

/// ReceiptPoundSterling icon component (compatibility wrapper)
#[component]
pub fn ReceiptPoundSterling(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReceiptPoundSterling class=class /> }
}

/// ReceiptRussianRuble icon component (compatibility wrapper)
#[component]
pub fn ReceiptRussianRuble(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReceiptRussianRuble class=class /> }
}

/// ReceiptSwissFranc icon component (compatibility wrapper)
#[component]
pub fn ReceiptSwissFranc(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReceiptSwissFranc class=class /> }
}

/// ReceiptText icon component (compatibility wrapper)
#[component]
pub fn ReceiptText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReceiptText class=class /> }
}

/// ReceiptTurkishLira icon component (compatibility wrapper)
#[component]
pub fn ReceiptTurkishLira(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReceiptTurkishLira class=class /> }
}

/// RectangleCircle icon component (compatibility wrapper)
#[component]
pub fn RectangleCircle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RectangleCircle class=class /> }
}

/// RectangleEllipsis icon component (compatibility wrapper)
#[component]
pub fn RectangleEllipsis(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RectangleEllipsis class=class /> }
}

/// RectangleGoggles icon component (compatibility wrapper)
#[component]
pub fn RectangleGoggles(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RectangleGoggles class=class /> }
}

/// RectangleHorizontal icon component (compatibility wrapper)
#[component]
pub fn RectangleHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RectangleHorizontal class=class /> }
}

/// RectangleVertical icon component (compatibility wrapper)
#[component]
pub fn RectangleVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RectangleVertical class=class /> }
}

/// Recycle icon component (compatibility wrapper)
#[component]
pub fn Recycle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Recycle class=class /> }
}

/// Redo icon component (compatibility wrapper)
#[component]
pub fn Redo(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Redo class=class /> }
}

/// Redo2 icon component (compatibility wrapper)
#[component]
pub fn Redo2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Redo2 class=class /> }
}

/// RedoDot icon component (compatibility wrapper)
#[component]
pub fn RedoDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RedoDot class=class /> }
}

/// RefreshCcw icon component (compatibility wrapper)
#[component]
pub fn RefreshCcw(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RefreshCcw class=class /> }
}

/// RefreshCcwDot icon component (compatibility wrapper)
#[component]
pub fn RefreshCcwDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RefreshCcwDot class=class /> }
}

/// RefreshCw icon component (compatibility wrapper)
#[component]
pub fn RefreshCw(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RefreshCw class=class /> }
}

/// RefreshCwOff icon component (compatibility wrapper)
#[component]
pub fn RefreshCwOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RefreshCwOff class=class /> }
}

/// Refrigerator icon component (compatibility wrapper)
#[component]
pub fn Refrigerator(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Refrigerator class=class /> }
}

/// Regex icon component (compatibility wrapper)
#[component]
pub fn Regex(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Regex class=class /> }
}

/// RemoveFormatting icon component (compatibility wrapper)
#[component]
pub fn RemoveFormatting(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RemoveFormatting class=class /> }
}

/// Repeat icon component (compatibility wrapper)
#[component]
pub fn Repeat(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Repeat class=class /> }
}

/// Repeat1 icon component (compatibility wrapper)
#[component]
pub fn Repeat1(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Repeat1 class=class /> }
}

/// Repeat2 icon component (compatibility wrapper)
#[component]
pub fn Repeat2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Repeat2 class=class /> }
}

/// Replace icon component (compatibility wrapper)
#[component]
pub fn Replace(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Replace class=class /> }
}

/// ReplaceAll icon component (compatibility wrapper)
#[component]
pub fn ReplaceAll(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReplaceAll class=class /> }
}

/// Reply icon component (compatibility wrapper)
#[component]
pub fn Reply(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Reply class=class /> }
}

/// ReplyAll icon component (compatibility wrapper)
#[component]
pub fn ReplyAll(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ReplyAll class=class /> }
}

/// Rewind icon component (compatibility wrapper)
#[component]
pub fn Rewind(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Rewind class=class /> }
}

/// Ribbon icon component (compatibility wrapper)
#[component]
pub fn Ribbon(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ribbon class=class /> }
}

/// Rocket icon component (compatibility wrapper)
#[component]
pub fn Rocket(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Rocket class=class /> }
}

/// RockingChair icon component (compatibility wrapper)
#[component]
pub fn RockingChair(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RockingChair class=class /> }
}

/// RollerCoaster icon component (compatibility wrapper)
#[component]
pub fn RollerCoaster(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RollerCoaster class=class /> }
}

/// Rotate3D icon component (compatibility wrapper)
#[component]
pub fn Rotate3D(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Rotate3D class=class /> }
}

/// RotateCcw icon component (compatibility wrapper)
#[component]
pub fn RotateCcw(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RotateCcw class=class /> }
}

/// RotateCcwKey icon component (compatibility wrapper)
#[component]
pub fn RotateCcwKey(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RotateCcwKey class=class /> }
}

/// RotateCcwSquare icon component (compatibility wrapper)
#[component]
pub fn RotateCcwSquare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RotateCcwSquare class=class /> }
}

/// RotateCw icon component (compatibility wrapper)
#[component]
pub fn RotateCw(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RotateCw class=class /> }
}

/// RotateCwSquare icon component (compatibility wrapper)
#[component]
pub fn RotateCwSquare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RotateCwSquare class=class /> }
}

/// Route icon component (compatibility wrapper)
#[component]
pub fn Route(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Route class=class /> }
}

/// RouteOff icon component (compatibility wrapper)
#[component]
pub fn RouteOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RouteOff class=class /> }
}

/// Router icon component (compatibility wrapper)
#[component]
pub fn Router(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Router class=class /> }
}

/// Rows2 icon component (compatibility wrapper)
#[component]
pub fn Rows2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Rows2 class=class /> }
}

/// Rows3 icon component (compatibility wrapper)
#[component]
pub fn Rows3(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Rows3 class=class /> }
}

/// Rows4 icon component (compatibility wrapper)
#[component]
pub fn Rows4(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Rows4 class=class /> }
}

/// Rss icon component (compatibility wrapper)
#[component]
pub fn Rss(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Rss class=class /> }
}

/// Ruler icon component (compatibility wrapper)
#[component]
pub fn Ruler(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ruler class=class /> }
}

/// RulerDimensionLine icon component (compatibility wrapper)
#[component]
pub fn RulerDimensionLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RulerDimensionLine class=class /> }
}

/// RussianRuble icon component (compatibility wrapper)
#[component]
pub fn RussianRuble(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::RussianRuble class=class /> }
}

/// Sailboat icon component (compatibility wrapper)
#[component]
pub fn Sailboat(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sailboat class=class /> }
}

/// Salad icon component (compatibility wrapper)
#[component]
pub fn Salad(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Salad class=class /> }
}

/// Sandwich icon component (compatibility wrapper)
#[component]
pub fn Sandwich(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sandwich class=class /> }
}

/// Satellite icon component (compatibility wrapper)
#[component]
pub fn Satellite(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Satellite class=class /> }
}

/// SatelliteDish icon component (compatibility wrapper)
#[component]
pub fn SatelliteDish(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SatelliteDish class=class /> }
}

/// SaudiRiyal icon component (compatibility wrapper)
#[component]
pub fn SaudiRiyal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SaudiRiyal class=class /> }
}

/// Save icon component (compatibility wrapper)
#[component]
pub fn Save(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Save class=class /> }
}

/// SaveAll icon component (compatibility wrapper)
#[component]
pub fn SaveAll(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SaveAll class=class /> }
}

/// SaveOff icon component (compatibility wrapper)
#[component]
pub fn SaveOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SaveOff class=class /> }
}

/// Scale icon component (compatibility wrapper)
#[component]
pub fn Scale(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Scale class=class /> }
}

/// Scale3D icon component (compatibility wrapper)
#[component]
pub fn Scale3D(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Scale3D class=class /> }
}

/// Scaling icon component (compatibility wrapper)
#[component]
pub fn Scaling(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Scaling class=class /> }
}

/// Scan icon component (compatibility wrapper)
#[component]
pub fn Scan(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Scan class=class /> }
}

/// ScanBarcode icon component (compatibility wrapper)
#[component]
pub fn ScanBarcode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScanBarcode class=class /> }
}

/// ScanEye icon component (compatibility wrapper)
#[component]
pub fn ScanEye(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScanEye class=class /> }
}

/// ScanFace icon component (compatibility wrapper)
#[component]
pub fn ScanFace(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScanFace class=class /> }
}

/// ScanHeart icon component (compatibility wrapper)
#[component]
pub fn ScanHeart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScanHeart class=class /> }
}

/// ScanLine icon component (compatibility wrapper)
#[component]
pub fn ScanLine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScanLine class=class /> }
}

/// ScanQrCode icon component (compatibility wrapper)
#[component]
pub fn ScanQrCode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScanQrCode class=class /> }
}

/// ScanSearch icon component (compatibility wrapper)
#[component]
pub fn ScanSearch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScanSearch class=class /> }
}

/// ScanText icon component (compatibility wrapper)
#[component]
pub fn ScanText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScanText class=class /> }
}

/// School icon component (compatibility wrapper)
#[component]
pub fn School(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::School class=class /> }
}

/// Scissors icon component (compatibility wrapper)
#[component]
pub fn Scissors(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Scissors class=class /> }
}

/// ScissorsLineDashed icon component (compatibility wrapper)
#[component]
pub fn ScissorsLineDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScissorsLineDashed class=class /> }
}

/// ScreenShare icon component (compatibility wrapper)
#[component]
pub fn ScreenShare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScreenShare class=class /> }
}

/// ScreenShareOff icon component (compatibility wrapper)
#[component]
pub fn ScreenShareOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScreenShareOff class=class /> }
}

/// Scroll icon component (compatibility wrapper)
#[component]
pub fn Scroll(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Scroll class=class /> }
}

/// ScrollText icon component (compatibility wrapper)
#[component]
pub fn ScrollText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ScrollText class=class /> }
}

/// Search icon component (compatibility wrapper)
#[component]
pub fn Search(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Search class=class /> }
}

/// SearchCheck icon component (compatibility wrapper)
#[component]
pub fn SearchCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SearchCheck class=class /> }
}

/// SearchCode icon component (compatibility wrapper)
#[component]
pub fn SearchCode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SearchCode class=class /> }
}

/// SearchSlash icon component (compatibility wrapper)
#[component]
pub fn SearchSlash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SearchSlash class=class /> }
}

/// SearchX icon component (compatibility wrapper)
#[component]
pub fn SearchX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SearchX class=class /> }
}

/// Section icon component (compatibility wrapper)
#[component]
pub fn Section(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Section class=class /> }
}

/// Send icon component (compatibility wrapper)
#[component]
pub fn Send(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Send class=class /> }
}

/// SendHorizontal icon component (compatibility wrapper)
#[component]
pub fn SendHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SendHorizontal class=class /> }
}

/// SendToBack icon component (compatibility wrapper)
#[component]
pub fn SendToBack(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SendToBack class=class /> }
}

/// SeparatorHorizontal icon component (compatibility wrapper)
#[component]
pub fn SeparatorHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SeparatorHorizontal class=class /> }
}

/// SeparatorVertical icon component (compatibility wrapper)
#[component]
pub fn SeparatorVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SeparatorVertical class=class /> }
}

/// Server icon component (compatibility wrapper)
#[component]
pub fn Server(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Server class=class /> }
}

/// ServerCog icon component (compatibility wrapper)
#[component]
pub fn ServerCog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ServerCog class=class /> }
}

/// ServerCrash icon component (compatibility wrapper)
#[component]
pub fn ServerCrash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ServerCrash class=class /> }
}

/// ServerOff icon component (compatibility wrapper)
#[component]
pub fn ServerOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ServerOff class=class /> }
}

/// Settings icon component (compatibility wrapper)
#[component]
pub fn Settings(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Settings class=class /> }
}

/// Settings2 icon component (compatibility wrapper)
#[component]
pub fn Settings2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Settings2 class=class /> }
}

/// Shapes icon component (compatibility wrapper)
#[component]
pub fn Shapes(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Shapes class=class /> }
}

/// Share icon component (compatibility wrapper)
#[component]
pub fn Share(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Share class=class /> }
}

/// Share2 icon component (compatibility wrapper)
#[component]
pub fn Share2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Share2 class=class /> }
}

/// Sheet icon component (compatibility wrapper)
#[component]
pub fn Sheet(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sheet class=class /> }
}

/// Shell icon component (compatibility wrapper)
#[component]
pub fn Shell(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Shell class=class /> }
}

/// Shield icon component (compatibility wrapper)
#[component]
pub fn Shield(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Shield class=class /> }
}

/// ShieldAlert icon component (compatibility wrapper)
#[component]
pub fn ShieldAlert(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldAlert class=class /> }
}

/// ShieldBan icon component (compatibility wrapper)
#[component]
pub fn ShieldBan(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldBan class=class /> }
}

/// ShieldCheck icon component (compatibility wrapper)
#[component]
pub fn ShieldCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldCheck class=class /> }
}

/// ShieldEllipsis icon component (compatibility wrapper)
#[component]
pub fn ShieldEllipsis(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldEllipsis class=class /> }
}

/// ShieldHalf icon component (compatibility wrapper)
#[component]
pub fn ShieldHalf(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldHalf class=class /> }
}

/// ShieldMinus icon component (compatibility wrapper)
#[component]
pub fn ShieldMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldMinus class=class /> }
}

/// ShieldOff icon component (compatibility wrapper)
#[component]
pub fn ShieldOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldOff class=class /> }
}

/// ShieldPlus icon component (compatibility wrapper)
#[component]
pub fn ShieldPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldPlus class=class /> }
}

/// ShieldQuestion icon component (compatibility wrapper)
#[component]
pub fn ShieldQuestion(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldQuestion class=class /> }
}

/// ShieldQuestionMark icon component (compatibility wrapper)
#[component]
pub fn ShieldQuestionMark(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldQuestionMark class=class /> }
}

/// ShieldUser icon component (compatibility wrapper)
#[component]
pub fn ShieldUser(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldUser class=class /> }
}

/// ShieldX icon component (compatibility wrapper)
#[component]
pub fn ShieldX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShieldX class=class /> }
}

/// Ship icon component (compatibility wrapper)
#[component]
pub fn Ship(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ship class=class /> }
}

/// ShipWheel icon component (compatibility wrapper)
#[component]
pub fn ShipWheel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShipWheel class=class /> }
}

/// Shirt icon component (compatibility wrapper)
#[component]
pub fn Shirt(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Shirt class=class /> }
}

/// ShoppingBag icon component (compatibility wrapper)
#[component]
pub fn ShoppingBag(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShoppingBag class=class /> }
}

/// ShoppingBasket icon component (compatibility wrapper)
#[component]
pub fn ShoppingBasket(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShoppingBasket class=class /> }
}

/// ShoppingCart icon component (compatibility wrapper)
#[component]
pub fn ShoppingCart(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShoppingCart class=class /> }
}

/// Shovel icon component (compatibility wrapper)
#[component]
pub fn Shovel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Shovel class=class /> }
}

/// ShowerHead icon component (compatibility wrapper)
#[component]
pub fn ShowerHead(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ShowerHead class=class /> }
}

/// Shredder icon component (compatibility wrapper)
#[component]
pub fn Shredder(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Shredder class=class /> }
}

/// Shrimp icon component (compatibility wrapper)
#[component]
pub fn Shrimp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Shrimp class=class /> }
}

/// Shrink icon component (compatibility wrapper)
#[component]
pub fn Shrink(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Shrink class=class /> }
}

/// Shrub icon component (compatibility wrapper)
#[component]
pub fn Shrub(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Shrub class=class /> }
}

/// Shuffle icon component (compatibility wrapper)
#[component]
pub fn Shuffle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Shuffle class=class /> }
}

/// Sigma icon component (compatibility wrapper)
#[component]
pub fn Sigma(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sigma class=class /> }
}

/// Signal icon component (compatibility wrapper)
#[component]
pub fn Signal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Signal class=class /> }
}

/// SignalHigh icon component (compatibility wrapper)
#[component]
pub fn SignalHigh(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SignalHigh class=class /> }
}

/// SignalLow icon component (compatibility wrapper)
#[component]
pub fn SignalLow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SignalLow class=class /> }
}

/// SignalMedium icon component (compatibility wrapper)
#[component]
pub fn SignalMedium(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SignalMedium class=class /> }
}

/// SignalZero icon component (compatibility wrapper)
#[component]
pub fn SignalZero(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SignalZero class=class /> }
}

/// Signature icon component (compatibility wrapper)
#[component]
pub fn Signature(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Signature class=class /> }
}

/// Signpost icon component (compatibility wrapper)
#[component]
pub fn Signpost(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Signpost class=class /> }
}

/// SignpostBig icon component (compatibility wrapper)
#[component]
pub fn SignpostBig(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SignpostBig class=class /> }
}

/// Siren icon component (compatibility wrapper)
#[component]
pub fn Siren(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Siren class=class /> }
}

/// SkipBack icon component (compatibility wrapper)
#[component]
pub fn SkipBack(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SkipBack class=class /> }
}

/// SkipForward icon component (compatibility wrapper)
#[component]
pub fn SkipForward(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SkipForward class=class /> }
}

/// Skull icon component (compatibility wrapper)
#[component]
pub fn Skull(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Skull class=class /> }
}

/// Slack icon component (compatibility wrapper)
#[component]
pub fn Slack(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Slack class=class /> }
}

/// Slash icon component (compatibility wrapper)
#[component]
pub fn Slash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Slash class=class /> }
}

/// Slice icon component (compatibility wrapper)
#[component]
pub fn Slice(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Slice class=class /> }
}

/// SlidersHorizontal icon component (compatibility wrapper)
#[component]
pub fn SlidersHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SlidersHorizontal class=class /> }
}

/// SlidersVertical icon component (compatibility wrapper)
#[component]
pub fn SlidersVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SlidersVertical class=class /> }
}

/// Smartphone icon component (compatibility wrapper)
#[component]
pub fn Smartphone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Smartphone class=class /> }
}

/// SmartphoneCharging icon component (compatibility wrapper)
#[component]
pub fn SmartphoneCharging(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SmartphoneCharging class=class /> }
}

/// SmartphoneNfc icon component (compatibility wrapper)
#[component]
pub fn SmartphoneNfc(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SmartphoneNfc class=class /> }
}

/// Smile icon component (compatibility wrapper)
#[component]
pub fn Smile(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Smile class=class /> }
}

/// SmilePlus icon component (compatibility wrapper)
#[component]
pub fn SmilePlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SmilePlus class=class /> }
}

/// Snail icon component (compatibility wrapper)
#[component]
pub fn Snail(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Snail class=class /> }
}

/// Snowflake icon component (compatibility wrapper)
#[component]
pub fn Snowflake(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Snowflake class=class /> }
}

/// SoapDispenserDroplet icon component (compatibility wrapper)
#[component]
pub fn SoapDispenserDroplet(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SoapDispenserDroplet class=class /> }
}

/// Sofa icon component (compatibility wrapper)
#[component]
pub fn Sofa(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sofa class=class /> }
}

/// Soup icon component (compatibility wrapper)
#[component]
pub fn Soup(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Soup class=class /> }
}

/// Space icon component (compatibility wrapper)
#[component]
pub fn Space(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Space class=class /> }
}

/// Spade icon component (compatibility wrapper)
#[component]
pub fn Spade(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Spade class=class /> }
}

/// Sparkle icon component (compatibility wrapper)
#[component]
pub fn Sparkle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sparkle class=class /> }
}

/// Sparkles icon component (compatibility wrapper)
#[component]
pub fn Sparkles(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sparkles class=class /> }
}

/// Speaker icon component (compatibility wrapper)
#[component]
pub fn Speaker(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Speaker class=class /> }
}

/// Speech icon component (compatibility wrapper)
#[component]
pub fn Speech(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Speech class=class /> }
}

/// SpellCheck icon component (compatibility wrapper)
#[component]
pub fn SpellCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SpellCheck class=class /> }
}

/// SpellCheck2 icon component (compatibility wrapper)
#[component]
pub fn SpellCheck2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SpellCheck2 class=class /> }
}

/// Spline icon component (compatibility wrapper)
#[component]
pub fn Spline(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Spline class=class /> }
}

/// SplinePointer icon component (compatibility wrapper)
#[component]
pub fn SplinePointer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SplinePointer class=class /> }
}

/// Split icon component (compatibility wrapper)
#[component]
pub fn Split(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Split class=class /> }
}

/// Spool icon component (compatibility wrapper)
#[component]
pub fn Spool(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Spool class=class /> }
}

/// Spotlight icon component (compatibility wrapper)
#[component]
pub fn Spotlight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Spotlight class=class /> }
}

/// SprayCan icon component (compatibility wrapper)
#[component]
pub fn SprayCan(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SprayCan class=class /> }
}

/// Sprout icon component (compatibility wrapper)
#[component]
pub fn Sprout(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sprout class=class /> }
}

/// Square icon component (compatibility wrapper)
#[component]
pub fn Square(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Square class=class /> }
}

/// SquareActivity icon component (compatibility wrapper)
#[component]
pub fn SquareActivity(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareActivity class=class /> }
}

/// SquareArrowDown icon component (compatibility wrapper)
#[component]
pub fn SquareArrowDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowDown class=class /> }
}

/// SquareArrowDownLeft icon component (compatibility wrapper)
#[component]
pub fn SquareArrowDownLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowDownLeft class=class /> }
}

/// SquareArrowDownRight icon component (compatibility wrapper)
#[component]
pub fn SquareArrowDownRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowDownRight class=class /> }
}

/// SquareArrowLeft icon component (compatibility wrapper)
#[component]
pub fn SquareArrowLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowLeft class=class /> }
}

/// SquareArrowOutDownLeft icon component (compatibility wrapper)
#[component]
pub fn SquareArrowOutDownLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowOutDownLeft class=class /> }
}

/// SquareArrowOutDownRight icon component (compatibility wrapper)
#[component]
pub fn SquareArrowOutDownRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowOutDownRight class=class /> }
}

/// SquareArrowOutUpLeft icon component (compatibility wrapper)
#[component]
pub fn SquareArrowOutUpLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowOutUpLeft class=class /> }
}

/// SquareArrowOutUpRight icon component (compatibility wrapper)
#[component]
pub fn SquareArrowOutUpRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowOutUpRight class=class /> }
}

/// SquareArrowRight icon component (compatibility wrapper)
#[component]
pub fn SquareArrowRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowRight class=class /> }
}

/// SquareArrowUp icon component (compatibility wrapper)
#[component]
pub fn SquareArrowUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowUp class=class /> }
}

/// SquareArrowUpLeft icon component (compatibility wrapper)
#[component]
pub fn SquareArrowUpLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowUpLeft class=class /> }
}

/// SquareArrowUpRight icon component (compatibility wrapper)
#[component]
pub fn SquareArrowUpRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareArrowUpRight class=class /> }
}

/// SquareAsterisk icon component (compatibility wrapper)
#[component]
pub fn SquareAsterisk(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareAsterisk class=class /> }
}

/// SquareBottomDashedScissors icon component (compatibility wrapper)
#[component]
pub fn SquareBottomDashedScissors(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareBottomDashedScissors class=class /> }
}

/// SquareChartGantt icon component (compatibility wrapper)
#[component]
pub fn SquareChartGantt(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareChartGantt class=class /> }
}

/// SquareCheck icon component (compatibility wrapper)
#[component]
pub fn SquareCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareCheck class=class /> }
}

/// SquareCheckBig icon component (compatibility wrapper)
#[component]
pub fn SquareCheckBig(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareCheckBig class=class /> }
}

/// SquareChevronDown icon component (compatibility wrapper)
#[component]
pub fn SquareChevronDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareChevronDown class=class /> }
}

/// SquareChevronLeft icon component (compatibility wrapper)
#[component]
pub fn SquareChevronLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareChevronLeft class=class /> }
}

/// SquareChevronRight icon component (compatibility wrapper)
#[component]
pub fn SquareChevronRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareChevronRight class=class /> }
}

/// SquareChevronUp icon component (compatibility wrapper)
#[component]
pub fn SquareChevronUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareChevronUp class=class /> }
}

/// SquareCode icon component (compatibility wrapper)
#[component]
pub fn SquareCode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareCode class=class /> }
}

/// SquareDashed icon component (compatibility wrapper)
#[component]
pub fn SquareDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareDashed class=class /> }
}

/// SquareDashedBottom icon component (compatibility wrapper)
#[component]
pub fn SquareDashedBottom(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareDashedBottom class=class /> }
}

/// SquareDashedBottomCode icon component (compatibility wrapper)
#[component]
pub fn SquareDashedBottomCode(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareDashedBottomCode class=class /> }
}

/// SquareDashedKanban icon component (compatibility wrapper)
#[component]
pub fn SquareDashedKanban(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareDashedKanban class=class /> }
}

/// SquareDashedMousePointer icon component (compatibility wrapper)
#[component]
pub fn SquareDashedMousePointer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareDashedMousePointer class=class /> }
}

/// SquareDashedTopSolid icon component (compatibility wrapper)
#[component]
pub fn SquareDashedTopSolid(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareDashedTopSolid class=class /> }
}

/// SquareDivide icon component (compatibility wrapper)
#[component]
pub fn SquareDivide(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareDivide class=class /> }
}

/// SquareDot icon component (compatibility wrapper)
#[component]
pub fn SquareDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareDot class=class /> }
}

/// SquareEqual icon component (compatibility wrapper)
#[component]
pub fn SquareEqual(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareEqual class=class /> }
}

/// SquareFunction icon component (compatibility wrapper)
#[component]
pub fn SquareFunction(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareFunction class=class /> }
}

/// SquareKanban icon component (compatibility wrapper)
#[component]
pub fn SquareKanban(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareKanban class=class /> }
}

/// SquareLibrary icon component (compatibility wrapper)
#[component]
pub fn SquareLibrary(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareLibrary class=class /> }
}

/// SquareM icon component (compatibility wrapper)
#[component]
pub fn SquareM(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareM class=class /> }
}

/// SquareMenu icon component (compatibility wrapper)
#[component]
pub fn SquareMenu(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareMenu class=class /> }
}

/// SquareMinus icon component (compatibility wrapper)
#[component]
pub fn SquareMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareMinus class=class /> }
}

/// SquareMousePointer icon component (compatibility wrapper)
#[component]
pub fn SquareMousePointer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareMousePointer class=class /> }
}

/// SquareParking icon component (compatibility wrapper)
#[component]
pub fn SquareParking(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareParking class=class /> }
}

/// SquareParkingOff icon component (compatibility wrapper)
#[component]
pub fn SquareParkingOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareParkingOff class=class /> }
}

/// SquarePause icon component (compatibility wrapper)
#[component]
pub fn SquarePause(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquarePause class=class /> }
}

/// SquarePen icon component (compatibility wrapper)
#[component]
pub fn SquarePen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquarePen class=class /> }
}

/// SquarePercent icon component (compatibility wrapper)
#[component]
pub fn SquarePercent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquarePercent class=class /> }
}

/// SquarePi icon component (compatibility wrapper)
#[component]
pub fn SquarePi(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquarePi class=class /> }
}

/// SquarePilcrow icon component (compatibility wrapper)
#[component]
pub fn SquarePilcrow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquarePilcrow class=class /> }
}

/// SquarePlay icon component (compatibility wrapper)
#[component]
pub fn SquarePlay(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquarePlay class=class /> }
}

/// SquarePlus icon component (compatibility wrapper)
#[component]
pub fn SquarePlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquarePlus class=class /> }
}

/// SquarePower icon component (compatibility wrapper)
#[component]
pub fn SquarePower(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquarePower class=class /> }
}

/// SquareRadical icon component (compatibility wrapper)
#[component]
pub fn SquareRadical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareRadical class=class /> }
}

/// SquareRoundCorner icon component (compatibility wrapper)
#[component]
pub fn SquareRoundCorner(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareRoundCorner class=class /> }
}

/// SquareScissors icon component (compatibility wrapper)
#[component]
pub fn SquareScissors(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareScissors class=class /> }
}

/// SquareSigma icon component (compatibility wrapper)
#[component]
pub fn SquareSigma(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareSigma class=class /> }
}

/// SquareSlash icon component (compatibility wrapper)
#[component]
pub fn SquareSlash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareSlash class=class /> }
}

/// SquareSplitHorizontal icon component (compatibility wrapper)
#[component]
pub fn SquareSplitHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareSplitHorizontal class=class /> }
}

/// SquareSplitVertical icon component (compatibility wrapper)
#[component]
pub fn SquareSplitVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareSplitVertical class=class /> }
}

/// SquareSquare icon component (compatibility wrapper)
#[component]
pub fn SquareSquare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareSquare class=class /> }
}

/// SquareStack icon component (compatibility wrapper)
#[component]
pub fn SquareStack(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareStack class=class /> }
}

/// SquareStop icon component (compatibility wrapper)
#[component]
pub fn SquareStop(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareStop class=class /> }
}

/// SquareTerminal icon component (compatibility wrapper)
#[component]
pub fn SquareTerminal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareTerminal class=class /> }
}

/// SquareUser icon component (compatibility wrapper)
#[component]
pub fn SquareUser(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareUser class=class /> }
}

/// SquareUserRound icon component (compatibility wrapper)
#[component]
pub fn SquareUserRound(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareUserRound class=class /> }
}

/// SquareX icon component (compatibility wrapper)
#[component]
pub fn SquareX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquareX class=class /> }
}

/// SquaresExclude icon component (compatibility wrapper)
#[component]
pub fn SquaresExclude(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquaresExclude class=class /> }
}

/// SquaresIntersect icon component (compatibility wrapper)
#[component]
pub fn SquaresIntersect(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquaresIntersect class=class /> }
}

/// SquaresSubtract icon component (compatibility wrapper)
#[component]
pub fn SquaresSubtract(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquaresSubtract class=class /> }
}

/// SquaresUnite icon component (compatibility wrapper)
#[component]
pub fn SquaresUnite(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquaresUnite class=class /> }
}

/// Squircle icon component (compatibility wrapper)
#[component]
pub fn Squircle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Squircle class=class /> }
}

/// SquircleDashed icon component (compatibility wrapper)
#[component]
pub fn SquircleDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SquircleDashed class=class /> }
}

/// Squirrel icon component (compatibility wrapper)
#[component]
pub fn Squirrel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Squirrel class=class /> }
}

/// Stamp icon component (compatibility wrapper)
#[component]
pub fn Stamp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Stamp class=class /> }
}

/// Star icon component (compatibility wrapper)
#[component]
pub fn Star(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Star class=class /> }
}

/// StarHalf icon component (compatibility wrapper)
#[component]
pub fn StarHalf(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::StarHalf class=class /> }
}

/// StarOff icon component (compatibility wrapper)
#[component]
pub fn StarOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::StarOff class=class /> }
}

/// StepBack icon component (compatibility wrapper)
#[component]
pub fn StepBack(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::StepBack class=class /> }
}

/// StepForward icon component (compatibility wrapper)
#[component]
pub fn StepForward(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::StepForward class=class /> }
}

/// Stethoscope icon component (compatibility wrapper)
#[component]
pub fn Stethoscope(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Stethoscope class=class /> }
}

/// Sticker icon component (compatibility wrapper)
#[component]
pub fn Sticker(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sticker class=class /> }
}

/// StickyNote icon component (compatibility wrapper)
#[component]
pub fn StickyNote(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::StickyNote class=class /> }
}

/// Store icon component (compatibility wrapper)
#[component]
pub fn Store(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Store class=class /> }
}

/// StretchHorizontal icon component (compatibility wrapper)
#[component]
pub fn StretchHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::StretchHorizontal class=class /> }
}

/// StretchVertical icon component (compatibility wrapper)
#[component]
pub fn StretchVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::StretchVertical class=class /> }
}

/// Strikethrough icon component (compatibility wrapper)
#[component]
pub fn Strikethrough(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Strikethrough class=class /> }
}

/// Subscript icon component (compatibility wrapper)
#[component]
pub fn Subscript(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Subscript class=class /> }
}

/// Sun icon component (compatibility wrapper)
#[component]
pub fn Sun(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sun class=class /> }
}

/// SunDim icon component (compatibility wrapper)
#[component]
pub fn SunDim(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SunDim class=class /> }
}

/// SunMedium icon component (compatibility wrapper)
#[component]
pub fn SunMedium(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SunMedium class=class /> }
}

/// SunMoon icon component (compatibility wrapper)
#[component]
pub fn SunMoon(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SunMoon class=class /> }
}

/// SunSnow icon component (compatibility wrapper)
#[component]
pub fn SunSnow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SunSnow class=class /> }
}

/// Sunrise icon component (compatibility wrapper)
#[component]
pub fn Sunrise(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sunrise class=class /> }
}

/// Sunset icon component (compatibility wrapper)
#[component]
pub fn Sunset(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sunset class=class /> }
}

/// Superscript icon component (compatibility wrapper)
#[component]
pub fn Superscript(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Superscript class=class /> }
}

/// SwatchBook icon component (compatibility wrapper)
#[component]
pub fn SwatchBook(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SwatchBook class=class /> }
}

/// SwissFranc icon component (compatibility wrapper)
#[component]
pub fn SwissFranc(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SwissFranc class=class /> }
}

/// SwitchCamera icon component (compatibility wrapper)
#[component]
pub fn SwitchCamera(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::SwitchCamera class=class /> }
}

/// Sword icon component (compatibility wrapper)
#[component]
pub fn Sword(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Sword class=class /> }
}

/// Swords icon component (compatibility wrapper)
#[component]
pub fn Swords(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Swords class=class /> }
}

/// Syringe icon component (compatibility wrapper)
#[component]
pub fn Syringe(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Syringe class=class /> }
}

/// Table icon component (compatibility wrapper)
#[component]
pub fn Table(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Table class=class /> }
}

/// Table2 icon component (compatibility wrapper)
#[component]
pub fn Table2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Table2 class=class /> }
}

/// TableCellsMerge icon component (compatibility wrapper)
#[component]
pub fn TableCellsMerge(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TableCellsMerge class=class /> }
}

/// TableCellsSplit icon component (compatibility wrapper)
#[component]
pub fn TableCellsSplit(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TableCellsSplit class=class /> }
}

/// TableColumnsSplit icon component (compatibility wrapper)
#[component]
pub fn TableColumnsSplit(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TableColumnsSplit class=class /> }
}

/// TableOfContents icon component (compatibility wrapper)
#[component]
pub fn TableOfContents(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TableOfContents class=class /> }
}

/// TableProperties icon component (compatibility wrapper)
#[component]
pub fn TableProperties(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TableProperties class=class /> }
}

/// TableRowsSplit icon component (compatibility wrapper)
#[component]
pub fn TableRowsSplit(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TableRowsSplit class=class /> }
}

/// Tablet icon component (compatibility wrapper)
#[component]
pub fn Tablet(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tablet class=class /> }
}

/// TabletSmartphone icon component (compatibility wrapper)
#[component]
pub fn TabletSmartphone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TabletSmartphone class=class /> }
}

/// Tablets icon component (compatibility wrapper)
#[component]
pub fn Tablets(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tablets class=class /> }
}

/// Tag icon component (compatibility wrapper)
#[component]
pub fn Tag(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tag class=class /> }
}

/// Tags icon component (compatibility wrapper)
#[component]
pub fn Tags(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tags class=class /> }
}

/// Tally1 icon component (compatibility wrapper)
#[component]
pub fn Tally1(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tally1 class=class /> }
}

/// Tally2 icon component (compatibility wrapper)
#[component]
pub fn Tally2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tally2 class=class /> }
}

/// Tally3 icon component (compatibility wrapper)
#[component]
pub fn Tally3(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tally3 class=class /> }
}

/// Tally4 icon component (compatibility wrapper)
#[component]
pub fn Tally4(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tally4 class=class /> }
}

/// Tally5 icon component (compatibility wrapper)
#[component]
pub fn Tally5(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tally5 class=class /> }
}

/// Tangent icon component (compatibility wrapper)
#[component]
pub fn Tangent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tangent class=class /> }
}

/// Target icon component (compatibility wrapper)
#[component]
pub fn Target(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Target class=class /> }
}

/// Telescope icon component (compatibility wrapper)
#[component]
pub fn Telescope(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Telescope class=class /> }
}

/// Tent icon component (compatibility wrapper)
#[component]
pub fn Tent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tent class=class /> }
}

/// TentTree icon component (compatibility wrapper)
#[component]
pub fn TentTree(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TentTree class=class /> }
}

/// Terminal icon component (compatibility wrapper)
#[component]
pub fn Terminal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Terminal class=class /> }
}

/// TestTube icon component (compatibility wrapper)
#[component]
pub fn TestTube(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TestTube class=class /> }
}

/// TestTubeDiagonal icon component (compatibility wrapper)
#[component]
pub fn TestTubeDiagonal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TestTubeDiagonal class=class /> }
}

/// TestTubes icon component (compatibility wrapper)
#[component]
pub fn TestTubes(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TestTubes class=class /> }
}

/// Text icon component (compatibility wrapper)
#[component]
pub fn Text(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Text class=class /> }
}

/// TextCursor icon component (compatibility wrapper)
#[component]
pub fn TextCursor(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TextCursor class=class /> }
}

/// TextCursorInput icon component (compatibility wrapper)
#[component]
pub fn TextCursorInput(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TextCursorInput class=class /> }
}

/// TextQuote icon component (compatibility wrapper)
#[component]
pub fn TextQuote(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TextQuote class=class /> }
}

/// TextSearch icon component (compatibility wrapper)
#[component]
pub fn TextSearch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TextSearch class=class /> }
}

/// TextSelect icon component (compatibility wrapper)
#[component]
pub fn TextSelect(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TextSelect class=class /> }
}

/// Theater icon component (compatibility wrapper)
#[component]
pub fn Theater(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Theater class=class /> }
}

/// Thermometer icon component (compatibility wrapper)
#[component]
pub fn Thermometer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Thermometer class=class /> }
}

/// ThermometerSnowflake icon component (compatibility wrapper)
#[component]
pub fn ThermometerSnowflake(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ThermometerSnowflake class=class /> }
}

/// ThermometerSun icon component (compatibility wrapper)
#[component]
pub fn ThermometerSun(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ThermometerSun class=class /> }
}

/// ThumbsDown icon component (compatibility wrapper)
#[component]
pub fn ThumbsDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ThumbsDown class=class /> }
}

/// ThumbsUp icon component (compatibility wrapper)
#[component]
pub fn ThumbsUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ThumbsUp class=class /> }
}

/// Ticket icon component (compatibility wrapper)
#[component]
pub fn Ticket(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ticket class=class /> }
}

/// TicketCheck icon component (compatibility wrapper)
#[component]
pub fn TicketCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TicketCheck class=class /> }
}

/// TicketMinus icon component (compatibility wrapper)
#[component]
pub fn TicketMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TicketMinus class=class /> }
}

/// TicketPercent icon component (compatibility wrapper)
#[component]
pub fn TicketPercent(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TicketPercent class=class /> }
}

/// TicketPlus icon component (compatibility wrapper)
#[component]
pub fn TicketPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TicketPlus class=class /> }
}

/// TicketSlash icon component (compatibility wrapper)
#[component]
pub fn TicketSlash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TicketSlash class=class /> }
}

/// TicketX icon component (compatibility wrapper)
#[component]
pub fn TicketX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TicketX class=class /> }
}

/// Tickets icon component (compatibility wrapper)
#[component]
pub fn Tickets(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tickets class=class /> }
}

/// TicketsPlane icon component (compatibility wrapper)
#[component]
pub fn TicketsPlane(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TicketsPlane class=class /> }
}

/// Timer icon component (compatibility wrapper)
#[component]
pub fn Timer(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Timer class=class /> }
}

/// TimerOff icon component (compatibility wrapper)
#[component]
pub fn TimerOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TimerOff class=class /> }
}

/// TimerReset icon component (compatibility wrapper)
#[component]
pub fn TimerReset(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TimerReset class=class /> }
}

/// ToggleLeft icon component (compatibility wrapper)
#[component]
pub fn ToggleLeft(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ToggleLeft class=class /> }
}

/// ToggleRight icon component (compatibility wrapper)
#[component]
pub fn ToggleRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ToggleRight class=class /> }
}

/// Toilet icon component (compatibility wrapper)
#[component]
pub fn Toilet(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Toilet class=class /> }
}

/// ToolCase icon component (compatibility wrapper)
#[component]
pub fn ToolCase(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ToolCase class=class /> }
}

/// Tornado icon component (compatibility wrapper)
#[component]
pub fn Tornado(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tornado class=class /> }
}

/// Torus icon component (compatibility wrapper)
#[component]
pub fn Torus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Torus class=class /> }
}

/// Touchpad icon component (compatibility wrapper)
#[component]
pub fn Touchpad(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Touchpad class=class /> }
}

/// TouchpadOff icon component (compatibility wrapper)
#[component]
pub fn TouchpadOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TouchpadOff class=class /> }
}

/// TowerControl icon component (compatibility wrapper)
#[component]
pub fn TowerControl(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TowerControl class=class /> }
}

/// ToyBrick icon component (compatibility wrapper)
#[component]
pub fn ToyBrick(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ToyBrick class=class /> }
}

/// Tractor icon component (compatibility wrapper)
#[component]
pub fn Tractor(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tractor class=class /> }
}

/// TrafficCone icon component (compatibility wrapper)
#[component]
pub fn TrafficCone(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TrafficCone class=class /> }
}

/// TrainFront icon component (compatibility wrapper)
#[component]
pub fn TrainFront(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TrainFront class=class /> }
}

/// TrainFrontTunnel icon component (compatibility wrapper)
#[component]
pub fn TrainFrontTunnel(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TrainFrontTunnel class=class /> }
}

/// TrainTrack icon component (compatibility wrapper)
#[component]
pub fn TrainTrack(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TrainTrack class=class /> }
}

/// TramFront icon component (compatibility wrapper)
#[component]
pub fn TramFront(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TramFront class=class /> }
}

/// Transgender icon component (compatibility wrapper)
#[component]
pub fn Transgender(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Transgender class=class /> }
}

/// Trash icon component (compatibility wrapper)
#[component]
pub fn Trash(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Trash class=class /> }
}

/// Trash2 icon component (compatibility wrapper)
#[component]
pub fn Trash2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Trash2 class=class /> }
}

/// TreeDeciduous icon component (compatibility wrapper)
#[component]
pub fn TreeDeciduous(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TreeDeciduous class=class /> }
}

/// TreePalm icon component (compatibility wrapper)
#[component]
pub fn TreePalm(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TreePalm class=class /> }
}

/// TreePine icon component (compatibility wrapper)
#[component]
pub fn TreePine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TreePine class=class /> }
}

/// Trees icon component (compatibility wrapper)
#[component]
pub fn Trees(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Trees class=class /> }
}

/// Trello icon component (compatibility wrapper)
#[component]
pub fn Trello(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Trello class=class /> }
}

/// TrendingDown icon component (compatibility wrapper)
#[component]
pub fn TrendingDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TrendingDown class=class /> }
}

/// TrendingUp icon component (compatibility wrapper)
#[component]
pub fn TrendingUp(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TrendingUp class=class /> }
}

/// TrendingUpDown icon component (compatibility wrapper)
#[component]
pub fn TrendingUpDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TrendingUpDown class=class /> }
}

/// Triangle icon component (compatibility wrapper)
#[component]
pub fn Triangle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Triangle class=class /> }
}

/// TriangleAlert icon component (compatibility wrapper)
#[component]
pub fn TriangleAlert(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TriangleAlert class=class /> }
}

/// TriangleDashed icon component (compatibility wrapper)
#[component]
pub fn TriangleDashed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TriangleDashed class=class /> }
}

/// TriangleRight icon component (compatibility wrapper)
#[component]
pub fn TriangleRight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TriangleRight class=class /> }
}

/// Trophy icon component (compatibility wrapper)
#[component]
pub fn Trophy(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Trophy class=class /> }
}

/// Truck icon component (compatibility wrapper)
#[component]
pub fn Truck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Truck class=class /> }
}

/// TruckElectric icon component (compatibility wrapper)
#[component]
pub fn TruckElectric(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TruckElectric class=class /> }
}

/// TurkishLira icon component (compatibility wrapper)
#[component]
pub fn TurkishLira(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TurkishLira class=class /> }
}

/// Turtle icon component (compatibility wrapper)
#[component]
pub fn Turtle(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Turtle class=class /> }
}

/// Tv icon component (compatibility wrapper)
#[component]
pub fn Tv(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Tv class=class /> }
}

/// TvMinimal icon component (compatibility wrapper)
#[component]
pub fn TvMinimal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TvMinimal class=class /> }
}

/// TvMinimalPlay icon component (compatibility wrapper)
#[component]
pub fn TvMinimalPlay(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TvMinimalPlay class=class /> }
}

/// Twitch icon component (compatibility wrapper)
#[component]
pub fn Twitch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Twitch class=class /> }
}

/// Twitter icon component (compatibility wrapper)
#[component]
pub fn Twitter(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Twitter class=class /> }
}

/// Type icon component (compatibility wrapper)
#[component]
pub fn Type(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Type class=class /> }
}

/// TypeOutline icon component (compatibility wrapper)
#[component]
pub fn TypeOutline(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::TypeOutline class=class /> }
}

/// Umbrella icon component (compatibility wrapper)
#[component]
pub fn Umbrella(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Umbrella class=class /> }
}

/// UmbrellaOff icon component (compatibility wrapper)
#[component]
pub fn UmbrellaOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UmbrellaOff class=class /> }
}

/// Underline icon component (compatibility wrapper)
#[component]
pub fn Underline(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Underline class=class /> }
}

/// Undo icon component (compatibility wrapper)
#[component]
pub fn Undo(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Undo class=class /> }
}

/// Undo2 icon component (compatibility wrapper)
#[component]
pub fn Undo2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Undo2 class=class /> }
}

/// UndoDot icon component (compatibility wrapper)
#[component]
pub fn UndoDot(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UndoDot class=class /> }
}

/// UnfoldHorizontal icon component (compatibility wrapper)
#[component]
pub fn UnfoldHorizontal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UnfoldHorizontal class=class /> }
}

/// UnfoldVertical icon component (compatibility wrapper)
#[component]
pub fn UnfoldVertical(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UnfoldVertical class=class /> }
}

/// Ungroup icon component (compatibility wrapper)
#[component]
pub fn Ungroup(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Ungroup class=class /> }
}

/// University icon component (compatibility wrapper)
#[component]
pub fn University(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::University class=class /> }
}

/// Unlink icon component (compatibility wrapper)
#[component]
pub fn Unlink(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Unlink class=class /> }
}

/// Unlink2 icon component (compatibility wrapper)
#[component]
pub fn Unlink2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Unlink2 class=class /> }
}

/// Unplug icon component (compatibility wrapper)
#[component]
pub fn Unplug(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Unplug class=class /> }
}

/// Upload icon component (compatibility wrapper)
#[component]
pub fn Upload(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Upload class=class /> }
}

/// Usb icon component (compatibility wrapper)
#[component]
pub fn Usb(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Usb class=class /> }
}

/// User icon component (compatibility wrapper)
#[component]
pub fn User(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::User class=class /> }
}

/// UserCheck icon component (compatibility wrapper)
#[component]
pub fn UserCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserCheck class=class /> }
}

/// UserCog icon component (compatibility wrapper)
#[component]
pub fn UserCog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserCog class=class /> }
}

/// UserLock icon component (compatibility wrapper)
#[component]
pub fn UserLock(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserLock class=class /> }
}

/// UserMinus icon component (compatibility wrapper)
#[component]
pub fn UserMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserMinus class=class /> }
}

/// UserPen icon component (compatibility wrapper)
#[component]
pub fn UserPen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserPen class=class /> }
}

/// UserPlus icon component (compatibility wrapper)
#[component]
pub fn UserPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserPlus class=class /> }
}

/// UserRound icon component (compatibility wrapper)
#[component]
pub fn UserRound(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserRound class=class /> }
}

/// UserRoundCheck icon component (compatibility wrapper)
#[component]
pub fn UserRoundCheck(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserRoundCheck class=class /> }
}

/// UserRoundCog icon component (compatibility wrapper)
#[component]
pub fn UserRoundCog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserRoundCog class=class /> }
}

/// UserRoundMinus icon component (compatibility wrapper)
#[component]
pub fn UserRoundMinus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserRoundMinus class=class /> }
}

/// UserRoundPen icon component (compatibility wrapper)
#[component]
pub fn UserRoundPen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserRoundPen class=class /> }
}

/// UserRoundPlus icon component (compatibility wrapper)
#[component]
pub fn UserRoundPlus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserRoundPlus class=class /> }
}

/// UserRoundSearch icon component (compatibility wrapper)
#[component]
pub fn UserRoundSearch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserRoundSearch class=class /> }
}

/// UserRoundX icon component (compatibility wrapper)
#[component]
pub fn UserRoundX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserRoundX class=class /> }
}

/// UserSearch icon component (compatibility wrapper)
#[component]
pub fn UserSearch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserSearch class=class /> }
}

/// UserStar icon component (compatibility wrapper)
#[component]
pub fn UserStar(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserStar class=class /> }
}

/// UserX icon component (compatibility wrapper)
#[component]
pub fn UserX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UserX class=class /> }
}

/// Users icon component (compatibility wrapper)
#[component]
pub fn Users(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Users class=class /> }
}

/// UsersRound icon component (compatibility wrapper)
#[component]
pub fn UsersRound(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UsersRound class=class /> }
}

/// Utensils icon component (compatibility wrapper)
#[component]
pub fn Utensils(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Utensils class=class /> }
}

/// UtensilsCrossed icon component (compatibility wrapper)
#[component]
pub fn UtensilsCrossed(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UtensilsCrossed class=class /> }
}

/// UtilityPole icon component (compatibility wrapper)
#[component]
pub fn UtilityPole(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::UtilityPole class=class /> }
}

/// Variable icon component (compatibility wrapper)
#[component]
pub fn Variable(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Variable class=class /> }
}

/// Vault icon component (compatibility wrapper)
#[component]
pub fn Vault(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Vault class=class /> }
}

/// VectorSquare icon component (compatibility wrapper)
#[component]
pub fn VectorSquare(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::VectorSquare class=class /> }
}

/// Vegan icon component (compatibility wrapper)
#[component]
pub fn Vegan(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Vegan class=class /> }
}

/// VenetianMask icon component (compatibility wrapper)
#[component]
pub fn VenetianMask(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::VenetianMask class=class /> }
}

/// Venus icon component (compatibility wrapper)
#[component]
pub fn Venus(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Venus class=class /> }
}

/// VenusAndMars icon component (compatibility wrapper)
#[component]
pub fn VenusAndMars(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::VenusAndMars class=class /> }
}

/// Vibrate icon component (compatibility wrapper)
#[component]
pub fn Vibrate(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Vibrate class=class /> }
}

/// VibrateOff icon component (compatibility wrapper)
#[component]
pub fn VibrateOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::VibrateOff class=class /> }
}

/// Video icon component (compatibility wrapper)
#[component]
pub fn Video(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Video class=class /> }
}

/// VideoOff icon component (compatibility wrapper)
#[component]
pub fn VideoOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::VideoOff class=class /> }
}

/// Videotape icon component (compatibility wrapper)
#[component]
pub fn Videotape(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Videotape class=class /> }
}

/// View icon component (compatibility wrapper)
#[component]
pub fn View(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::View class=class /> }
}

/// Voicemail icon component (compatibility wrapper)
#[component]
pub fn Voicemail(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Voicemail class=class /> }
}

/// Volleyball icon component (compatibility wrapper)
#[component]
pub fn Volleyball(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Volleyball class=class /> }
}

/// Volume icon component (compatibility wrapper)
#[component]
pub fn Volume(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Volume class=class /> }
}

/// Volume1 icon component (compatibility wrapper)
#[component]
pub fn Volume1(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Volume1 class=class /> }
}

/// Volume2 icon component (compatibility wrapper)
#[component]
pub fn Volume2(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Volume2 class=class /> }
}

/// VolumeOff icon component (compatibility wrapper)
#[component]
pub fn VolumeOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::VolumeOff class=class /> }
}

/// VolumeX icon component (compatibility wrapper)
#[component]
pub fn VolumeX(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::VolumeX class=class /> }
}

/// Vote icon component (compatibility wrapper)
#[component]
pub fn Vote(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Vote class=class /> }
}

/// Wallet icon component (compatibility wrapper)
#[component]
pub fn Wallet(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Wallet class=class /> }
}

/// WalletCards icon component (compatibility wrapper)
#[component]
pub fn WalletCards(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WalletCards class=class /> }
}

/// WalletMinimal icon component (compatibility wrapper)
#[component]
pub fn WalletMinimal(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WalletMinimal class=class /> }
}

/// Wallpaper icon component (compatibility wrapper)
#[component]
pub fn Wallpaper(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Wallpaper class=class /> }
}

/// Wand icon component (compatibility wrapper)
#[component]
pub fn Wand(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Wand class=class /> }
}

/// WandSparkles icon component (compatibility wrapper)
#[component]
pub fn WandSparkles(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WandSparkles class=class /> }
}

/// Warehouse icon component (compatibility wrapper)
#[component]
pub fn Warehouse(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Warehouse class=class /> }
}

/// WashingMachine icon component (compatibility wrapper)
#[component]
pub fn WashingMachine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WashingMachine class=class /> }
}

/// Watch icon component (compatibility wrapper)
#[component]
pub fn Watch(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Watch class=class /> }
}

/// Waves icon component (compatibility wrapper)
#[component]
pub fn Waves(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Waves class=class /> }
}

/// WavesLadder icon component (compatibility wrapper)
#[component]
pub fn WavesLadder(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WavesLadder class=class /> }
}

/// Waypoints icon component (compatibility wrapper)
#[component]
pub fn Waypoints(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Waypoints class=class /> }
}

/// Webcam icon component (compatibility wrapper)
#[component]
pub fn Webcam(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Webcam class=class /> }
}

/// Webhook icon component (compatibility wrapper)
#[component]
pub fn Webhook(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Webhook class=class /> }
}

/// WebhookOff icon component (compatibility wrapper)
#[component]
pub fn WebhookOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WebhookOff class=class /> }
}

/// Weight icon component (compatibility wrapper)
#[component]
pub fn Weight(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Weight class=class /> }
}

/// Wheat icon component (compatibility wrapper)
#[component]
pub fn Wheat(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Wheat class=class /> }
}

/// WheatOff icon component (compatibility wrapper)
#[component]
pub fn WheatOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WheatOff class=class /> }
}

/// WholeWord icon component (compatibility wrapper)
#[component]
pub fn WholeWord(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WholeWord class=class /> }
}

/// Wifi icon component (compatibility wrapper)
#[component]
pub fn Wifi(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Wifi class=class /> }
}

/// WifiCog icon component (compatibility wrapper)
#[component]
pub fn WifiCog(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WifiCog class=class /> }
}

/// WifiHigh icon component (compatibility wrapper)
#[component]
pub fn WifiHigh(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WifiHigh class=class /> }
}

/// WifiLow icon component (compatibility wrapper)
#[component]
pub fn WifiLow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WifiLow class=class /> }
}

/// WifiOff icon component (compatibility wrapper)
#[component]
pub fn WifiOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WifiOff class=class /> }
}

/// WifiPen icon component (compatibility wrapper)
#[component]
pub fn WifiPen(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WifiPen class=class /> }
}

/// WifiSync icon component (compatibility wrapper)
#[component]
pub fn WifiSync(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WifiSync class=class /> }
}

/// WifiZero icon component (compatibility wrapper)
#[component]
pub fn WifiZero(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WifiZero class=class /> }
}

/// Wind icon component (compatibility wrapper)
#[component]
pub fn Wind(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Wind class=class /> }
}

/// WindArrowDown icon component (compatibility wrapper)
#[component]
pub fn WindArrowDown(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WindArrowDown class=class /> }
}

/// Wine icon component (compatibility wrapper)
#[component]
pub fn Wine(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Wine class=class /> }
}

/// WineOff icon component (compatibility wrapper)
#[component]
pub fn WineOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WineOff class=class /> }
}

/// Workflow icon component (compatibility wrapper)
#[component]
pub fn Workflow(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Workflow class=class /> }
}

/// Worm icon component (compatibility wrapper)
#[component]
pub fn Worm(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Worm class=class /> }
}

/// WrapText icon component (compatibility wrapper)
#[component]
pub fn WrapText(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::WrapText class=class /> }
}

/// Wrench icon component (compatibility wrapper)
#[component]
pub fn Wrench(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Wrench class=class /> }
}

/// X icon component (compatibility wrapper)
#[component]
pub fn X(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::X class=class /> }
}

/// Youtube icon component (compatibility wrapper)
#[component]
pub fn Youtube(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Youtube class=class /> }
}

/// Zap icon component (compatibility wrapper)
#[component]
pub fn Zap(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::Zap class=class /> }
}

/// ZapOff icon component (compatibility wrapper)
#[component]
pub fn ZapOff(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ZapOff class=class /> }
}

/// ZoomIn icon component (compatibility wrapper)
#[component]
pub fn ZoomIn(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ZoomIn class=class /> }
}

/// ZoomOut icon component (compatibility wrapper)
#[component]
pub fn ZoomOut(#[prop(into, optional)] class: Signal<String>) -> impl IntoView {
    view! { <LeptosIcon icon=IconType::ZoomOut class=class /> }
}

/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/*                        🧪 TESTS 🧪                         */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_compatibility_activity() {
        let _icon = view! { <Activity class="test-class" /> };
    }

    #[test]
    fn test_compatibility_arrow_right() {
        let _icon = view! { <ArrowRight class="test-class" /> };
    }

    #[test]
    fn test_compatibility_a_arrow_down() {
        let _icon = view! { <AArrowDown class="test-class" /> };
    }

    #[test]
    fn test_all_compatibility_functions_exist() {
        // Test that key compatibility functions exist
        let class = "test-class";

        // Test a few representative functions
        let _activity = view! { <Activity class=class /> };
        let _arrow_right = view! { <ArrowRight class=class /> };
        let _accessibility = view! { <Accessibility class=class /> };
        let _alarm_clock = view! { <AlarmClock class=class /> };
    }

    #[test]
    fn test_compatibility_vs_direct_icon() {
        let class = "test-class";

        // Both should create equivalent components
        let _compat_icon = view! { <Activity class=class /> };
        let _direct_icon = view! { <LeptosIcon icon=IconType::Activity class=class /> };

        // They should use the same underlying implementation
        // (This is more of a conceptual test - both go through the registry)
    }
}