use dioxus::prelude::*;

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

#[component]
pub fn AArrowDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AArrowDown, class }
    }
}

#[component]
pub fn AArrowUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AArrowUp, class }
    }
}

#[component]
pub fn ALargeSmall(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ALargeSmall, class }
    }
}

#[component]
pub fn Accessibility(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Accessibility, class }
    }
}

#[component]
pub fn Activity(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Activity, class }
    }
}

#[component]
pub fn AirVent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AirVent, class }
    }
}

#[component]
pub fn Airplay(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Airplay, class }
    }
}

#[component]
pub fn AlarmClockCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlarmClockCheck, class }
    }
}

#[component]
pub fn AlarmClockMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlarmClockMinus, class }
    }
}

#[component]
pub fn AlarmClockOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlarmClockOff, class }
    }
}

#[component]
pub fn AlarmClockPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlarmClockPlus, class }
    }
}

#[component]
pub fn AlarmClock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlarmClock, class }
    }
}

#[component]
pub fn AlarmSmoke(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlarmSmoke, class }
    }
}

#[component]
pub fn Album(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Album, class }
    }
}

#[component]
pub fn AlignCenterHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignCenterHorizontal, class }
    }
}

#[component]
pub fn AlignCenterVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignCenterVertical, class }
    }
}

#[component]
pub fn AlignCenter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignCenter, class }
    }
}

#[component]
pub fn AlignEndHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignEndHorizontal, class }
    }
}

#[component]
pub fn AlignEndVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignEndVertical, class }
    }
}

#[component]
pub fn AlignHorizontalDistributeCenter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignHorizontalDistributeCenter, class }
    }
}

#[component]
pub fn AlignHorizontalDistributeEnd(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignHorizontalDistributeEnd, class }
    }
}

#[component]
pub fn AlignHorizontalDistributeStart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignHorizontalDistributeStart, class }
    }
}

#[component]
pub fn AlignHorizontalJustifyCenter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignHorizontalJustifyCenter, class }
    }
}

#[component]
pub fn AlignHorizontalJustifyEnd(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignHorizontalJustifyEnd, class }
    }
}

#[component]
pub fn AlignHorizontalJustifyStart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignHorizontalJustifyStart, class }
    }
}

#[component]
pub fn AlignHorizontalSpaceAround(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignHorizontalSpaceAround, class }
    }
}

#[component]
pub fn AlignHorizontalSpaceBetween(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignHorizontalSpaceBetween, class }
    }
}

#[component]
pub fn AlignJustify(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignJustify, class }
    }
}

#[component]
pub fn AlignLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignLeft, class }
    }
}

#[component]
pub fn AlignRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignRight, class }
    }
}

#[component]
pub fn AlignStartHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignStartHorizontal, class }
    }
}

#[component]
pub fn AlignStartVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignStartVertical, class }
    }
}

#[component]
pub fn AlignVerticalDistributeCenter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignVerticalDistributeCenter, class }
    }
}

#[component]
pub fn AlignVerticalDistributeEnd(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignVerticalDistributeEnd, class }
    }
}

#[component]
pub fn AlignVerticalDistributeStart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignVerticalDistributeStart, class }
    }
}

#[component]
pub fn AlignVerticalJustifyCenter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignVerticalJustifyCenter, class }
    }
}

#[component]
pub fn AlignVerticalJustifyEnd(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignVerticalJustifyEnd, class }
    }
}

#[component]
pub fn AlignVerticalJustifyStart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignVerticalJustifyStart, class }
    }
}

#[component]
pub fn AlignVerticalSpaceAround(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignVerticalSpaceAround, class }
    }
}

#[component]
pub fn AlignVerticalSpaceBetween(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AlignVerticalSpaceBetween, class }
    }
}

#[component]
pub fn Ambulance(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ambulance, class }
    }
}

#[component]
pub fn Ampersand(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ampersand, class }
    }
}

#[component]
pub fn Ampersands(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ampersands, class }
    }
}

#[component]
pub fn Amphora(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Amphora, class }
    }
}

#[component]
pub fn Anchor(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Anchor, class }
    }
}

#[component]
pub fn Angry(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Angry, class }
    }
}

#[component]
pub fn Annoyed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Annoyed, class }
    }
}

#[component]
pub fn Antenna(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Antenna, class }
    }
}

#[component]
pub fn Anvil(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Anvil, class }
    }
}

#[component]
pub fn Aperture(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Aperture, class }
    }
}

#[component]
pub fn AppWindowMac(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AppWindowMac, class }
    }
}

#[component]
pub fn AppWindow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AppWindow, class }
    }
}

#[component]
pub fn Apple(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Apple, class }
    }
}

#[component]
pub fn ArchiveRestore(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArchiveRestore, class }
    }
}

#[component]
pub fn ArchiveX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArchiveX, class }
    }
}

#[component]
pub fn Archive(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Archive, class }
    }
}

#[component]
pub fn Armchair(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Armchair, class }
    }
}

#[component]
pub fn ArrowBigDownDash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowBigDownDash, class }
    }
}

#[component]
pub fn ArrowBigDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowBigDown, class }
    }
}

#[component]
pub fn ArrowBigLeftDash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowBigLeftDash, class }
    }
}

#[component]
pub fn ArrowBigLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowBigLeft, class }
    }
}

#[component]
pub fn ArrowBigRightDash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowBigRightDash, class }
    }
}

#[component]
pub fn ArrowBigRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowBigRight, class }
    }
}

#[component]
pub fn ArrowBigUpDash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowBigUpDash, class }
    }
}

#[component]
pub fn ArrowBigUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowBigUp, class }
    }
}

#[component]
pub fn ArrowDown01(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDown01, class }
    }
}

#[component]
pub fn ArrowDown10(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDown10, class }
    }
}

#[component]
pub fn ArrowDownAZ(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDownAZ, class }
    }
}

#[component]
pub fn ArrowDownFromLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDownFromLine, class }
    }
}

#[component]
pub fn ArrowDownLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDownLeft, class }
    }
}

#[component]
pub fn ArrowDownNarrowWide(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDownNarrowWide, class }
    }
}

#[component]
pub fn ArrowDownRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDownRight, class }
    }
}

#[component]
pub fn ArrowDownToDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDownToDot, class }
    }
}

#[component]
pub fn ArrowDownToLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDownToLine, class }
    }
}

#[component]
pub fn ArrowDownUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDownUp, class }
    }
}

#[component]
pub fn ArrowDownWideNarrow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDownWideNarrow, class }
    }
}

#[component]
pub fn ArrowDownZA(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDownZA, class }
    }
}

#[component]
pub fn ArrowDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowDown, class }
    }
}

#[component]
pub fn ArrowLeftFromLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowLeftFromLine, class }
    }
}

#[component]
pub fn ArrowLeftRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowLeftRight, class }
    }
}

#[component]
pub fn ArrowLeftToLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowLeftToLine, class }
    }
}

#[component]
pub fn ArrowLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowLeft, class }
    }
}

#[component]
pub fn ArrowRightFromLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowRightFromLine, class }
    }
}

#[component]
pub fn ArrowRightLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowRightLeft, class }
    }
}

#[component]
pub fn ArrowRightToLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowRightToLine, class }
    }
}

#[component]
pub fn ArrowRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowRight, class }
    }
}

#[component]
pub fn ArrowUp01(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUp01, class }
    }
}

#[component]
pub fn ArrowUp10(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUp10, class }
    }
}

#[component]
pub fn ArrowUpAZ(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUpAZ, class }
    }
}

#[component]
pub fn ArrowUpDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUpDown, class }
    }
}

#[component]
pub fn ArrowUpFromDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUpFromDot, class }
    }
}

#[component]
pub fn ArrowUpFromLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUpFromLine, class }
    }
}

#[component]
pub fn ArrowUpLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUpLeft, class }
    }
}

#[component]
pub fn ArrowUpNarrowWide(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUpNarrowWide, class }
    }
}

#[component]
pub fn ArrowUpRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUpRight, class }
    }
}

#[component]
pub fn ArrowUpToLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUpToLine, class }
    }
}

#[component]
pub fn ArrowUpWideNarrow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUpWideNarrow, class }
    }
}

#[component]
pub fn ArrowUpZA(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUpZA, class }
    }
}

#[component]
pub fn ArrowUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowUp, class }
    }
}

#[component]
pub fn ArrowsUpFromLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ArrowsUpFromLine, class }
    }
}

#[component]
pub fn Asterisk(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Asterisk, class }
    }
}

#[component]
pub fn AtSign(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AtSign, class }
    }
}

#[component]
pub fn Atom(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Atom, class }
    }
}

#[component]
pub fn AudioLines(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AudioLines, class }
    }
}

#[component]
pub fn AudioWaveform(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::AudioWaveform, class }
    }
}

#[component]
pub fn Award(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Award, class }
    }
}

#[component]
pub fn Axe(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Axe, class }
    }
}

#[component]
pub fn Axis3D(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Axis3D, class }
    }
}

#[component]
pub fn Baby(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Baby, class }
    }
}

#[component]
pub fn Backpack(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Backpack, class }
    }
}

#[component]
pub fn BadgeAlert(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeAlert, class }
    }
}

#[component]
pub fn BadgeCent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeCent, class }
    }
}

#[component]
pub fn BadgeCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeCheck, class }
    }
}

#[component]
pub fn BadgeDollarSign(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeDollarSign, class }
    }
}

#[component]
pub fn BadgeEuro(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeEuro, class }
    }
}

#[component]
pub fn BadgeHelp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeHelp, class }
    }
}

#[component]
pub fn BadgeIndianRupee(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeIndianRupee, class }
    }
}

#[component]
pub fn BadgeInfo(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeInfo, class }
    }
}

#[component]
pub fn BadgeJapaneseYen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeJapaneseYen, class }
    }
}

#[component]
pub fn BadgeMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeMinus, class }
    }
}

#[component]
pub fn BadgePercent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgePercent, class }
    }
}

#[component]
pub fn BadgePlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgePlus, class }
    }
}

#[component]
pub fn BadgePoundSterling(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgePoundSterling, class }
    }
}

#[component]
pub fn BadgeQuestionMark(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeQuestionMark, class }
    }
}

#[component]
pub fn BadgeRussianRuble(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeRussianRuble, class }
    }
}

#[component]
pub fn BadgeSwissFranc(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeSwissFranc, class }
    }
}

#[component]
pub fn BadgeTurkishLira(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeTurkishLira, class }
    }
}

#[component]
pub fn BadgeX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BadgeX, class }
    }
}

#[component]
pub fn Badge(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Badge, class }
    }
}

#[component]
pub fn BaggageClaim(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BaggageClaim, class }
    }
}

#[component]
pub fn Ban(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ban, class }
    }
}

#[component]
pub fn Banana(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Banana, class }
    }
}

#[component]
pub fn Bandage(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bandage, class }
    }
}

#[component]
pub fn BanknoteArrowDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BanknoteArrowDown, class }
    }
}

#[component]
pub fn BanknoteArrowUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BanknoteArrowUp, class }
    }
}

#[component]
pub fn BanknoteX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BanknoteX, class }
    }
}

#[component]
pub fn Banknote(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Banknote, class }
    }
}

#[component]
pub fn Barcode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Barcode, class }
    }
}

#[component]
pub fn Barrel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Barrel, class }
    }
}

#[component]
pub fn Baseline(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Baseline, class }
    }
}

#[component]
pub fn Bath(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bath, class }
    }
}

#[component]
pub fn BatteryCharging(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BatteryCharging, class }
    }
}

#[component]
pub fn BatteryFull(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BatteryFull, class }
    }
}

#[component]
pub fn BatteryLow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BatteryLow, class }
    }
}

#[component]
pub fn BatteryMedium(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BatteryMedium, class }
    }
}

#[component]
pub fn BatteryPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BatteryPlus, class }
    }
}

#[component]
pub fn BatteryWarning(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BatteryWarning, class }
    }
}

#[component]
pub fn Battery(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Battery, class }
    }
}

#[component]
pub fn Beaker(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Beaker, class }
    }
}

#[component]
pub fn BeanOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BeanOff, class }
    }
}

#[component]
pub fn Bean(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bean, class }
    }
}

#[component]
pub fn BedDouble(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BedDouble, class }
    }
}

#[component]
pub fn BedSingle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BedSingle, class }
    }
}

#[component]
pub fn Bed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bed, class }
    }
}

#[component]
pub fn Beef(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Beef, class }
    }
}

#[component]
pub fn BeerOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BeerOff, class }
    }
}

#[component]
pub fn Beer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Beer, class }
    }
}

#[component]
pub fn BellDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BellDot, class }
    }
}

#[component]
pub fn BellElectric(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BellElectric, class }
    }
}

#[component]
pub fn BellMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BellMinus, class }
    }
}

#[component]
pub fn BellOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BellOff, class }
    }
}

#[component]
pub fn BellPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BellPlus, class }
    }
}

#[component]
pub fn BellRing(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BellRing, class }
    }
}

#[component]
pub fn Bell(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bell, class }
    }
}

#[component]
pub fn BetweenHorizontalEnd(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BetweenHorizontalEnd, class }
    }
}

#[component]
pub fn BetweenHorizontalStart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BetweenHorizontalStart, class }
    }
}

#[component]
pub fn BetweenVerticalEnd(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BetweenVerticalEnd, class }
    }
}

#[component]
pub fn BetweenVerticalStart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BetweenVerticalStart, class }
    }
}

#[component]
pub fn BicepsFlexed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BicepsFlexed, class }
    }
}

#[component]
pub fn Bike(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bike, class }
    }
}

#[component]
pub fn Binary(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Binary, class }
    }
}

#[component]
pub fn Binoculars(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Binoculars, class }
    }
}

#[component]
pub fn Biohazard(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Biohazard, class }
    }
}

#[component]
pub fn Bird(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bird, class }
    }
}

#[component]
pub fn Bitcoin(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bitcoin, class }
    }
}

#[component]
pub fn Blend(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Blend, class }
    }
}

#[component]
pub fn Blinds(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Blinds, class }
    }
}

#[component]
pub fn Blocks(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Blocks, class }
    }
}

#[component]
pub fn BluetoothConnected(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BluetoothConnected, class }
    }
}

#[component]
pub fn BluetoothOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BluetoothOff, class }
    }
}

#[component]
pub fn BluetoothSearching(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BluetoothSearching, class }
    }
}

#[component]
pub fn Bluetooth(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bluetooth, class }
    }
}

#[component]
pub fn Bold(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bold, class }
    }
}

#[component]
pub fn Bolt(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bolt, class }
    }
}

#[component]
pub fn Bomb(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bomb, class }
    }
}

#[component]
pub fn Bone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bone, class }
    }
}

#[component]
pub fn BookA(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookA, class }
    }
}

#[component]
pub fn BookAlert(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookAlert, class }
    }
}

#[component]
pub fn BookAudio(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookAudio, class }
    }
}

#[component]
pub fn BookCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookCheck, class }
    }
}

#[component]
pub fn BookCopy(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookCopy, class }
    }
}

#[component]
pub fn BookDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookDashed, class }
    }
}

#[component]
pub fn BookDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookDown, class }
    }
}

#[component]
pub fn BookHeadphones(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookHeadphones, class }
    }
}

#[component]
pub fn BookHeart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookHeart, class }
    }
}

#[component]
pub fn BookImage(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookImage, class }
    }
}

#[component]
pub fn BookKey(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookKey, class }
    }
}

#[component]
pub fn BookLock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookLock, class }
    }
}

#[component]
pub fn BookMarked(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookMarked, class }
    }
}

#[component]
pub fn BookMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookMinus, class }
    }
}

#[component]
pub fn BookOpenCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookOpenCheck, class }
    }
}

#[component]
pub fn BookOpenText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookOpenText, class }
    }
}

#[component]
pub fn BookOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookOpen, class }
    }
}

#[component]
pub fn BookPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookPlus, class }
    }
}

#[component]
pub fn BookText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookText, class }
    }
}

#[component]
pub fn BookType(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookType, class }
    }
}

#[component]
pub fn BookUp2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookUp2, class }
    }
}

#[component]
pub fn BookUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookUp, class }
    }
}

#[component]
pub fn BookUser(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookUser, class }
    }
}

#[component]
pub fn BookX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookX, class }
    }
}

#[component]
pub fn Book(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Book, class }
    }
}

#[component]
pub fn BookmarkCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookmarkCheck, class }
    }
}

#[component]
pub fn BookmarkMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookmarkMinus, class }
    }
}

#[component]
pub fn BookmarkPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookmarkPlus, class }
    }
}

#[component]
pub fn BookmarkX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BookmarkX, class }
    }
}

#[component]
pub fn Bookmark(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bookmark, class }
    }
}

#[component]
pub fn BoomBox(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BoomBox, class }
    }
}

#[component]
pub fn BotMessageSquare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BotMessageSquare, class }
    }
}

#[component]
pub fn BotOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BotOff, class }
    }
}

#[component]
pub fn Bot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bot, class }
    }
}

#[component]
pub fn BottleWine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BottleWine, class }
    }
}

#[component]
pub fn BowArrow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BowArrow, class }
    }
}

// #[component]
// pub fn Box(class: Option<String>) -> Element {
//     rsx! {
//         DioxusIcon { icon: IconType::Box, class }
//     }
// }

#[component]
pub fn Boxes(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Boxes, class }
    }
}

#[component]
pub fn Braces(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Braces, class }
    }
}

#[component]
pub fn Brackets(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Brackets, class }
    }
}

#[component]
pub fn BrainCircuit(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BrainCircuit, class }
    }
}

#[component]
pub fn BrainCog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BrainCog, class }
    }
}

#[component]
pub fn Brain(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Brain, class }
    }
}

#[component]
pub fn BrickWallFire(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BrickWallFire, class }
    }
}

#[component]
pub fn BrickWall(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BrickWall, class }
    }
}

#[component]
pub fn BriefcaseBusiness(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BriefcaseBusiness, class }
    }
}

#[component]
pub fn BriefcaseConveyorBelt(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BriefcaseConveyorBelt, class }
    }
}

#[component]
pub fn BriefcaseMedical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BriefcaseMedical, class }
    }
}

#[component]
pub fn Briefcase(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Briefcase, class }
    }
}

#[component]
pub fn BringToFront(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BringToFront, class }
    }
}

#[component]
pub fn BrushCleaning(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BrushCleaning, class }
    }
}

#[component]
pub fn Brush(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Brush, class }
    }
}

#[component]
pub fn Bubbles(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bubbles, class }
    }
}

#[component]
pub fn BugOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BugOff, class }
    }
}

#[component]
pub fn BugPlay(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BugPlay, class }
    }
}

#[component]
pub fn Bug(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bug, class }
    }
}

#[component]
pub fn Building2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Building2, class }
    }
}

#[component]
pub fn Building(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Building, class }
    }
}

#[component]
pub fn BusFront(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::BusFront, class }
    }
}

#[component]
pub fn Bus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Bus, class }
    }
}

#[component]
pub fn CableCar(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CableCar, class }
    }
}

#[component]
pub fn Cable(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cable, class }
    }
}

#[component]
pub fn CakeSlice(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CakeSlice, class }
    }
}

#[component]
pub fn Cake(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cake, class }
    }
}

#[component]
pub fn Calculator(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Calculator, class }
    }
}

#[component]
pub fn Calendar1(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Calendar1, class }
    }
}

#[component]
pub fn CalendarArrowDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarArrowDown, class }
    }
}

#[component]
pub fn CalendarArrowUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarArrowUp, class }
    }
}

#[component]
pub fn CalendarCheck2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarCheck2, class }
    }
}

#[component]
pub fn CalendarCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarCheck, class }
    }
}

#[component]
pub fn CalendarClock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarClock, class }
    }
}

#[component]
pub fn CalendarCog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarCog, class }
    }
}

#[component]
pub fn CalendarDays(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarDays, class }
    }
}

#[component]
pub fn CalendarFold(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarFold, class }
    }
}

#[component]
pub fn CalendarHeart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarHeart, class }
    }
}

#[component]
pub fn CalendarMinus2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarMinus2, class }
    }
}

#[component]
pub fn CalendarMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarMinus, class }
    }
}

#[component]
pub fn CalendarOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarOff, class }
    }
}

#[component]
pub fn CalendarPlus2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarPlus2, class }
    }
}

#[component]
pub fn CalendarPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarPlus, class }
    }
}

#[component]
pub fn CalendarRange(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarRange, class }
    }
}

#[component]
pub fn CalendarSearch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarSearch, class }
    }
}

#[component]
pub fn CalendarSync(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarSync, class }
    }
}

#[component]
pub fn CalendarX2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarX2, class }
    }
}

#[component]
pub fn CalendarX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CalendarX, class }
    }
}

#[component]
pub fn Calendar(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Calendar, class }
    }
}

#[component]
pub fn CameraOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CameraOff, class }
    }
}

#[component]
pub fn Camera(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Camera, class }
    }
}

#[component]
pub fn CandyCane(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CandyCane, class }
    }
}

#[component]
pub fn CandyOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CandyOff, class }
    }
}

#[component]
pub fn Candy(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Candy, class }
    }
}

#[component]
pub fn Cannabis(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cannabis, class }
    }
}

#[component]
pub fn CaptionsOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CaptionsOff, class }
    }
}

#[component]
pub fn Captions(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Captions, class }
    }
}

#[component]
pub fn CarFront(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CarFront, class }
    }
}

#[component]
pub fn CarTaxiFront(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CarTaxiFront, class }
    }
}

#[component]
pub fn Car(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Car, class }
    }
}

#[component]
pub fn Caravan(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Caravan, class }
    }
}

#[component]
pub fn CardSim(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CardSim, class }
    }
}

#[component]
pub fn Carrot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Carrot, class }
    }
}

#[component]
pub fn CaseLower(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CaseLower, class }
    }
}

#[component]
pub fn CaseSensitive(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CaseSensitive, class }
    }
}

#[component]
pub fn CaseUpper(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CaseUpper, class }
    }
}

#[component]
pub fn CassetteTape(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CassetteTape, class }
    }
}

#[component]
pub fn Cast(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cast, class }
    }
}

#[component]
pub fn Castle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Castle, class }
    }
}

#[component]
pub fn Cat(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cat, class }
    }
}

#[component]
pub fn Cctv(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cctv, class }
    }
}

#[component]
pub fn ChartArea(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartArea, class }
    }
}

#[component]
pub fn ChartBarBig(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartBarBig, class }
    }
}

#[component]
pub fn ChartBarDecreasing(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartBarDecreasing, class }
    }
}

#[component]
pub fn ChartBarIncreasing(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartBarIncreasing, class }
    }
}

#[component]
pub fn ChartBarStacked(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartBarStacked, class }
    }
}

#[component]
pub fn ChartBar(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartBar, class }
    }
}

#[component]
pub fn ChartCandlestick(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartCandlestick, class }
    }
}

#[component]
pub fn ChartColumnBig(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartColumnBig, class }
    }
}

#[component]
pub fn ChartColumnDecreasing(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartColumnDecreasing, class }
    }
}

#[component]
pub fn ChartColumnIncreasing(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartColumnIncreasing, class }
    }
}

#[component]
pub fn ChartColumnStacked(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartColumnStacked, class }
    }
}

#[component]
pub fn ChartColumn(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartColumn, class }
    }
}

#[component]
pub fn ChartGantt(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartGantt, class }
    }
}

#[component]
pub fn ChartLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartLine, class }
    }
}

#[component]
pub fn ChartNetwork(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartNetwork, class }
    }
}

#[component]
pub fn ChartNoAxesColumnDecreasing(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartNoAxesColumnDecreasing, class }
    }
}

#[component]
pub fn ChartNoAxesColumnIncreasing(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartNoAxesColumnIncreasing, class }
    }
}

#[component]
pub fn ChartNoAxesColumn(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartNoAxesColumn, class }
    }
}

#[component]
pub fn ChartNoAxesCombined(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartNoAxesCombined, class }
    }
}

#[component]
pub fn ChartNoAxesGantt(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartNoAxesGantt, class }
    }
}

#[component]
pub fn ChartPie(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartPie, class }
    }
}

#[component]
pub fn ChartScatter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartScatter, class }
    }
}

#[component]
pub fn ChartSpline(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChartSpline, class }
    }
}

#[component]
pub fn CheckCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CheckCheck, class }
    }
}

#[component]
pub fn CheckLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CheckLine, class }
    }
}

#[component]
pub fn Check(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Check, class }
    }
}

#[component]
pub fn ChefHat(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChefHat, class }
    }
}

#[component]
pub fn Cherry(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cherry, class }
    }
}

#[component]
pub fn ChevronDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronDown, class }
    }
}

#[component]
pub fn ChevronFirst(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronFirst, class }
    }
}

#[component]
pub fn ChevronLast(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronLast, class }
    }
}

#[component]
pub fn ChevronLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronLeft, class }
    }
}

#[component]
pub fn ChevronRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronRight, class }
    }
}

#[component]
pub fn ChevronUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronUp, class }
    }
}

#[component]
pub fn ChevronsDownUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronsDownUp, class }
    }
}

#[component]
pub fn ChevronsDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronsDown, class }
    }
}

#[component]
pub fn ChevronsLeftRightEllipsis(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronsLeftRightEllipsis, class }
    }
}

#[component]
pub fn ChevronsLeftRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronsLeftRight, class }
    }
}

#[component]
pub fn ChevronsLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronsLeft, class }
    }
}

#[component]
pub fn ChevronsRightLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronsRightLeft, class }
    }
}

#[component]
pub fn ChevronsRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronsRight, class }
    }
}

#[component]
pub fn ChevronsUpDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronsUpDown, class }
    }
}

#[component]
pub fn ChevronsUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ChevronsUp, class }
    }
}

#[component]
pub fn Chrome(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Chrome, class }
    }
}

#[component]
pub fn Church(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Church, class }
    }
}

#[component]
pub fn CigaretteOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CigaretteOff, class }
    }
}

#[component]
pub fn Cigarette(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cigarette, class }
    }
}

#[component]
pub fn CircleAlert(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleAlert, class }
    }
}

#[component]
pub fn CircleArrowDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleArrowDown, class }
    }
}

#[component]
pub fn CircleArrowLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleArrowLeft, class }
    }
}

#[component]
pub fn CircleArrowOutDownLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleArrowOutDownLeft, class }
    }
}

#[component]
pub fn CircleArrowOutDownRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleArrowOutDownRight, class }
    }
}

#[component]
pub fn CircleArrowOutUpLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleArrowOutUpLeft, class }
    }
}

#[component]
pub fn CircleArrowOutUpRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleArrowOutUpRight, class }
    }
}

#[component]
pub fn CircleArrowRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleArrowRight, class }
    }
}

#[component]
pub fn CircleArrowUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleArrowUp, class }
    }
}

#[component]
pub fn CircleCheckBig(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleCheckBig, class }
    }
}

#[component]
pub fn CircleCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleCheck, class }
    }
}

#[component]
pub fn CircleChevronDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleChevronDown, class }
    }
}

#[component]
pub fn CircleChevronLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleChevronLeft, class }
    }
}

#[component]
pub fn CircleChevronRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleChevronRight, class }
    }
}

#[component]
pub fn CircleChevronUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleChevronUp, class }
    }
}

#[component]
pub fn CircleDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleDashed, class }
    }
}

#[component]
pub fn CircleDivide(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleDivide, class }
    }
}

#[component]
pub fn CircleDollarSign(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleDollarSign, class }
    }
}

#[component]
pub fn CircleDotDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleDotDashed, class }
    }
}

#[component]
pub fn CircleDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleDot, class }
    }
}

#[component]
pub fn CircleEllipsis(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleEllipsis, class }
    }
}

#[component]
pub fn CircleEqual(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleEqual, class }
    }
}

#[component]
pub fn CircleFadingArrowUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleFadingArrowUp, class }
    }
}

#[component]
pub fn CircleFadingPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleFadingPlus, class }
    }
}

#[component]
pub fn CircleGauge(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleGauge, class }
    }
}

#[component]
pub fn CircleHelp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleHelp, class }
    }
}

#[component]
pub fn CircleMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleMinus, class }
    }
}

#[component]
pub fn CircleOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleOff, class }
    }
}

#[component]
pub fn CircleParkingOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleParkingOff, class }
    }
}

#[component]
pub fn CircleParking(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleParking, class }
    }
}

#[component]
pub fn CirclePause(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CirclePause, class }
    }
}

#[component]
pub fn CirclePercent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CirclePercent, class }
    }
}

#[component]
pub fn CirclePlay(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CirclePlay, class }
    }
}

#[component]
pub fn CirclePlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CirclePlus, class }
    }
}

#[component]
pub fn CirclePoundSterling(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CirclePoundSterling, class }
    }
}

#[component]
pub fn CirclePower(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CirclePower, class }
    }
}

#[component]
pub fn CircleQuestionMark(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleQuestionMark, class }
    }
}

#[component]
pub fn CircleSlash2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleSlash2, class }
    }
}

#[component]
pub fn CircleSlash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleSlash, class }
    }
}

#[component]
pub fn CircleSmall(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleSmall, class }
    }
}

#[component]
pub fn CircleStop(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleStop, class }
    }
}

#[component]
pub fn CircleUserRound(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleUserRound, class }
    }
}

#[component]
pub fn CircleUser(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleUser, class }
    }
}

#[component]
pub fn CircleX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircleX, class }
    }
}

#[component]
pub fn Circle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Circle, class }
    }
}

#[component]
pub fn CircuitBoard(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CircuitBoard, class }
    }
}

#[component]
pub fn Citrus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Citrus, class }
    }
}

#[component]
pub fn Clapperboard(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clapperboard, class }
    }
}

#[component]
pub fn ClipboardCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardCheck, class }
    }
}

#[component]
pub fn ClipboardClock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardClock, class }
    }
}

#[component]
pub fn ClipboardCopy(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardCopy, class }
    }
}

#[component]
pub fn ClipboardList(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardList, class }
    }
}

#[component]
pub fn ClipboardMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardMinus, class }
    }
}

#[component]
pub fn ClipboardPaste(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardPaste, class }
    }
}

#[component]
pub fn ClipboardPenLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardPenLine, class }
    }
}

#[component]
pub fn ClipboardPen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardPen, class }
    }
}

#[component]
pub fn ClipboardPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardPlus, class }
    }
}

#[component]
pub fn ClipboardType(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardType, class }
    }
}

#[component]
pub fn ClipboardX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClipboardX, class }
    }
}

#[component]
pub fn Clipboard(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clipboard, class }
    }
}

#[component]
pub fn Clock1(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock1, class }
    }
}

#[component]
pub fn Clock10(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock10, class }
    }
}

#[component]
pub fn Clock11(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock11, class }
    }
}

#[component]
pub fn Clock12(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock12, class }
    }
}

#[component]
pub fn Clock2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock2, class }
    }
}

#[component]
pub fn Clock3(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock3, class }
    }
}

#[component]
pub fn Clock4(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock4, class }
    }
}

#[component]
pub fn Clock5(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock5, class }
    }
}

#[component]
pub fn Clock6(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock6, class }
    }
}

#[component]
pub fn Clock7(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock7, class }
    }
}

#[component]
pub fn Clock8(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock8, class }
    }
}

#[component]
pub fn Clock9(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock9, class }
    }
}

#[component]
pub fn ClockAlert(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClockAlert, class }
    }
}

#[component]
pub fn ClockArrowDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClockArrowDown, class }
    }
}

#[component]
pub fn ClockArrowUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClockArrowUp, class }
    }
}

#[component]
pub fn ClockFading(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClockFading, class }
    }
}

#[component]
pub fn ClockPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ClockPlus, class }
    }
}

#[component]
pub fn Clock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clock, class }
    }
}

#[component]
pub fn CloudAlert(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudAlert, class }
    }
}

#[component]
pub fn CloudCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudCheck, class }
    }
}

#[component]
pub fn CloudCog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudCog, class }
    }
}

#[component]
pub fn CloudDownload(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudDownload, class }
    }
}

#[component]
pub fn CloudDrizzle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudDrizzle, class }
    }
}

#[component]
pub fn CloudFog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudFog, class }
    }
}

#[component]
pub fn CloudHail(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudHail, class }
    }
}

#[component]
pub fn CloudLightning(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudLightning, class }
    }
}

#[component]
pub fn CloudMoonRain(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudMoonRain, class }
    }
}

#[component]
pub fn CloudMoon(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudMoon, class }
    }
}

#[component]
pub fn CloudOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudOff, class }
    }
}

#[component]
pub fn CloudRainWind(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudRainWind, class }
    }
}

#[component]
pub fn CloudRain(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudRain, class }
    }
}

#[component]
pub fn CloudSnow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudSnow, class }
    }
}

#[component]
pub fn CloudSunRain(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudSunRain, class }
    }
}

#[component]
pub fn CloudSun(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudSun, class }
    }
}

#[component]
pub fn CloudUpload(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CloudUpload, class }
    }
}

#[component]
pub fn Cloud(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cloud, class }
    }
}

#[component]
pub fn Cloudy(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cloudy, class }
    }
}

#[component]
pub fn Clover(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Clover, class }
    }
}

#[component]
pub fn Club(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Club, class }
    }
}

#[component]
pub fn CodeXml(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CodeXml, class }
    }
}

#[component]
pub fn Code(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Code, class }
    }
}

#[component]
pub fn Codepen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Codepen, class }
    }
}

#[component]
pub fn Codesandbox(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Codesandbox, class }
    }
}

#[component]
pub fn Coffee(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Coffee, class }
    }
}

#[component]
pub fn Cog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cog, class }
    }
}

#[component]
pub fn Coins(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Coins, class }
    }
}

#[component]
pub fn Columns2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Columns2, class }
    }
}

#[component]
pub fn Columns3Cog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Columns3Cog, class }
    }
}

#[component]
pub fn Columns3(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Columns3, class }
    }
}

#[component]
pub fn Columns4(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Columns4, class }
    }
}

#[component]
pub fn Combine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Combine, class }
    }
}

#[component]
pub fn Command(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Command, class }
    }
}

#[component]
pub fn Compass(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Compass, class }
    }
}

#[component]
pub fn Component(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Component, class }
    }
}

#[component]
pub fn Computer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Computer, class }
    }
}

#[component]
pub fn ConciergeBell(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ConciergeBell, class }
    }
}

#[component]
pub fn Cone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cone, class }
    }
}

#[component]
pub fn Construction(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Construction, class }
    }
}

#[component]
pub fn ContactRound(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ContactRound, class }
    }
}

#[component]
pub fn Contact(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Contact, class }
    }
}

#[component]
pub fn Container(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Container, class }
    }
}

#[component]
pub fn Contrast(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Contrast, class }
    }
}

#[component]
pub fn Cookie(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cookie, class }
    }
}

#[component]
pub fn CookingPot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CookingPot, class }
    }
}

#[component]
pub fn CopyCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CopyCheck, class }
    }
}

#[component]
pub fn CopyMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CopyMinus, class }
    }
}

#[component]
pub fn CopyPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CopyPlus, class }
    }
}

#[component]
pub fn CopySlash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CopySlash, class }
    }
}

#[component]
pub fn CopyX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CopyX, class }
    }
}

#[component]
pub fn Copy(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Copy, class }
    }
}

#[component]
pub fn Copyleft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Copyleft, class }
    }
}

#[component]
pub fn Copyright(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Copyright, class }
    }
}

#[component]
pub fn CornerDownLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CornerDownLeft, class }
    }
}

#[component]
pub fn CornerDownRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CornerDownRight, class }
    }
}

#[component]
pub fn CornerLeftDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CornerLeftDown, class }
    }
}

#[component]
pub fn CornerLeftUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CornerLeftUp, class }
    }
}

#[component]
pub fn CornerRightDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CornerRightDown, class }
    }
}

#[component]
pub fn CornerRightUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CornerRightUp, class }
    }
}

#[component]
pub fn CornerUpLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CornerUpLeft, class }
    }
}

#[component]
pub fn CornerUpRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CornerUpRight, class }
    }
}

#[component]
pub fn Cpu(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cpu, class }
    }
}

#[component]
pub fn CreativeCommons(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CreativeCommons, class }
    }
}

#[component]
pub fn CreditCard(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CreditCard, class }
    }
}

#[component]
pub fn Croissant(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Croissant, class }
    }
}

#[component]
pub fn Crop(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Crop, class }
    }
}

#[component]
pub fn Cross(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cross, class }
    }
}

#[component]
pub fn Crosshair(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Crosshair, class }
    }
}

#[component]
pub fn Crown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Crown, class }
    }
}

#[component]
pub fn Cuboid(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cuboid, class }
    }
}

#[component]
pub fn CupSoda(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::CupSoda, class }
    }
}

#[component]
pub fn Currency(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Currency, class }
    }
}

#[component]
pub fn Cylinder(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Cylinder, class }
    }
}

#[component]
pub fn Dam(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dam, class }
    }
}

#[component]
pub fn DatabaseBackup(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DatabaseBackup, class }
    }
}

#[component]
pub fn DatabaseZap(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DatabaseZap, class }
    }
}

#[component]
pub fn Database(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Database, class }
    }
}

#[component]
pub fn DecimalsArrowLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DecimalsArrowLeft, class }
    }
}

#[component]
pub fn DecimalsArrowRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DecimalsArrowRight, class }
    }
}

#[component]
pub fn Delete(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Delete, class }
    }
}

#[component]
pub fn Dessert(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dessert, class }
    }
}

#[component]
pub fn Diameter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Diameter, class }
    }
}

#[component]
pub fn DiamondMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DiamondMinus, class }
    }
}

#[component]
pub fn DiamondPercent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DiamondPercent, class }
    }
}

#[component]
pub fn DiamondPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DiamondPlus, class }
    }
}

#[component]
pub fn Diamond(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Diamond, class }
    }
}

#[component]
pub fn Dice1(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dice1, class }
    }
}

#[component]
pub fn Dice2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dice2, class }
    }
}

#[component]
pub fn Dice3(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dice3, class }
    }
}

#[component]
pub fn Dice4(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dice4, class }
    }
}

#[component]
pub fn Dice5(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dice5, class }
    }
}

#[component]
pub fn Dice6(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dice6, class }
    }
}

#[component]
pub fn Dices(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dices, class }
    }
}

#[component]
pub fn Diff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Diff, class }
    }
}

#[component]
pub fn Disc2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Disc2, class }
    }
}

#[component]
pub fn Disc3(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Disc3, class }
    }
}

#[component]
pub fn DiscAlbum(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DiscAlbum, class }
    }
}

#[component]
pub fn Disc(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Disc, class }
    }
}

#[component]
pub fn Divide(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Divide, class }
    }
}

#[component]
pub fn DnaOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DnaOff, class }
    }
}

#[component]
pub fn Dna(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dna, class }
    }
}

#[component]
pub fn Dock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dock, class }
    }
}

#[component]
pub fn Dog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dog, class }
    }
}

#[component]
pub fn DollarSign(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DollarSign, class }
    }
}

#[component]
pub fn Donut(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Donut, class }
    }
}

#[component]
pub fn DoorClosedLocked(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DoorClosedLocked, class }
    }
}

#[component]
pub fn DoorClosed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DoorClosed, class }
    }
}

#[component]
pub fn DoorOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DoorOpen, class }
    }
}

#[component]
pub fn Dot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dot, class }
    }
}

#[component]
pub fn Download(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Download, class }
    }
}

#[component]
pub fn DraftingCompass(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DraftingCompass, class }
    }
}

#[component]
pub fn Drama(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Drama, class }
    }
}

#[component]
pub fn Dribbble(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dribbble, class }
    }
}

#[component]
pub fn Drill(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Drill, class }
    }
}

#[component]
pub fn Drone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Drone, class }
    }
}

#[component]
pub fn DropletOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::DropletOff, class }
    }
}

#[component]
pub fn Droplet(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Droplet, class }
    }
}

#[component]
pub fn Droplets(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Droplets, class }
    }
}

#[component]
pub fn Drum(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Drum, class }
    }
}

#[component]
pub fn Drumstick(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Drumstick, class }
    }
}

#[component]
pub fn Dumbbell(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Dumbbell, class }
    }
}

#[component]
pub fn EarOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::EarOff, class }
    }
}

#[component]
pub fn Ear(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ear, class }
    }
}

#[component]
pub fn EarthLock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::EarthLock, class }
    }
}

#[component]
pub fn Earth(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Earth, class }
    }
}

#[component]
pub fn Eclipse(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Eclipse, class }
    }
}

#[component]
pub fn EggFried(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::EggFried, class }
    }
}

#[component]
pub fn EggOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::EggOff, class }
    }
}

#[component]
pub fn Egg(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Egg, class }
    }
}

#[component]
pub fn EllipsisVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::EllipsisVertical, class }
    }
}

#[component]
pub fn Ellipsis(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ellipsis, class }
    }
}

#[component]
pub fn EqualApproximately(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::EqualApproximately, class }
    }
}

#[component]
pub fn EqualNot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::EqualNot, class }
    }
}

#[component]
pub fn Equal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Equal, class }
    }
}

#[component]
pub fn Eraser(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Eraser, class }
    }
}

#[component]
pub fn EthernetPort(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::EthernetPort, class }
    }
}

#[component]
pub fn Euro(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Euro, class }
    }
}

#[component]
pub fn Expand(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Expand, class }
    }
}

#[component]
pub fn ExternalLink(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ExternalLink, class }
    }
}

#[component]
pub fn EyeClosed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::EyeClosed, class }
    }
}

#[component]
pub fn EyeOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::EyeOff, class }
    }
}

#[component]
pub fn Eye(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Eye, class }
    }
}

#[component]
pub fn Facebook(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Facebook, class }
    }
}

#[component]
pub fn Factory(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Factory, class }
    }
}

#[component]
pub fn Fan(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Fan, class }
    }
}

#[component]
pub fn FastForward(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FastForward, class }
    }
}

#[component]
pub fn Feather(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Feather, class }
    }
}

#[component]
pub fn Fence(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Fence, class }
    }
}

#[component]
pub fn FerrisWheel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FerrisWheel, class }
    }
}

#[component]
pub fn Figma(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Figma, class }
    }
}

#[component]
pub fn FileArchive(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileArchive, class }
    }
}

#[component]
pub fn FileAudio2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileAudio2, class }
    }
}

#[component]
pub fn FileAudio(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileAudio, class }
    }
}

#[component]
pub fn FileAxis3D(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileAxis3D, class }
    }
}

#[component]
pub fn FileBadge2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileBadge2, class }
    }
}

#[component]
pub fn FileBadge(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileBadge, class }
    }
}

#[component]
pub fn FileBox(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileBox, class }
    }
}

#[component]
pub fn FileChartColumnIncreasing(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileChartColumnIncreasing, class }
    }
}

#[component]
pub fn FileChartColumn(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileChartColumn, class }
    }
}

#[component]
pub fn FileChartLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileChartLine, class }
    }
}

#[component]
pub fn FileChartPie(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileChartPie, class }
    }
}

#[component]
pub fn FileCheck2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileCheck2, class }
    }
}

#[component]
pub fn FileCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileCheck, class }
    }
}

#[component]
pub fn FileClock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileClock, class }
    }
}

#[component]
pub fn FileCode2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileCode2, class }
    }
}

#[component]
pub fn FileCode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileCode, class }
    }
}

#[component]
pub fn FileCog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileCog, class }
    }
}

#[component]
pub fn FileDiff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileDiff, class }
    }
}

#[component]
pub fn FileDigit(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileDigit, class }
    }
}

#[component]
pub fn FileDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileDown, class }
    }
}

#[component]
pub fn FileHeart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileHeart, class }
    }
}

#[component]
pub fn FileImage(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileImage, class }
    }
}

#[component]
pub fn FileInput(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileInput, class }
    }
}

#[component]
pub fn FileJson2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileJson2, class }
    }
}

#[component]
pub fn FileJson(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileJson, class }
    }
}

#[component]
pub fn FileKey2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileKey2, class }
    }
}

#[component]
pub fn FileKey(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileKey, class }
    }
}

#[component]
pub fn FileLock2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileLock2, class }
    }
}

#[component]
pub fn FileLock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileLock, class }
    }
}

#[component]
pub fn FileMinus2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileMinus2, class }
    }
}

#[component]
pub fn FileMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileMinus, class }
    }
}

#[component]
pub fn FileMusic(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileMusic, class }
    }
}

#[component]
pub fn FileOutput(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileOutput, class }
    }
}

#[component]
pub fn FilePenLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FilePenLine, class }
    }
}

#[component]
pub fn FilePen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FilePen, class }
    }
}

#[component]
pub fn FilePlay(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FilePlay, class }
    }
}

#[component]
pub fn FilePlus2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FilePlus2, class }
    }
}

#[component]
pub fn FilePlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FilePlus, class }
    }
}

#[component]
pub fn FileQuestionMark(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileQuestionMark, class }
    }
}

#[component]
pub fn FileQuestion(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileQuestion, class }
    }
}

#[component]
pub fn FileScan(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileScan, class }
    }
}

#[component]
pub fn FileSearch2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileSearch2, class }
    }
}

#[component]
pub fn FileSearch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileSearch, class }
    }
}

#[component]
pub fn FileSliders(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileSliders, class }
    }
}

#[component]
pub fn FileSpreadsheet(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileSpreadsheet, class }
    }
}

#[component]
pub fn FileStack(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileStack, class }
    }
}

#[component]
pub fn FileSymlink(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileSymlink, class }
    }
}

#[component]
pub fn FileTerminal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileTerminal, class }
    }
}

#[component]
pub fn FileText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileText, class }
    }
}

#[component]
pub fn FileType2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileType2, class }
    }
}

#[component]
pub fn FileType(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileType, class }
    }
}

#[component]
pub fn FileUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileUp, class }
    }
}

#[component]
pub fn FileUser(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileUser, class }
    }
}

#[component]
pub fn FileVideo2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileVideo2, class }
    }
}

#[component]
pub fn FileVideoCamera(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileVideoCamera, class }
    }
}

#[component]
pub fn FileVideo(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileVideo, class }
    }
}

#[component]
pub fn FileVolume2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileVolume2, class }
    }
}

#[component]
pub fn FileVolume(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileVolume, class }
    }
}

#[component]
pub fn FileWarning(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileWarning, class }
    }
}

#[component]
pub fn FileX2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileX2, class }
    }
}

#[component]
pub fn FileX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FileX, class }
    }
}

#[component]
pub fn File(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::File, class }
    }
}

#[component]
pub fn Files(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Files, class }
    }
}

#[component]
pub fn Film(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Film, class }
    }
}

#[component]
pub fn FilterX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FilterX, class }
    }
}

#[component]
pub fn Filter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Filter, class }
    }
}

#[component]
pub fn Fingerprint(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Fingerprint, class }
    }
}

#[component]
pub fn FireExtinguisher(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FireExtinguisher, class }
    }
}

#[component]
pub fn FishOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FishOff, class }
    }
}

#[component]
pub fn FishSymbol(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FishSymbol, class }
    }
}

#[component]
pub fn Fish(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Fish, class }
    }
}

#[component]
pub fn FlagOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlagOff, class }
    }
}

#[component]
pub fn FlagTriangleLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlagTriangleLeft, class }
    }
}

#[component]
pub fn FlagTriangleRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlagTriangleRight, class }
    }
}

#[component]
pub fn Flag(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Flag, class }
    }
}

#[component]
pub fn FlameKindling(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlameKindling, class }
    }
}

#[component]
pub fn Flame(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Flame, class }
    }
}

#[component]
pub fn FlashlightOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlashlightOff, class }
    }
}

#[component]
pub fn Flashlight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Flashlight, class }
    }
}

#[component]
pub fn FlaskConicalOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlaskConicalOff, class }
    }
}

#[component]
pub fn FlaskConical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlaskConical, class }
    }
}

#[component]
pub fn FlaskRound(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlaskRound, class }
    }
}

#[component]
pub fn FlipHorizontal2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlipHorizontal2, class }
    }
}

#[component]
pub fn FlipHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlipHorizontal, class }
    }
}

#[component]
pub fn FlipVertical2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlipVertical2, class }
    }
}

#[component]
pub fn FlipVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FlipVertical, class }
    }
}

#[component]
pub fn Flower2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Flower2, class }
    }
}

#[component]
pub fn Flower(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Flower, class }
    }
}

#[component]
pub fn Focus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Focus, class }
    }
}

#[component]
pub fn FoldHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FoldHorizontal, class }
    }
}

#[component]
pub fn FoldVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FoldVertical, class }
    }
}

#[component]
pub fn FolderArchive(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderArchive, class }
    }
}

#[component]
pub fn FolderCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderCheck, class }
    }
}

#[component]
pub fn FolderClock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderClock, class }
    }
}

#[component]
pub fn FolderClosed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderClosed, class }
    }
}

#[component]
pub fn FolderCode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderCode, class }
    }
}

#[component]
pub fn FolderCog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderCog, class }
    }
}

#[component]
pub fn FolderDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderDot, class }
    }
}

#[component]
pub fn FolderDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderDown, class }
    }
}

#[component]
pub fn FolderGit2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderGit2, class }
    }
}

#[component]
pub fn FolderGit(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderGit, class }
    }
}

#[component]
pub fn FolderHeart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderHeart, class }
    }
}

#[component]
pub fn FolderInput(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderInput, class }
    }
}

#[component]
pub fn FolderKanban(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderKanban, class }
    }
}

#[component]
pub fn FolderKey(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderKey, class }
    }
}

#[component]
pub fn FolderLock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderLock, class }
    }
}

#[component]
pub fn FolderMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderMinus, class }
    }
}

#[component]
pub fn FolderOpenDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderOpenDot, class }
    }
}

#[component]
pub fn FolderOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderOpen, class }
    }
}

#[component]
pub fn FolderOutput(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderOutput, class }
    }
}

#[component]
pub fn FolderPen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderPen, class }
    }
}

#[component]
pub fn FolderPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderPlus, class }
    }
}

#[component]
pub fn FolderRoot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderRoot, class }
    }
}

#[component]
pub fn FolderSearch2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderSearch2, class }
    }
}

#[component]
pub fn FolderSearch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderSearch, class }
    }
}

#[component]
pub fn FolderSymlink(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderSymlink, class }
    }
}

#[component]
pub fn FolderSync(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderSync, class }
    }
}

#[component]
pub fn FolderTree(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderTree, class }
    }
}

#[component]
pub fn FolderUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderUp, class }
    }
}

#[component]
pub fn FolderX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FolderX, class }
    }
}

#[component]
pub fn Folder(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Folder, class }
    }
}

#[component]
pub fn Folders(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Folders, class }
    }
}

#[component]
pub fn Footprints(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Footprints, class }
    }
}

#[component]
pub fn Forklift(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Forklift, class }
    }
}

#[component]
pub fn Forward(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Forward, class }
    }
}

#[component]
pub fn Frame(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Frame, class }
    }
}

#[component]
pub fn Framer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Framer, class }
    }
}

#[component]
pub fn Frown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Frown, class }
    }
}

#[component]
pub fn Fuel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Fuel, class }
    }
}

#[component]
pub fn Fullscreen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Fullscreen, class }
    }
}

#[component]
pub fn FunnelPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FunnelPlus, class }
    }
}

#[component]
pub fn FunnelX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::FunnelX, class }
    }
}

#[component]
pub fn Funnel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Funnel, class }
    }
}

#[component]
pub fn GalleryHorizontalEnd(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GalleryHorizontalEnd, class }
    }
}

#[component]
pub fn GalleryHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GalleryHorizontal, class }
    }
}

#[component]
pub fn GalleryThumbnails(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GalleryThumbnails, class }
    }
}

#[component]
pub fn GalleryVerticalEnd(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GalleryVerticalEnd, class }
    }
}

#[component]
pub fn GalleryVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GalleryVertical, class }
    }
}

#[component]
pub fn Gamepad2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Gamepad2, class }
    }
}

#[component]
pub fn Gamepad(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Gamepad, class }
    }
}

#[component]
pub fn Gauge(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Gauge, class }
    }
}

#[component]
pub fn Gavel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Gavel, class }
    }
}

#[component]
pub fn Gem(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Gem, class }
    }
}

#[component]
pub fn GeorgianLari(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GeorgianLari, class }
    }
}

#[component]
pub fn Ghost(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ghost, class }
    }
}

#[component]
pub fn Gift(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Gift, class }
    }
}

#[component]
pub fn GitBranchPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitBranchPlus, class }
    }
}

#[component]
pub fn GitBranch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitBranch, class }
    }
}

#[component]
pub fn GitCommitHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitCommitHorizontal, class }
    }
}

#[component]
pub fn GitCommitVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitCommitVertical, class }
    }
}

#[component]
pub fn GitCompareArrows(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitCompareArrows, class }
    }
}

#[component]
pub fn GitCompare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitCompare, class }
    }
}

#[component]
pub fn GitFork(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitFork, class }
    }
}

#[component]
pub fn GitGraph(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitGraph, class }
    }
}

#[component]
pub fn GitMerge(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitMerge, class }
    }
}

#[component]
pub fn GitPullRequestArrow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitPullRequestArrow, class }
    }
}

#[component]
pub fn GitPullRequestClosed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitPullRequestClosed, class }
    }
}

#[component]
pub fn GitPullRequestCreateArrow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitPullRequestCreateArrow, class }
    }
}

#[component]
pub fn GitPullRequestCreate(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitPullRequestCreate, class }
    }
}

#[component]
pub fn GitPullRequestDraft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitPullRequestDraft, class }
    }
}

#[component]
pub fn GitPullRequest(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GitPullRequest, class }
    }
}

#[component]
pub fn Github(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Github, class }
    }
}

#[component]
pub fn Gitlab(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Gitlab, class }
    }
}

#[component]
pub fn GlassWater(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GlassWater, class }
    }
}

#[component]
pub fn Glasses(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Glasses, class }
    }
}

#[component]
pub fn GlobeLock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GlobeLock, class }
    }
}

#[component]
pub fn Globe(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Globe, class }
    }
}

#[component]
pub fn Goal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Goal, class }
    }
}

#[component]
pub fn Gpu(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Gpu, class }
    }
}

#[component]
pub fn Grab(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Grab, class }
    }
}

#[component]
pub fn GraduationCap(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GraduationCap, class }
    }
}

#[component]
pub fn Grape(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Grape, class }
    }
}

#[component]
pub fn Grid2X2Check(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Grid2X2Check, class }
    }
}

#[component]
pub fn Grid2X2Plus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Grid2X2Plus, class }
    }
}

#[component]
pub fn Grid2X2X(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Grid2X2X, class }
    }
}

#[component]
pub fn Grid2X2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Grid2X2, class }
    }
}

#[component]
pub fn Grid3X2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Grid3X2, class }
    }
}

#[component]
pub fn Grid3X3(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Grid3X3, class }
    }
}

#[component]
pub fn GripHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GripHorizontal, class }
    }
}

#[component]
pub fn GripVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::GripVertical, class }
    }
}

#[component]
pub fn Grip(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Grip, class }
    }
}

#[component]
pub fn Group(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Group, class }
    }
}

#[component]
pub fn Guitar(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Guitar, class }
    }
}

#[component]
pub fn Ham(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ham, class }
    }
}

#[component]
pub fn Hamburger(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Hamburger, class }
    }
}

#[component]
pub fn Hammer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Hammer, class }
    }
}

#[component]
pub fn HandCoins(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HandCoins, class }
    }
}

#[component]
pub fn HandHeart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HandHeart, class }
    }
}

#[component]
pub fn HandHelping(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HandHelping, class }
    }
}

#[component]
pub fn HandMetal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HandMetal, class }
    }
}

#[component]
pub fn HandPlatter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HandPlatter, class }
    }
}

#[component]
pub fn Hand(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Hand, class }
    }
}

#[component]
pub fn Handbag(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Handbag, class }
    }
}

#[component]
pub fn Handshake(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Handshake, class }
    }
}

#[component]
pub fn HardDriveDownload(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HardDriveDownload, class }
    }
}

#[component]
pub fn HardDriveUpload(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HardDriveUpload, class }
    }
}

#[component]
pub fn HardDrive(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HardDrive, class }
    }
}

#[component]
pub fn HardHat(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HardHat, class }
    }
}

#[component]
pub fn Hash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Hash, class }
    }
}

#[component]
pub fn HatGlasses(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HatGlasses, class }
    }
}

#[component]
pub fn Haze(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Haze, class }
    }
}

#[component]
pub fn HdmiPort(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HdmiPort, class }
    }
}

#[component]
pub fn Heading1(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Heading1, class }
    }
}

#[component]
pub fn Heading2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Heading2, class }
    }
}

#[component]
pub fn Heading3(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Heading3, class }
    }
}

#[component]
pub fn Heading4(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Heading4, class }
    }
}

#[component]
pub fn Heading5(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Heading5, class }
    }
}

#[component]
pub fn Heading6(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Heading6, class }
    }
}

#[component]
pub fn Heading(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Heading, class }
    }
}

#[component]
pub fn HeadphoneOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HeadphoneOff, class }
    }
}

#[component]
pub fn Headphones(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Headphones, class }
    }
}

#[component]
pub fn Headset(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Headset, class }
    }
}

#[component]
pub fn HeartCrack(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HeartCrack, class }
    }
}

#[component]
pub fn HeartHandshake(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HeartHandshake, class }
    }
}

#[component]
pub fn HeartMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HeartMinus, class }
    }
}

#[component]
pub fn HeartOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HeartOff, class }
    }
}

#[component]
pub fn HeartPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HeartPlus, class }
    }
}

#[component]
pub fn HeartPulse(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HeartPulse, class }
    }
}

#[component]
pub fn Heart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Heart, class }
    }
}

#[component]
pub fn Heater(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Heater, class }
    }
}

#[component]
pub fn Hexagon(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Hexagon, class }
    }
}

#[component]
pub fn Highlighter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Highlighter, class }
    }
}

#[component]
pub fn History(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::History, class }
    }
}

#[component]
pub fn HopOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HopOff, class }
    }
}

#[component]
pub fn Hop(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Hop, class }
    }
}

#[component]
pub fn Hospital(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Hospital, class }
    }
}

#[component]
pub fn Hotel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Hotel, class }
    }
}

#[component]
pub fn Hourglass(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Hourglass, class }
    }
}

#[component]
pub fn HousePlug(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HousePlug, class }
    }
}

#[component]
pub fn HousePlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HousePlus, class }
    }
}

#[component]
pub fn HouseWifi(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::HouseWifi, class }
    }
}

#[component]
pub fn House(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::House, class }
    }
}

#[component]
pub fn IceCreamBowl(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::IceCreamBowl, class }
    }
}

#[component]
pub fn IceCreamCone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::IceCreamCone, class }
    }
}

#[component]
pub fn IdCardLanyard(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::IdCardLanyard, class }
    }
}

#[component]
pub fn IdCard(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::IdCard, class }
    }
}

#[component]
pub fn ImageDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ImageDown, class }
    }
}

#[component]
pub fn ImageMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ImageMinus, class }
    }
}

#[component]
pub fn ImageOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ImageOff, class }
    }
}

#[component]
pub fn ImagePlay(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ImagePlay, class }
    }
}

#[component]
pub fn ImagePlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ImagePlus, class }
    }
}

#[component]
pub fn ImageUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ImageUp, class }
    }
}

#[component]
pub fn ImageUpscale(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ImageUpscale, class }
    }
}

#[component]
pub fn Image(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Image, class }
    }
}

#[component]
pub fn Images(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Images, class }
    }
}

#[component]
pub fn Import(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Import, class }
    }
}

#[component]
pub fn Inbox(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Inbox, class }
    }
}

#[component]
pub fn IndentDecrease(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::IndentDecrease, class }
    }
}

#[component]
pub fn IndentIncrease(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::IndentIncrease, class }
    }
}

#[component]
pub fn IndianRupee(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::IndianRupee, class }
    }
}

#[component]
pub fn Infinity(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Infinity, class }
    }
}

#[component]
pub fn Info(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Info, class }
    }
}

#[component]
pub fn InspectionPanel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::InspectionPanel, class }
    }
}

#[component]
pub fn Instagram(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Instagram, class }
    }
}

#[component]
pub fn Italic(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Italic, class }
    }
}

#[component]
pub fn IterationCcw(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::IterationCcw, class }
    }
}

#[component]
pub fn IterationCw(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::IterationCw, class }
    }
}

#[component]
pub fn JapaneseYen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::JapaneseYen, class }
    }
}

#[component]
pub fn Joystick(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Joystick, class }
    }
}

#[component]
pub fn Kanban(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Kanban, class }
    }
}

#[component]
pub fn KeyRound(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::KeyRound, class }
    }
}

#[component]
pub fn KeySquare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::KeySquare, class }
    }
}

#[component]
pub fn Key(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Key, class }
    }
}

#[component]
pub fn KeyboardMusic(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::KeyboardMusic, class }
    }
}

#[component]
pub fn KeyboardOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::KeyboardOff, class }
    }
}

#[component]
pub fn Keyboard(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Keyboard, class }
    }
}

#[component]
pub fn LampCeiling(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LampCeiling, class }
    }
}

#[component]
pub fn LampDesk(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LampDesk, class }
    }
}

#[component]
pub fn LampFloor(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LampFloor, class }
    }
}

#[component]
pub fn LampWallDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LampWallDown, class }
    }
}

#[component]
pub fn LampWallUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LampWallUp, class }
    }
}

#[component]
pub fn Lamp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Lamp, class }
    }
}

#[component]
pub fn LandPlot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LandPlot, class }
    }
}

#[component]
pub fn Landmark(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Landmark, class }
    }
}

#[component]
pub fn Languages(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Languages, class }
    }
}

#[component]
pub fn LaptopMinimalCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LaptopMinimalCheck, class }
    }
}

#[component]
pub fn LaptopMinimal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LaptopMinimal, class }
    }
}

#[component]
pub fn Laptop(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Laptop, class }
    }
}

#[component]
pub fn LassoSelect(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LassoSelect, class }
    }
}

#[component]
pub fn Lasso(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Lasso, class }
    }
}

#[component]
pub fn Laugh(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Laugh, class }
    }
}

#[component]
pub fn Layers2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Layers2, class }
    }
}

#[component]
pub fn Layers3(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Layers3, class }
    }
}

#[component]
pub fn Layers(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Layers, class }
    }
}

#[component]
pub fn LayoutDashboard(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LayoutDashboard, class }
    }
}

#[component]
pub fn LayoutGrid(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LayoutGrid, class }
    }
}

#[component]
pub fn LayoutList(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LayoutList, class }
    }
}

#[component]
pub fn LayoutPanelLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LayoutPanelLeft, class }
    }
}

#[component]
pub fn LayoutPanelTop(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LayoutPanelTop, class }
    }
}

#[component]
pub fn LayoutTemplate(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LayoutTemplate, class }
    }
}

#[component]
pub fn Leaf(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Leaf, class }
    }
}

#[component]
pub fn LeafyGreen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LeafyGreen, class }
    }
}

#[component]
pub fn Lectern(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Lectern, class }
    }
}

#[component]
pub fn LetterText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LetterText, class }
    }
}

#[component]
pub fn LibraryBig(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LibraryBig, class }
    }
}

#[component]
pub fn Library(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Library, class }
    }
}

#[component]
pub fn LifeBuoy(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LifeBuoy, class }
    }
}

#[component]
pub fn Ligature(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ligature, class }
    }
}

#[component]
pub fn LightbulbOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LightbulbOff, class }
    }
}

#[component]
pub fn Lightbulb(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Lightbulb, class }
    }
}

#[component]
pub fn LineSquiggle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LineSquiggle, class }
    }
}

#[component]
pub fn Link2Off(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Link2Off, class }
    }
}

#[component]
pub fn Link2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Link2, class }
    }
}

#[component]
pub fn Link(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Link, class }
    }
}

#[component]
pub fn Linkedin(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Linkedin, class }
    }
}

#[component]
pub fn ListCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListCheck, class }
    }
}

#[component]
pub fn ListChecks(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListChecks, class }
    }
}

#[component]
pub fn ListCollapse(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListCollapse, class }
    }
}

#[component]
pub fn ListEnd(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListEnd, class }
    }
}

#[component]
pub fn ListFilterPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListFilterPlus, class }
    }
}

#[component]
pub fn ListFilter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListFilter, class }
    }
}

#[component]
pub fn ListMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListMinus, class }
    }
}

#[component]
pub fn ListMusic(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListMusic, class }
    }
}

#[component]
pub fn ListOrdered(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListOrdered, class }
    }
}

#[component]
pub fn ListPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListPlus, class }
    }
}

#[component]
pub fn ListRestart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListRestart, class }
    }
}

#[component]
pub fn ListStart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListStart, class }
    }
}

#[component]
pub fn ListTodo(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListTodo, class }
    }
}

#[component]
pub fn ListTree(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListTree, class }
    }
}

#[component]
pub fn ListVideo(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListVideo, class }
    }
}

#[component]
pub fn ListX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ListX, class }
    }
}

#[component]
pub fn List(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::List, class }
    }
}

#[component]
pub fn LoaderCircle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LoaderCircle, class }
    }
}

#[component]
pub fn LoaderPinwheel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LoaderPinwheel, class }
    }
}

#[component]
pub fn Loader(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Loader, class }
    }
}

#[component]
pub fn LocateFixed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LocateFixed, class }
    }
}

#[component]
pub fn LocateOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LocateOff, class }
    }
}

#[component]
pub fn Locate(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Locate, class }
    }
}

#[component]
pub fn LocationEdit(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LocationEdit, class }
    }
}

#[component]
pub fn LockKeyholeOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LockKeyholeOpen, class }
    }
}

#[component]
pub fn LockKeyhole(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LockKeyhole, class }
    }
}

#[component]
pub fn LockOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LockOpen, class }
    }
}

#[component]
pub fn Lock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Lock, class }
    }
}

#[component]
pub fn LogIn(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LogIn, class }
    }
}

#[component]
pub fn LogOut(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::LogOut, class }
    }
}

#[component]
pub fn Logs(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Logs, class }
    }
}

#[component]
pub fn Lollipop(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Lollipop, class }
    }
}

#[component]
pub fn Luggage(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Luggage, class }
    }
}

#[component]
pub fn Magnet(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Magnet, class }
    }
}

#[component]
pub fn MailCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MailCheck, class }
    }
}

#[component]
pub fn MailMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MailMinus, class }
    }
}

#[component]
pub fn MailOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MailOpen, class }
    }
}

#[component]
pub fn MailPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MailPlus, class }
    }
}

#[component]
pub fn MailQuestionMark(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MailQuestionMark, class }
    }
}

#[component]
pub fn MailQuestion(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MailQuestion, class }
    }
}

#[component]
pub fn MailSearch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MailSearch, class }
    }
}

#[component]
pub fn MailWarning(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MailWarning, class }
    }
}

#[component]
pub fn MailX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MailX, class }
    }
}

#[component]
pub fn Mail(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Mail, class }
    }
}

#[component]
pub fn Mailbox(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Mailbox, class }
    }
}

#[component]
pub fn Mails(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Mails, class }
    }
}

#[component]
pub fn MapMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapMinus, class }
    }
}

#[component]
pub fn MapPinCheckInside(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinCheckInside, class }
    }
}

#[component]
pub fn MapPinCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinCheck, class }
    }
}

#[component]
pub fn MapPinHouse(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinHouse, class }
    }
}

#[component]
pub fn MapPinMinusInside(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinMinusInside, class }
    }
}

#[component]
pub fn MapPinMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinMinus, class }
    }
}

#[component]
pub fn MapPinOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinOff, class }
    }
}

#[component]
pub fn MapPinPen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinPen, class }
    }
}

#[component]
pub fn MapPinPlusInside(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinPlusInside, class }
    }
}

#[component]
pub fn MapPinPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinPlus, class }
    }
}

#[component]
pub fn MapPinXInside(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinXInside, class }
    }
}

#[component]
pub fn MapPinX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinX, class }
    }
}

#[component]
pub fn MapPin(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPin, class }
    }
}

#[component]
pub fn MapPinned(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPinned, class }
    }
}

#[component]
pub fn MapPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MapPlus, class }
    }
}

#[component]
pub fn Map(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Map, class }
    }
}

#[component]
pub fn MarsStroke(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MarsStroke, class }
    }
}

#[component]
pub fn Mars(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Mars, class }
    }
}

#[component]
pub fn Martini(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Martini, class }
    }
}

#[component]
pub fn Maximize2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Maximize2, class }
    }
}

#[component]
pub fn Maximize(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Maximize, class }
    }
}

#[component]
pub fn Medal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Medal, class }
    }
}

#[component]
pub fn MegaphoneOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MegaphoneOff, class }
    }
}

#[component]
pub fn Megaphone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Megaphone, class }
    }
}

#[component]
pub fn Meh(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Meh, class }
    }
}

#[component]
pub fn MemoryStick(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MemoryStick, class }
    }
}

#[component]
pub fn Menu(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Menu, class }
    }
}

#[component]
pub fn Merge(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Merge, class }
    }
}

#[component]
pub fn MessageCircleCode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircleCode, class }
    }
}

#[component]
pub fn MessageCircleDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircleDashed, class }
    }
}

#[component]
pub fn MessageCircleHeart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircleHeart, class }
    }
}

#[component]
pub fn MessageCircleMore(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircleMore, class }
    }
}

#[component]
pub fn MessageCircleOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircleOff, class }
    }
}

#[component]
pub fn MessageCirclePlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCirclePlus, class }
    }
}

#[component]
pub fn MessageCircleQuestionMark(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircleQuestionMark, class }
    }
}

#[component]
pub fn MessageCircleQuestion(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircleQuestion, class }
    }
}

#[component]
pub fn MessageCircleReply(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircleReply, class }
    }
}

#[component]
pub fn MessageCircleWarning(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircleWarning, class }
    }
}

#[component]
pub fn MessageCircleX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircleX, class }
    }
}

#[component]
pub fn MessageCircle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageCircle, class }
    }
}

#[component]
pub fn MessageSquareCode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareCode, class }
    }
}

#[component]
pub fn MessageSquareDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareDashed, class }
    }
}

#[component]
pub fn MessageSquareDiff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareDiff, class }
    }
}

#[component]
pub fn MessageSquareDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareDot, class }
    }
}

#[component]
pub fn MessageSquareHeart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareHeart, class }
    }
}

#[component]
pub fn MessageSquareLock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareLock, class }
    }
}

#[component]
pub fn MessageSquareMore(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareMore, class }
    }
}

#[component]
pub fn MessageSquareOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareOff, class }
    }
}

#[component]
pub fn MessageSquarePlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquarePlus, class }
    }
}

#[component]
pub fn MessageSquareQuote(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareQuote, class }
    }
}

#[component]
pub fn MessageSquareReply(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareReply, class }
    }
}

#[component]
pub fn MessageSquareShare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareShare, class }
    }
}

#[component]
pub fn MessageSquareText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareText, class }
    }
}

#[component]
pub fn MessageSquareWarning(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareWarning, class }
    }
}

#[component]
pub fn MessageSquareX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquareX, class }
    }
}

#[component]
pub fn MessageSquare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessageSquare, class }
    }
}

#[component]
pub fn MessagesSquare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MessagesSquare, class }
    }
}

#[component]
pub fn MicOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MicOff, class }
    }
}

#[component]
pub fn MicVocal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MicVocal, class }
    }
}

#[component]
pub fn Mic(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Mic, class }
    }
}

#[component]
pub fn Microchip(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Microchip, class }
    }
}

#[component]
pub fn Microscope(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Microscope, class }
    }
}

#[component]
pub fn Microwave(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Microwave, class }
    }
}

#[component]
pub fn Milestone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Milestone, class }
    }
}

#[component]
pub fn MilkOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MilkOff, class }
    }
}

#[component]
pub fn Milk(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Milk, class }
    }
}

#[component]
pub fn Minimize2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Minimize2, class }
    }
}

#[component]
pub fn Minimize(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Minimize, class }
    }
}

#[component]
pub fn Minus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Minus, class }
    }
}

#[component]
pub fn MonitorCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorCheck, class }
    }
}

#[component]
pub fn MonitorCog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorCog, class }
    }
}

#[component]
pub fn MonitorDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorDot, class }
    }
}

#[component]
pub fn MonitorDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorDown, class }
    }
}

#[component]
pub fn MonitorOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorOff, class }
    }
}

#[component]
pub fn MonitorPause(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorPause, class }
    }
}

#[component]
pub fn MonitorPlay(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorPlay, class }
    }
}

#[component]
pub fn MonitorSmartphone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorSmartphone, class }
    }
}

#[component]
pub fn MonitorSpeaker(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorSpeaker, class }
    }
}

#[component]
pub fn MonitorStop(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorStop, class }
    }
}

#[component]
pub fn MonitorUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorUp, class }
    }
}

#[component]
pub fn MonitorX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MonitorX, class }
    }
}

#[component]
pub fn Monitor(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Monitor, class }
    }
}

#[component]
pub fn MoonStar(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoonStar, class }
    }
}

#[component]
pub fn Moon(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Moon, class }
    }
}

#[component]
pub fn MountainSnow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MountainSnow, class }
    }
}

#[component]
pub fn Mountain(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Mountain, class }
    }
}

#[component]
pub fn MouseOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MouseOff, class }
    }
}

#[component]
pub fn MousePointer2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MousePointer2, class }
    }
}

#[component]
pub fn MousePointerBan(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MousePointerBan, class }
    }
}

#[component]
pub fn MousePointerClick(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MousePointerClick, class }
    }
}

#[component]
pub fn MousePointer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MousePointer, class }
    }
}

#[component]
pub fn Mouse(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Mouse, class }
    }
}

#[component]
pub fn Move3D(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Move3D, class }
    }
}

#[component]
pub fn MoveDiagonal2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveDiagonal2, class }
    }
}

#[component]
pub fn MoveDiagonal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveDiagonal, class }
    }
}

#[component]
pub fn MoveDownLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveDownLeft, class }
    }
}

#[component]
pub fn MoveDownRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveDownRight, class }
    }
}

#[component]
pub fn MoveDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveDown, class }
    }
}

#[component]
pub fn MoveHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveHorizontal, class }
    }
}

#[component]
pub fn MoveLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveLeft, class }
    }
}

#[component]
pub fn MoveRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveRight, class }
    }
}

#[component]
pub fn MoveUpLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveUpLeft, class }
    }
}

#[component]
pub fn MoveUpRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveUpRight, class }
    }
}

#[component]
pub fn MoveUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveUp, class }
    }
}

#[component]
pub fn MoveVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::MoveVertical, class }
    }
}

#[component]
pub fn Move(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Move, class }
    }
}

#[component]
pub fn Music2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Music2, class }
    }
}

#[component]
pub fn Music3(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Music3, class }
    }
}

#[component]
pub fn Music4(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Music4, class }
    }
}

#[component]
pub fn Music(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Music, class }
    }
}

#[component]
pub fn Navigation2Off(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Navigation2Off, class }
    }
}

#[component]
pub fn Navigation2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Navigation2, class }
    }
}

#[component]
pub fn NavigationOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::NavigationOff, class }
    }
}

#[component]
pub fn Navigation(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Navigation, class }
    }
}

#[component]
pub fn Network(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Network, class }
    }
}

#[component]
pub fn Newspaper(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Newspaper, class }
    }
}

#[component]
pub fn Nfc(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Nfc, class }
    }
}

#[component]
pub fn NonBinary(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::NonBinary, class }
    }
}

#[component]
pub fn NotebookPen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::NotebookPen, class }
    }
}

#[component]
pub fn NotebookTabs(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::NotebookTabs, class }
    }
}

#[component]
pub fn NotebookText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::NotebookText, class }
    }
}

#[component]
pub fn Notebook(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Notebook, class }
    }
}

#[component]
pub fn NotepadTextDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::NotepadTextDashed, class }
    }
}

#[component]
pub fn NotepadText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::NotepadText, class }
    }
}

#[component]
pub fn NutOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::NutOff, class }
    }
}

#[component]
pub fn Nut(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Nut, class }
    }
}

#[component]
pub fn OctagonAlert(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::OctagonAlert, class }
    }
}

#[component]
pub fn OctagonMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::OctagonMinus, class }
    }
}

#[component]
pub fn OctagonPause(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::OctagonPause, class }
    }
}

#[component]
pub fn OctagonX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::OctagonX, class }
    }
}

#[component]
pub fn Octagon(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Octagon, class }
    }
}

#[component]
pub fn Omega(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Omega, class }
    }
}

// #[component]
// pub fn Option(class: Option<String>) -> Element {
//     rsx! {
//         DioxusIcon { icon: IconType::Option, class }
//     }
// }

#[component]
pub fn Orbit(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Orbit, class }
    }
}

#[component]
pub fn Origami(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Origami, class }
    }
}

#[component]
pub fn Package2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Package2, class }
    }
}

#[component]
pub fn PackageCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PackageCheck, class }
    }
}

#[component]
pub fn PackageMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PackageMinus, class }
    }
}

#[component]
pub fn PackageOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PackageOpen, class }
    }
}

#[component]
pub fn PackagePlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PackagePlus, class }
    }
}

#[component]
pub fn PackageSearch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PackageSearch, class }
    }
}

#[component]
pub fn PackageX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PackageX, class }
    }
}

#[component]
pub fn Package(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Package, class }
    }
}

#[component]
pub fn PaintBucket(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PaintBucket, class }
    }
}

#[component]
pub fn PaintRoller(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PaintRoller, class }
    }
}

#[component]
pub fn PaintbrushVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PaintbrushVertical, class }
    }
}

#[component]
pub fn Paintbrush(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Paintbrush, class }
    }
}

#[component]
pub fn Palette(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Palette, class }
    }
}

#[component]
pub fn Panda(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Panda, class }
    }
}

#[component]
pub fn PanelBottomClose(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelBottomClose, class }
    }
}

#[component]
pub fn PanelBottomDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelBottomDashed, class }
    }
}

#[component]
pub fn PanelBottomOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelBottomOpen, class }
    }
}

#[component]
pub fn PanelBottom(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelBottom, class }
    }
}

#[component]
pub fn PanelLeftClose(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelLeftClose, class }
    }
}

#[component]
pub fn PanelLeftDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelLeftDashed, class }
    }
}

#[component]
pub fn PanelLeftOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelLeftOpen, class }
    }
}

#[component]
pub fn PanelLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelLeft, class }
    }
}

#[component]
pub fn PanelRightClose(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelRightClose, class }
    }
}

#[component]
pub fn PanelRightDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelRightDashed, class }
    }
}

#[component]
pub fn PanelRightOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelRightOpen, class }
    }
}

#[component]
pub fn PanelRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelRight, class }
    }
}

#[component]
pub fn PanelTopClose(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelTopClose, class }
    }
}

#[component]
pub fn PanelTopDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelTopDashed, class }
    }
}

#[component]
pub fn PanelTopOpen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelTopOpen, class }
    }
}

#[component]
pub fn PanelTop(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelTop, class }
    }
}

#[component]
pub fn PanelsLeftBottom(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelsLeftBottom, class }
    }
}

#[component]
pub fn PanelsRightBottom(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelsRightBottom, class }
    }
}

#[component]
pub fn PanelsTopLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PanelsTopLeft, class }
    }
}

#[component]
pub fn Paperclip(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Paperclip, class }
    }
}

#[component]
pub fn Parentheses(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Parentheses, class }
    }
}

#[component]
pub fn ParkingMeter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ParkingMeter, class }
    }
}

#[component]
pub fn PartyPopper(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PartyPopper, class }
    }
}

#[component]
pub fn Pause(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pause, class }
    }
}

#[component]
pub fn PawPrint(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PawPrint, class }
    }
}

#[component]
pub fn PcCase(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PcCase, class }
    }
}

#[component]
pub fn PenLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PenLine, class }
    }
}

#[component]
pub fn PenOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PenOff, class }
    }
}

#[component]
pub fn PenTool(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PenTool, class }
    }
}

#[component]
pub fn Pen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pen, class }
    }
}

#[component]
pub fn PencilLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PencilLine, class }
    }
}

#[component]
pub fn PencilOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PencilOff, class }
    }
}

#[component]
pub fn PencilRuler(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PencilRuler, class }
    }
}

#[component]
pub fn Pencil(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pencil, class }
    }
}

#[component]
pub fn Pentagon(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pentagon, class }
    }
}

#[component]
pub fn Percent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Percent, class }
    }
}

#[component]
pub fn PersonStanding(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PersonStanding, class }
    }
}

#[component]
pub fn PhilippinePeso(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PhilippinePeso, class }
    }
}

#[component]
pub fn PhoneCall(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PhoneCall, class }
    }
}

#[component]
pub fn PhoneForwarded(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PhoneForwarded, class }
    }
}

#[component]
pub fn PhoneIncoming(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PhoneIncoming, class }
    }
}

#[component]
pub fn PhoneMissed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PhoneMissed, class }
    }
}

#[component]
pub fn PhoneOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PhoneOff, class }
    }
}

#[component]
pub fn PhoneOutgoing(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PhoneOutgoing, class }
    }
}

#[component]
pub fn Phone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Phone, class }
    }
}

#[component]
pub fn Pi(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pi, class }
    }
}

#[component]
pub fn Piano(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Piano, class }
    }
}

#[component]
pub fn Pickaxe(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pickaxe, class }
    }
}

#[component]
pub fn PictureInPicture2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PictureInPicture2, class }
    }
}

#[component]
pub fn PictureInPicture(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PictureInPicture, class }
    }
}

#[component]
pub fn PiggyBank(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PiggyBank, class }
    }
}

#[component]
pub fn PilcrowLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PilcrowLeft, class }
    }
}

#[component]
pub fn PilcrowRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PilcrowRight, class }
    }
}

#[component]
pub fn Pilcrow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pilcrow, class }
    }
}

#[component]
pub fn PillBottle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PillBottle, class }
    }
}

#[component]
pub fn Pill(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pill, class }
    }
}

#[component]
pub fn PinOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PinOff, class }
    }
}

#[component]
pub fn Pin(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pin, class }
    }
}

#[component]
pub fn Pipette(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pipette, class }
    }
}

#[component]
pub fn Pizza(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pizza, class }
    }
}

#[component]
pub fn PlaneLanding(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PlaneLanding, class }
    }
}

#[component]
pub fn PlaneTakeoff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PlaneTakeoff, class }
    }
}

#[component]
pub fn Plane(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Plane, class }
    }
}

#[component]
pub fn Play(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Play, class }
    }
}

#[component]
pub fn Plug2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Plug2, class }
    }
}

#[component]
pub fn PlugZap(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PlugZap, class }
    }
}

#[component]
pub fn Plug(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Plug, class }
    }
}

#[component]
pub fn Plus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Plus, class }
    }
}

#[component]
pub fn PocketKnife(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PocketKnife, class }
    }
}

#[component]
pub fn Pocket(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pocket, class }
    }
}

#[component]
pub fn Podcast(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Podcast, class }
    }
}

#[component]
pub fn PointerOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PointerOff, class }
    }
}

#[component]
pub fn Pointer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pointer, class }
    }
}

#[component]
pub fn Popcorn(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Popcorn, class }
    }
}

#[component]
pub fn Popsicle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Popsicle, class }
    }
}

#[component]
pub fn PoundSterling(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PoundSterling, class }
    }
}

#[component]
pub fn PowerOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PowerOff, class }
    }
}

#[component]
pub fn Power(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Power, class }
    }
}

#[component]
pub fn Presentation(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Presentation, class }
    }
}

#[component]
pub fn PrinterCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::PrinterCheck, class }
    }
}

#[component]
pub fn Printer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Printer, class }
    }
}

#[component]
pub fn Projector(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Projector, class }
    }
}

#[component]
pub fn Proportions(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Proportions, class }
    }
}

#[component]
pub fn Puzzle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Puzzle, class }
    }
}

#[component]
pub fn Pyramid(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Pyramid, class }
    }
}

#[component]
pub fn QrCode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::QrCode, class }
    }
}

#[component]
pub fn Quote(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Quote, class }
    }
}

#[component]
pub fn Rabbit(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Rabbit, class }
    }
}

#[component]
pub fn Radar(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Radar, class }
    }
}

#[component]
pub fn Radiation(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Radiation, class }
    }
}

#[component]
pub fn Radical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Radical, class }
    }
}

#[component]
pub fn RadioReceiver(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RadioReceiver, class }
    }
}

#[component]
pub fn RadioTower(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RadioTower, class }
    }
}

#[component]
pub fn Radio(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Radio, class }
    }
}

#[component]
pub fn Radius(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Radius, class }
    }
}

#[component]
pub fn RailSymbol(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RailSymbol, class }
    }
}

#[component]
pub fn Rainbow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Rainbow, class }
    }
}

#[component]
pub fn Rat(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Rat, class }
    }
}

#[component]
pub fn Ratio(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ratio, class }
    }
}

#[component]
pub fn ReceiptCent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReceiptCent, class }
    }
}

#[component]
pub fn ReceiptEuro(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReceiptEuro, class }
    }
}

#[component]
pub fn ReceiptIndianRupee(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReceiptIndianRupee, class }
    }
}

#[component]
pub fn ReceiptJapaneseYen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReceiptJapaneseYen, class }
    }
}

#[component]
pub fn ReceiptPoundSterling(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReceiptPoundSterling, class }
    }
}

#[component]
pub fn ReceiptRussianRuble(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReceiptRussianRuble, class }
    }
}

#[component]
pub fn ReceiptSwissFranc(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReceiptSwissFranc, class }
    }
}

#[component]
pub fn ReceiptText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReceiptText, class }
    }
}

#[component]
pub fn ReceiptTurkishLira(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReceiptTurkishLira, class }
    }
}

#[component]
pub fn Receipt(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Receipt, class }
    }
}

#[component]
pub fn RectangleCircle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RectangleCircle, class }
    }
}

#[component]
pub fn RectangleEllipsis(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RectangleEllipsis, class }
    }
}

#[component]
pub fn RectangleGoggles(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RectangleGoggles, class }
    }
}

#[component]
pub fn RectangleHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RectangleHorizontal, class }
    }
}

#[component]
pub fn RectangleVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RectangleVertical, class }
    }
}

#[component]
pub fn Recycle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Recycle, class }
    }
}

#[component]
pub fn Redo2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Redo2, class }
    }
}

#[component]
pub fn RedoDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RedoDot, class }
    }
}

#[component]
pub fn Redo(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Redo, class }
    }
}

#[component]
pub fn RefreshCcwDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RefreshCcwDot, class }
    }
}

#[component]
pub fn RefreshCcw(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RefreshCcw, class }
    }
}

#[component]
pub fn RefreshCwOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RefreshCwOff, class }
    }
}

#[component]
pub fn RefreshCw(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RefreshCw, class }
    }
}

#[component]
pub fn Refrigerator(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Refrigerator, class }
    }
}

#[component]
pub fn Regex(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Regex, class }
    }
}

#[component]
pub fn RemoveFormatting(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RemoveFormatting, class }
    }
}

#[component]
pub fn Repeat1(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Repeat1, class }
    }
}

#[component]
pub fn Repeat2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Repeat2, class }
    }
}

#[component]
pub fn Repeat(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Repeat, class }
    }
}

#[component]
pub fn ReplaceAll(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReplaceAll, class }
    }
}

#[component]
pub fn Replace(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Replace, class }
    }
}

#[component]
pub fn ReplyAll(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ReplyAll, class }
    }
}

#[component]
pub fn Reply(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Reply, class }
    }
}

#[component]
pub fn Rewind(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Rewind, class }
    }
}

#[component]
pub fn Ribbon(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ribbon, class }
    }
}

#[component]
pub fn Rocket(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Rocket, class }
    }
}

#[component]
pub fn RockingChair(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RockingChair, class }
    }
}

#[component]
pub fn RollerCoaster(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RollerCoaster, class }
    }
}

#[component]
pub fn Rotate3D(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Rotate3D, class }
    }
}

#[component]
pub fn RotateCcwKey(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RotateCcwKey, class }
    }
}

#[component]
pub fn RotateCcwSquare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RotateCcwSquare, class }
    }
}

#[component]
pub fn RotateCcw(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RotateCcw, class }
    }
}

#[component]
pub fn RotateCwSquare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RotateCwSquare, class }
    }
}

#[component]
pub fn RotateCw(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RotateCw, class }
    }
}

#[component]
pub fn RouteOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RouteOff, class }
    }
}

#[component]
pub fn Route(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Route, class }
    }
}

#[component]
pub fn Router(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Router, class }
    }
}

#[component]
pub fn Rows2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Rows2, class }
    }
}

#[component]
pub fn Rows3(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Rows3, class }
    }
}

#[component]
pub fn Rows4(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Rows4, class }
    }
}

#[component]
pub fn Rss(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Rss, class }
    }
}

#[component]
pub fn RulerDimensionLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RulerDimensionLine, class }
    }
}

#[component]
pub fn Ruler(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ruler, class }
    }
}

#[component]
pub fn RussianRuble(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::RussianRuble, class }
    }
}

#[component]
pub fn Sailboat(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sailboat, class }
    }
}

#[component]
pub fn Salad(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Salad, class }
    }
}

#[component]
pub fn Sandwich(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sandwich, class }
    }
}

#[component]
pub fn SatelliteDish(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SatelliteDish, class }
    }
}

#[component]
pub fn Satellite(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Satellite, class }
    }
}

#[component]
pub fn SaudiRiyal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SaudiRiyal, class }
    }
}

#[component]
pub fn SaveAll(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SaveAll, class }
    }
}

#[component]
pub fn SaveOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SaveOff, class }
    }
}

#[component]
pub fn Save(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Save, class }
    }
}

#[component]
pub fn Scale3D(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Scale3D, class }
    }
}

#[component]
pub fn Scale(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Scale, class }
    }
}

#[component]
pub fn Scaling(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Scaling, class }
    }
}

#[component]
pub fn ScanBarcode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScanBarcode, class }
    }
}

#[component]
pub fn ScanEye(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScanEye, class }
    }
}

#[component]
pub fn ScanFace(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScanFace, class }
    }
}

#[component]
pub fn ScanHeart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScanHeart, class }
    }
}

#[component]
pub fn ScanLine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScanLine, class }
    }
}

#[component]
pub fn ScanQrCode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScanQrCode, class }
    }
}

#[component]
pub fn ScanSearch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScanSearch, class }
    }
}

#[component]
pub fn ScanText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScanText, class }
    }
}

#[component]
pub fn Scan(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Scan, class }
    }
}

#[component]
pub fn School(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::School, class }
    }
}

#[component]
pub fn ScissorsLineDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScissorsLineDashed, class }
    }
}

#[component]
pub fn Scissors(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Scissors, class }
    }
}

#[component]
pub fn ScreenShareOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScreenShareOff, class }
    }
}

#[component]
pub fn ScreenShare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScreenShare, class }
    }
}

#[component]
pub fn ScrollText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ScrollText, class }
    }
}

#[component]
pub fn Scroll(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Scroll, class }
    }
}

#[component]
pub fn SearchCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SearchCheck, class }
    }
}

#[component]
pub fn SearchCode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SearchCode, class }
    }
}

#[component]
pub fn SearchSlash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SearchSlash, class }
    }
}

#[component]
pub fn SearchX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SearchX, class }
    }
}

#[component]
pub fn Search(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Search, class }
    }
}

#[component]
pub fn Section(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Section, class }
    }
}

#[component]
pub fn SendHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SendHorizontal, class }
    }
}

#[component]
pub fn SendToBack(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SendToBack, class }
    }
}

#[component]
pub fn Send(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Send, class }
    }
}

#[component]
pub fn SeparatorHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SeparatorHorizontal, class }
    }
}

#[component]
pub fn SeparatorVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SeparatorVertical, class }
    }
}

#[component]
pub fn ServerCog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ServerCog, class }
    }
}

#[component]
pub fn ServerCrash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ServerCrash, class }
    }
}

#[component]
pub fn ServerOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ServerOff, class }
    }
}

#[component]
pub fn Server(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Server, class }
    }
}

#[component]
pub fn Settings2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Settings2, class }
    }
}

#[component]
pub fn Settings(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Settings, class }
    }
}

#[component]
pub fn Shapes(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Shapes, class }
    }
}

#[component]
pub fn Share2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Share2, class }
    }
}

#[component]
pub fn Share(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Share, class }
    }
}

#[component]
pub fn Sheet(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sheet, class }
    }
}

#[component]
pub fn Shell(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Shell, class }
    }
}

#[component]
pub fn ShieldAlert(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldAlert, class }
    }
}

#[component]
pub fn ShieldBan(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldBan, class }
    }
}

#[component]
pub fn ShieldCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldCheck, class }
    }
}

#[component]
pub fn ShieldEllipsis(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldEllipsis, class }
    }
}

#[component]
pub fn ShieldHalf(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldHalf, class }
    }
}

#[component]
pub fn ShieldMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldMinus, class }
    }
}

#[component]
pub fn ShieldOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldOff, class }
    }
}

#[component]
pub fn ShieldPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldPlus, class }
    }
}

#[component]
pub fn ShieldQuestionMark(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldQuestionMark, class }
    }
}

#[component]
pub fn ShieldQuestion(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldQuestion, class }
    }
}

#[component]
pub fn ShieldUser(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldUser, class }
    }
}

#[component]
pub fn ShieldX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShieldX, class }
    }
}

#[component]
pub fn Shield(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Shield, class }
    }
}

#[component]
pub fn ShipWheel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShipWheel, class }
    }
}

#[component]
pub fn Ship(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ship, class }
    }
}

#[component]
pub fn Shirt(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Shirt, class }
    }
}

#[component]
pub fn ShoppingBag(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShoppingBag, class }
    }
}

#[component]
pub fn ShoppingBasket(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShoppingBasket, class }
    }
}

#[component]
pub fn ShoppingCart(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShoppingCart, class }
    }
}

#[component]
pub fn Shovel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Shovel, class }
    }
}

#[component]
pub fn ShowerHead(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ShowerHead, class }
    }
}

#[component]
pub fn Shredder(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Shredder, class }
    }
}

#[component]
pub fn Shrimp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Shrimp, class }
    }
}

#[component]
pub fn Shrink(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Shrink, class }
    }
}

#[component]
pub fn Shrub(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Shrub, class }
    }
}

#[component]
pub fn Shuffle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Shuffle, class }
    }
}

#[component]
pub fn Sigma(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sigma, class }
    }
}

#[component]
pub fn SignalHigh(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SignalHigh, class }
    }
}

#[component]
pub fn SignalLow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SignalLow, class }
    }
}

#[component]
pub fn SignalMedium(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SignalMedium, class }
    }
}

#[component]
pub fn SignalZero(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SignalZero, class }
    }
}

#[component]
pub fn Signal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Signal, class }
    }
}

#[component]
pub fn Signature(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Signature, class }
    }
}

#[component]
pub fn SignpostBig(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SignpostBig, class }
    }
}

#[component]
pub fn Signpost(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Signpost, class }
    }
}

#[component]
pub fn Siren(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Siren, class }
    }
}

#[component]
pub fn SkipBack(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SkipBack, class }
    }
}

#[component]
pub fn SkipForward(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SkipForward, class }
    }
}

#[component]
pub fn Skull(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Skull, class }
    }
}

#[component]
pub fn Slack(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Slack, class }
    }
}

#[component]
pub fn Slash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Slash, class }
    }
}

#[component]
pub fn Slice(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Slice, class }
    }
}

#[component]
pub fn SlidersHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SlidersHorizontal, class }
    }
}

#[component]
pub fn SlidersVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SlidersVertical, class }
    }
}

#[component]
pub fn SmartphoneCharging(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SmartphoneCharging, class }
    }
}

#[component]
pub fn SmartphoneNfc(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SmartphoneNfc, class }
    }
}

#[component]
pub fn Smartphone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Smartphone, class }
    }
}

#[component]
pub fn SmilePlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SmilePlus, class }
    }
}

#[component]
pub fn Smile(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Smile, class }
    }
}

#[component]
pub fn Snail(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Snail, class }
    }
}

#[component]
pub fn Snowflake(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Snowflake, class }
    }
}

#[component]
pub fn SoapDispenserDroplet(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SoapDispenserDroplet, class }
    }
}

#[component]
pub fn Sofa(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sofa, class }
    }
}

#[component]
pub fn Soup(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Soup, class }
    }
}

#[component]
pub fn Space(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Space, class }
    }
}

#[component]
pub fn Spade(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Spade, class }
    }
}

#[component]
pub fn Sparkle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sparkle, class }
    }
}

#[component]
pub fn Sparkles(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sparkles, class }
    }
}

#[component]
pub fn Speaker(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Speaker, class }
    }
}

#[component]
pub fn Speech(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Speech, class }
    }
}

#[component]
pub fn SpellCheck2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SpellCheck2, class }
    }
}

#[component]
pub fn SpellCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SpellCheck, class }
    }
}

#[component]
pub fn SplinePointer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SplinePointer, class }
    }
}

#[component]
pub fn Spline(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Spline, class }
    }
}

#[component]
pub fn Split(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Split, class }
    }
}

#[component]
pub fn Spool(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Spool, class }
    }
}

#[component]
pub fn Spotlight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Spotlight, class }
    }
}

#[component]
pub fn SprayCan(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SprayCan, class }
    }
}

#[component]
pub fn Sprout(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sprout, class }
    }
}

#[component]
pub fn SquareActivity(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareActivity, class }
    }
}

#[component]
pub fn SquareArrowDownLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowDownLeft, class }
    }
}

#[component]
pub fn SquareArrowDownRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowDownRight, class }
    }
}

#[component]
pub fn SquareArrowDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowDown, class }
    }
}

#[component]
pub fn SquareArrowLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowLeft, class }
    }
}

#[component]
pub fn SquareArrowOutDownLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowOutDownLeft, class }
    }
}

#[component]
pub fn SquareArrowOutDownRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowOutDownRight, class }
    }
}

#[component]
pub fn SquareArrowOutUpLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowOutUpLeft, class }
    }
}

#[component]
pub fn SquareArrowOutUpRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowOutUpRight, class }
    }
}

#[component]
pub fn SquareArrowRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowRight, class }
    }
}

#[component]
pub fn SquareArrowUpLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowUpLeft, class }
    }
}

#[component]
pub fn SquareArrowUpRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowUpRight, class }
    }
}

#[component]
pub fn SquareArrowUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareArrowUp, class }
    }
}

#[component]
pub fn SquareAsterisk(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareAsterisk, class }
    }
}

#[component]
pub fn SquareBottomDashedScissors(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareBottomDashedScissors, class }
    }
}

#[component]
pub fn SquareChartGantt(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareChartGantt, class }
    }
}

#[component]
pub fn SquareCheckBig(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareCheckBig, class }
    }
}

#[component]
pub fn SquareCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareCheck, class }
    }
}

#[component]
pub fn SquareChevronDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareChevronDown, class }
    }
}

#[component]
pub fn SquareChevronLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareChevronLeft, class }
    }
}

#[component]
pub fn SquareChevronRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareChevronRight, class }
    }
}

#[component]
pub fn SquareChevronUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareChevronUp, class }
    }
}

#[component]
pub fn SquareCode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareCode, class }
    }
}

#[component]
pub fn SquareDashedBottomCode(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareDashedBottomCode, class }
    }
}

#[component]
pub fn SquareDashedBottom(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareDashedBottom, class }
    }
}

#[component]
pub fn SquareDashedKanban(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareDashedKanban, class }
    }
}

#[component]
pub fn SquareDashedMousePointer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareDashedMousePointer, class }
    }
}

#[component]
pub fn SquareDashedTopSolid(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareDashedTopSolid, class }
    }
}

#[component]
pub fn SquareDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareDashed, class }
    }
}

#[component]
pub fn SquareDivide(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareDivide, class }
    }
}

#[component]
pub fn SquareDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareDot, class }
    }
}

#[component]
pub fn SquareEqual(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareEqual, class }
    }
}

#[component]
pub fn SquareFunction(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareFunction, class }
    }
}

#[component]
pub fn SquareKanban(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareKanban, class }
    }
}

#[component]
pub fn SquareLibrary(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareLibrary, class }
    }
}

#[component]
pub fn SquareM(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareM, class }
    }
}

#[component]
pub fn SquareMenu(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareMenu, class }
    }
}

#[component]
pub fn SquareMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareMinus, class }
    }
}

#[component]
pub fn SquareMousePointer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareMousePointer, class }
    }
}

#[component]
pub fn SquareParkingOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareParkingOff, class }
    }
}

#[component]
pub fn SquareParking(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareParking, class }
    }
}

#[component]
pub fn SquarePause(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquarePause, class }
    }
}

#[component]
pub fn SquarePen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquarePen, class }
    }
}

#[component]
pub fn SquarePercent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquarePercent, class }
    }
}

#[component]
pub fn SquarePi(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquarePi, class }
    }
}

#[component]
pub fn SquarePilcrow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquarePilcrow, class }
    }
}

#[component]
pub fn SquarePlay(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquarePlay, class }
    }
}

#[component]
pub fn SquarePlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquarePlus, class }
    }
}

#[component]
pub fn SquarePower(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquarePower, class }
    }
}

#[component]
pub fn SquareRadical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareRadical, class }
    }
}

#[component]
pub fn SquareRoundCorner(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareRoundCorner, class }
    }
}

#[component]
pub fn SquareScissors(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareScissors, class }
    }
}

#[component]
pub fn SquareSigma(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareSigma, class }
    }
}

#[component]
pub fn SquareSlash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareSlash, class }
    }
}

#[component]
pub fn SquareSplitHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareSplitHorizontal, class }
    }
}

#[component]
pub fn SquareSplitVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareSplitVertical, class }
    }
}

#[component]
pub fn SquareSquare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareSquare, class }
    }
}

#[component]
pub fn SquareStack(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareStack, class }
    }
}

#[component]
pub fn SquareStop(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareStop, class }
    }
}

#[component]
pub fn SquareTerminal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareTerminal, class }
    }
}

#[component]
pub fn SquareUserRound(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareUserRound, class }
    }
}

#[component]
pub fn SquareUser(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareUser, class }
    }
}

#[component]
pub fn SquareX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquareX, class }
    }
}

#[component]
pub fn Square(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Square, class }
    }
}

#[component]
pub fn SquaresExclude(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquaresExclude, class }
    }
}

#[component]
pub fn SquaresIntersect(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquaresIntersect, class }
    }
}

#[component]
pub fn SquaresSubtract(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquaresSubtract, class }
    }
}

#[component]
pub fn SquaresUnite(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquaresUnite, class }
    }
}

#[component]
pub fn SquircleDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SquircleDashed, class }
    }
}

#[component]
pub fn Squircle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Squircle, class }
    }
}

#[component]
pub fn Squirrel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Squirrel, class }
    }
}

#[component]
pub fn Stamp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Stamp, class }
    }
}

#[component]
pub fn StarHalf(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::StarHalf, class }
    }
}

#[component]
pub fn StarOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::StarOff, class }
    }
}

#[component]
pub fn Star(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Star, class }
    }
}

#[component]
pub fn StepBack(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::StepBack, class }
    }
}

#[component]
pub fn StepForward(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::StepForward, class }
    }
}

#[component]
pub fn Stethoscope(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Stethoscope, class }
    }
}

#[component]
pub fn Sticker(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sticker, class }
    }
}

#[component]
pub fn StickyNote(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::StickyNote, class }
    }
}

#[component]
pub fn Store(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Store, class }
    }
}

#[component]
pub fn StretchHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::StretchHorizontal, class }
    }
}

#[component]
pub fn StretchVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::StretchVertical, class }
    }
}

#[component]
pub fn Strikethrough(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Strikethrough, class }
    }
}

#[component]
pub fn Subscript(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Subscript, class }
    }
}

#[component]
pub fn SunDim(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SunDim, class }
    }
}

#[component]
pub fn SunMedium(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SunMedium, class }
    }
}

#[component]
pub fn SunMoon(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SunMoon, class }
    }
}

#[component]
pub fn SunSnow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SunSnow, class }
    }
}

#[component]
pub fn Sun(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sun, class }
    }
}

#[component]
pub fn Sunrise(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sunrise, class }
    }
}

#[component]
pub fn Sunset(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sunset, class }
    }
}

#[component]
pub fn Superscript(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Superscript, class }
    }
}

#[component]
pub fn SwatchBook(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SwatchBook, class }
    }
}

#[component]
pub fn SwissFranc(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SwissFranc, class }
    }
}

#[component]
pub fn SwitchCamera(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::SwitchCamera, class }
    }
}

#[component]
pub fn Sword(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Sword, class }
    }
}

#[component]
pub fn Swords(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Swords, class }
    }
}

#[component]
pub fn Syringe(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Syringe, class }
    }
}

#[component]
pub fn Table2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Table2, class }
    }
}

#[component]
pub fn TableCellsMerge(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TableCellsMerge, class }
    }
}

#[component]
pub fn TableCellsSplit(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TableCellsSplit, class }
    }
}

#[component]
pub fn TableColumnsSplit(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TableColumnsSplit, class }
    }
}

#[component]
pub fn TableOfContents(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TableOfContents, class }
    }
}

#[component]
pub fn TableProperties(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TableProperties, class }
    }
}

#[component]
pub fn TableRowsSplit(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TableRowsSplit, class }
    }
}

#[component]
pub fn Table(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Table, class }
    }
}

#[component]
pub fn TabletSmartphone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TabletSmartphone, class }
    }
}

#[component]
pub fn Tablet(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tablet, class }
    }
}

#[component]
pub fn Tablets(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tablets, class }
    }
}

#[component]
pub fn Tag(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tag, class }
    }
}

#[component]
pub fn Tags(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tags, class }
    }
}

#[component]
pub fn Tally1(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tally1, class }
    }
}

#[component]
pub fn Tally2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tally2, class }
    }
}

#[component]
pub fn Tally3(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tally3, class }
    }
}

#[component]
pub fn Tally4(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tally4, class }
    }
}

#[component]
pub fn Tally5(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tally5, class }
    }
}

#[component]
pub fn Tangent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tangent, class }
    }
}

#[component]
pub fn Target(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Target, class }
    }
}

#[component]
pub fn Telescope(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Telescope, class }
    }
}

#[component]
pub fn TentTree(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TentTree, class }
    }
}

#[component]
pub fn Tent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tent, class }
    }
}

#[component]
pub fn Terminal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Terminal, class }
    }
}

#[component]
pub fn TestTubeDiagonal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TestTubeDiagonal, class }
    }
}

#[component]
pub fn TestTube(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TestTube, class }
    }
}

#[component]
pub fn TestTubes(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TestTubes, class }
    }
}

#[component]
pub fn TextCursorInput(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TextCursorInput, class }
    }
}

#[component]
pub fn TextCursor(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TextCursor, class }
    }
}

#[component]
pub fn TextQuote(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TextQuote, class }
    }
}

#[component]
pub fn TextSearch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TextSearch, class }
    }
}

#[component]
pub fn TextSelect(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TextSelect, class }
    }
}

#[component]
pub fn Text(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Text, class }
    }
}

#[component]
pub fn Theater(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Theater, class }
    }
}

#[component]
pub fn ThermometerSnowflake(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ThermometerSnowflake, class }
    }
}

#[component]
pub fn ThermometerSun(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ThermometerSun, class }
    }
}

#[component]
pub fn Thermometer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Thermometer, class }
    }
}

#[component]
pub fn ThumbsDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ThumbsDown, class }
    }
}

#[component]
pub fn ThumbsUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ThumbsUp, class }
    }
}

#[component]
pub fn TicketCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TicketCheck, class }
    }
}

#[component]
pub fn TicketMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TicketMinus, class }
    }
}

#[component]
pub fn TicketPercent(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TicketPercent, class }
    }
}

#[component]
pub fn TicketPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TicketPlus, class }
    }
}

#[component]
pub fn TicketSlash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TicketSlash, class }
    }
}

#[component]
pub fn TicketX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TicketX, class }
    }
}

#[component]
pub fn Ticket(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ticket, class }
    }
}

#[component]
pub fn TicketsPlane(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TicketsPlane, class }
    }
}

#[component]
pub fn Tickets(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tickets, class }
    }
}

#[component]
pub fn TimerOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TimerOff, class }
    }
}

#[component]
pub fn TimerReset(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TimerReset, class }
    }
}

#[component]
pub fn Timer(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Timer, class }
    }
}

#[component]
pub fn ToggleLeft(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ToggleLeft, class }
    }
}

#[component]
pub fn ToggleRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ToggleRight, class }
    }
}

#[component]
pub fn Toilet(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Toilet, class }
    }
}

#[component]
pub fn ToolCase(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ToolCase, class }
    }
}

#[component]
pub fn Tornado(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tornado, class }
    }
}

#[component]
pub fn Torus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Torus, class }
    }
}

#[component]
pub fn TouchpadOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TouchpadOff, class }
    }
}

#[component]
pub fn Touchpad(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Touchpad, class }
    }
}

#[component]
pub fn TowerControl(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TowerControl, class }
    }
}

#[component]
pub fn ToyBrick(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ToyBrick, class }
    }
}

#[component]
pub fn Tractor(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tractor, class }
    }
}

#[component]
pub fn TrafficCone(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TrafficCone, class }
    }
}

#[component]
pub fn TrainFrontTunnel(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TrainFrontTunnel, class }
    }
}

#[component]
pub fn TrainFront(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TrainFront, class }
    }
}

#[component]
pub fn TrainTrack(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TrainTrack, class }
    }
}

#[component]
pub fn TramFront(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TramFront, class }
    }
}

#[component]
pub fn Transgender(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Transgender, class }
    }
}

#[component]
pub fn Trash2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Trash2, class }
    }
}

#[component]
pub fn Trash(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Trash, class }
    }
}

#[component]
pub fn TreeDeciduous(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TreeDeciduous, class }
    }
}

#[component]
pub fn TreePalm(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TreePalm, class }
    }
}

#[component]
pub fn TreePine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TreePine, class }
    }
}

#[component]
pub fn Trees(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Trees, class }
    }
}

#[component]
pub fn Trello(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Trello, class }
    }
}

#[component]
pub fn TrendingDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TrendingDown, class }
    }
}

#[component]
pub fn TrendingUpDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TrendingUpDown, class }
    }
}

#[component]
pub fn TrendingUp(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TrendingUp, class }
    }
}

#[component]
pub fn TriangleAlert(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TriangleAlert, class }
    }
}

#[component]
pub fn TriangleDashed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TriangleDashed, class }
    }
}

#[component]
pub fn TriangleRight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TriangleRight, class }
    }
}

#[component]
pub fn Triangle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Triangle, class }
    }
}

#[component]
pub fn Trophy(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Trophy, class }
    }
}

#[component]
pub fn TruckElectric(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TruckElectric, class }
    }
}

#[component]
pub fn Truck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Truck, class }
    }
}

#[component]
pub fn TurkishLira(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TurkishLira, class }
    }
}

#[component]
pub fn Turtle(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Turtle, class }
    }
}

#[component]
pub fn TvMinimalPlay(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TvMinimalPlay, class }
    }
}

#[component]
pub fn TvMinimal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TvMinimal, class }
    }
}

#[component]
pub fn Tv(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Tv, class }
    }
}

#[component]
pub fn Twitch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Twitch, class }
    }
}

#[component]
pub fn Twitter(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Twitter, class }
    }
}

#[component]
pub fn TypeOutline(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::TypeOutline, class }
    }
}

#[component]
pub fn Type(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Type, class }
    }
}

#[component]
pub fn UmbrellaOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UmbrellaOff, class }
    }
}

#[component]
pub fn Umbrella(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Umbrella, class }
    }
}

#[component]
pub fn Underline(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Underline, class }
    }
}

#[component]
pub fn Undo2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Undo2, class }
    }
}

#[component]
pub fn UndoDot(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UndoDot, class }
    }
}

#[component]
pub fn Undo(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Undo, class }
    }
}

#[component]
pub fn UnfoldHorizontal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UnfoldHorizontal, class }
    }
}

#[component]
pub fn UnfoldVertical(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UnfoldVertical, class }
    }
}

#[component]
pub fn Ungroup(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Ungroup, class }
    }
}

#[component]
pub fn University(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::University, class }
    }
}

#[component]
pub fn Unlink2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Unlink2, class }
    }
}

#[component]
pub fn Unlink(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Unlink, class }
    }
}

#[component]
pub fn Unplug(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Unplug, class }
    }
}

#[component]
pub fn Upload(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Upload, class }
    }
}

#[component]
pub fn Usb(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Usb, class }
    }
}

#[component]
pub fn UserCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserCheck, class }
    }
}

#[component]
pub fn UserCog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserCog, class }
    }
}

#[component]
pub fn UserLock(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserLock, class }
    }
}

#[component]
pub fn UserMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserMinus, class }
    }
}

#[component]
pub fn UserPen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserPen, class }
    }
}

#[component]
pub fn UserPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserPlus, class }
    }
}

#[component]
pub fn UserRoundCheck(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserRoundCheck, class }
    }
}

#[component]
pub fn UserRoundCog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserRoundCog, class }
    }
}

#[component]
pub fn UserRoundMinus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserRoundMinus, class }
    }
}

#[component]
pub fn UserRoundPen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserRoundPen, class }
    }
}

#[component]
pub fn UserRoundPlus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserRoundPlus, class }
    }
}

#[component]
pub fn UserRoundSearch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserRoundSearch, class }
    }
}

#[component]
pub fn UserRoundX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserRoundX, class }
    }
}

#[component]
pub fn UserRound(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserRound, class }
    }
}

#[component]
pub fn UserSearch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserSearch, class }
    }
}

#[component]
pub fn UserStar(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserStar, class }
    }
}

#[component]
pub fn UserX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UserX, class }
    }
}

#[component]
pub fn User(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::User, class }
    }
}

#[component]
pub fn UsersRound(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UsersRound, class }
    }
}

#[component]
pub fn Users(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Users, class }
    }
}

#[component]
pub fn UtensilsCrossed(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UtensilsCrossed, class }
    }
}

#[component]
pub fn Utensils(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Utensils, class }
    }
}

#[component]
pub fn UtilityPole(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::UtilityPole, class }
    }
}

#[component]
pub fn Variable(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Variable, class }
    }
}

#[component]
pub fn Vault(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Vault, class }
    }
}

#[component]
pub fn VectorSquare(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::VectorSquare, class }
    }
}

#[component]
pub fn Vegan(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Vegan, class }
    }
}

#[component]
pub fn VenetianMask(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::VenetianMask, class }
    }
}

#[component]
pub fn VenusAndMars(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::VenusAndMars, class }
    }
}

#[component]
pub fn Venus(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Venus, class }
    }
}

#[component]
pub fn VibrateOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::VibrateOff, class }
    }
}

#[component]
pub fn Vibrate(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Vibrate, class }
    }
}

#[component]
pub fn VideoOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::VideoOff, class }
    }
}

#[component]
pub fn Video(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Video, class }
    }
}

#[component]
pub fn Videotape(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Videotape, class }
    }
}

#[component]
pub fn View(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::View, class }
    }
}

#[component]
pub fn Voicemail(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Voicemail, class }
    }
}

#[component]
pub fn Volleyball(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Volleyball, class }
    }
}

#[component]
pub fn Volume1(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Volume1, class }
    }
}

#[component]
pub fn Volume2(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Volume2, class }
    }
}

#[component]
pub fn VolumeOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::VolumeOff, class }
    }
}

#[component]
pub fn VolumeX(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::VolumeX, class }
    }
}

#[component]
pub fn Volume(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Volume, class }
    }
}

#[component]
pub fn Vote(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Vote, class }
    }
}

#[component]
pub fn WalletCards(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WalletCards, class }
    }
}

#[component]
pub fn WalletMinimal(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WalletMinimal, class }
    }
}

#[component]
pub fn Wallet(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Wallet, class }
    }
}

#[component]
pub fn Wallpaper(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Wallpaper, class }
    }
}

#[component]
pub fn WandSparkles(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WandSparkles, class }
    }
}

#[component]
pub fn Wand(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Wand, class }
    }
}

#[component]
pub fn Warehouse(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Warehouse, class }
    }
}

#[component]
pub fn WashingMachine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WashingMachine, class }
    }
}

#[component]
pub fn Watch(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Watch, class }
    }
}

#[component]
pub fn WavesLadder(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WavesLadder, class }
    }
}

#[component]
pub fn Waves(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Waves, class }
    }
}

#[component]
pub fn Waypoints(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Waypoints, class }
    }
}

#[component]
pub fn Webcam(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Webcam, class }
    }
}

#[component]
pub fn WebhookOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WebhookOff, class }
    }
}

#[component]
pub fn Webhook(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Webhook, class }
    }
}

#[component]
pub fn Weight(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Weight, class }
    }
}

#[component]
pub fn WheatOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WheatOff, class }
    }
}

#[component]
pub fn Wheat(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Wheat, class }
    }
}

#[component]
pub fn WholeWord(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WholeWord, class }
    }
}

#[component]
pub fn WifiCog(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WifiCog, class }
    }
}

#[component]
pub fn WifiHigh(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WifiHigh, class }
    }
}

#[component]
pub fn WifiLow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WifiLow, class }
    }
}

#[component]
pub fn WifiOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WifiOff, class }
    }
}

#[component]
pub fn WifiPen(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WifiPen, class }
    }
}

#[component]
pub fn WifiSync(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WifiSync, class }
    }
}

#[component]
pub fn WifiZero(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WifiZero, class }
    }
}

#[component]
pub fn Wifi(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Wifi, class }
    }
}

#[component]
pub fn WindArrowDown(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WindArrowDown, class }
    }
}

#[component]
pub fn Wind(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Wind, class }
    }
}

#[component]
pub fn WineOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WineOff, class }
    }
}

#[component]
pub fn Wine(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Wine, class }
    }
}

#[component]
pub fn Workflow(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Workflow, class }
    }
}

#[component]
pub fn Worm(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Worm, class }
    }
}

#[component]
pub fn WrapText(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::WrapText, class }
    }
}

#[component]
pub fn Wrench(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Wrench, class }
    }
}

#[component]
pub fn X(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::X, class }
    }
}

#[component]
pub fn Youtube(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Youtube, class }
    }
}

#[component]
pub fn ZapOff(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ZapOff, class }
    }
}

#[component]
pub fn Zap(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::Zap, class }
    }
}

#[component]
pub fn ZoomIn(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ZoomIn, class }
    }
}

#[component]
pub fn ZoomOut(class: Option<String>) -> Element {
    rsx! {
        DioxusIcon { icon: IconType::ZoomOut, class }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_compatibility_functions_compile() {
        // Test that compatibility functions can be created without panicking
        let _activity = Activity { class: None };
        let _check = Check { class: Some("text-red-500".to_string()) };
        let _x = X { class: None };
    }
}
