use super::super::IconShape;
use dioxus::prelude::*;

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAArrowDown;
impl IconShape for LdAArrowDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14 12 4 4 4-4",
            }
            path {
                d: "M18 16V7",
            }
            path {
                d: "m2 16 4.039-9.69a.5.5 0 0 1 .923 0L11 16",
            }
            path {
                d: "M3.304 13h6.392",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAArrowUp;
impl IconShape for LdAArrowUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14 11 4-4 4 4",
            }
            path {
                d: "M18 16V7",
            }
            path {
                d: "m2 16 4.039-9.69a.5.5 0 0 1 .923 0L11 16",
            }
            path {
                d: "M3.304 13h6.392",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdALargeSmall;
impl IconShape for LdALargeSmall {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 16 2.536-7.328a1.02 1.02 1 0 1 1.928 0L22 16",
            }
            path {
                d: "M15.697 14h5.606",
            }
            path {
                d: "m2 16 4.039-9.69a.5.5 0 0 1 .923 0L11 16",
            }
            path {
                d: "M3.304 13h6.392",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAccessibility;
impl IconShape for LdAccessibility {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "16",
                cy: "4",
                r: "1",
            }
            path {
                d: "m18 19 1-7-6 1",
            }
            path {
                d: "m5 8 3-3 5.5 3-2.36 3.5",
            }
            path {
                d: "M4.24 14.5a5 5 0 0 0 6.88 6",
            }
            path {
                d: "M13.76 17.5a5 5 0 0 0-6.88-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdActivity;
impl IconShape for LdActivity {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 12h-2.48a2 2 0 0 0-1.93 1.46l-2.35 8.36a.25.25 0 0 1-.48 0L9.24 2.18a.25.25 0 0 0-.48 0l-2.35 8.36A2 2 0 0 1 4.49 12H2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAirVent;
impl IconShape for LdAirVent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 17.5a2.5 2.5 0 1 1-4 2.03V12",
            }
            path {
                d: "M6 12H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M6 8h12",
            }
            path {
                d: "M6.6 15.572A2 2 0 1 0 10 17v-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAirplay;
impl IconShape for LdAirplay {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 17H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-1",
            }
            path {
                d: "m12 15 5 6H7Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlarmClockCheck;
impl IconShape for LdAlarmClockCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "13",
                r: "8",
            }
            path {
                d: "M5 3 2 6",
            }
            path {
                d: "m22 6-3-3",
            }
            path {
                d: "M6.38 18.7 4 21",
            }
            path {
                d: "M17.64 18.67 20 21",
            }
            path {
                d: "m9 13 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlarmClockMinus;
impl IconShape for LdAlarmClockMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "13",
                r: "8",
            }
            path {
                d: "M5 3 2 6",
            }
            path {
                d: "m22 6-3-3",
            }
            path {
                d: "M6.38 18.7 4 21",
            }
            path {
                d: "M17.64 18.67 20 21",
            }
            path {
                d: "M9 13h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlarmClockOff;
impl IconShape for LdAlarmClockOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6.87 6.87a8 8 0 1 0 11.26 11.26",
            }
            path {
                d: "M19.9 14.25a8 8 0 0 0-9.15-9.15",
            }
            path {
                d: "m22 6-3-3",
            }
            path {
                d: "M6.26 18.67 4 21",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M4 4 2 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlarmClockPlus;
impl IconShape for LdAlarmClockPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "13",
                r: "8",
            }
            path {
                d: "M5 3 2 6",
            }
            path {
                d: "m22 6-3-3",
            }
            path {
                d: "M6.38 18.7 4 21",
            }
            path {
                d: "M17.64 18.67 20 21",
            }
            path {
                d: "M12 10v6",
            }
            path {
                d: "M9 13h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlarmClock;
impl IconShape for LdAlarmClock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "13",
                r: "8",
            }
            path {
                d: "M12 9v4l2 2",
            }
            path {
                d: "M5 3 2 6",
            }
            path {
                d: "m22 6-3-3",
            }
            path {
                d: "M6.38 18.7 4 21",
            }
            path {
                d: "M17.64 18.67 20 21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlarmSmoke;
impl IconShape for LdAlarmSmoke {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 21c0-2.5 2-2.5 2-5",
            }
            path {
                d: "M16 21c0-2.5 2-2.5 2-5",
            }
            path {
                d: "m19 8-.8 3a1.25 1.25 0 0 1-1.2 1H7a1.25 1.25 0 0 1-1.2-1L5 8",
            }
            path {
                d: "M21 3a1 1 0 0 1 1 1v2a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V4a1 1 0 0 1 1-1z",
            }
            path {
                d: "M6 21c0-2.5 2-2.5 2-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlbum;
impl IconShape for LdAlbum {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            polyline {
                points: "11 3 11 11 14 8 17 11 17 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignCenterHorizontal;
impl IconShape for LdAlignCenterHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 12h20",
            }
            path {
                d: "M10 16v4a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-4",
            }
            path {
                d: "M10 8V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v4",
            }
            path {
                d: "M20 16v1a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2v-1",
            }
            path {
                d: "M14 8V7c0-1.1.9-2 2-2h2a2 2 0 0 1 2 2v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignCenterVertical;
impl IconShape for LdAlignCenterVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v20",
            }
            path {
                d: "M8 10H4a2 2 0 0 1-2-2V6c0-1.1.9-2 2-2h4",
            }
            path {
                d: "M16 10h4a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-4",
            }
            path {
                d: "M8 20H7a2 2 0 0 1-2-2v-2c0-1.1.9-2 2-2h1",
            }
            path {
                d: "M16 14h1a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2h-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignEndHorizontal;
impl IconShape for LdAlignEndHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "16",
                rx: "2",
                width: "6",
                x: "4",
                y: "2",
            }
            rect {
                height: "9",
                rx: "2",
                width: "6",
                x: "14",
                y: "9",
            }
            path {
                d: "M22 22H2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignEndVertical;
impl IconShape for LdAlignEndVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "16",
                x: "2",
                y: "4",
            }
            rect {
                height: "6",
                rx: "2",
                width: "9",
                x: "9",
                y: "14",
            }
            path {
                d: "M22 22V2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignHorizontalDistributeCenter;
impl IconShape for LdAlignHorizontalDistributeCenter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "6",
                x: "4",
                y: "5",
            }
            rect {
                height: "10",
                rx: "2",
                width: "6",
                x: "14",
                y: "7",
            }
            path {
                d: "M17 22v-5",
            }
            path {
                d: "M17 7V2",
            }
            path {
                d: "M7 22v-3",
            }
            path {
                d: "M7 5V2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignHorizontalDistributeEnd;
impl IconShape for LdAlignHorizontalDistributeEnd {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "6",
                x: "4",
                y: "5",
            }
            rect {
                height: "10",
                rx: "2",
                width: "6",
                x: "14",
                y: "7",
            }
            path {
                d: "M10 2v20",
            }
            path {
                d: "M20 2v20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignHorizontalDistributeStart;
impl IconShape for LdAlignHorizontalDistributeStart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "6",
                x: "4",
                y: "5",
            }
            rect {
                height: "10",
                rx: "2",
                width: "6",
                x: "14",
                y: "7",
            }
            path {
                d: "M4 2v20",
            }
            path {
                d: "M14 2v20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignHorizontalJustifyCenter;
impl IconShape for LdAlignHorizontalJustifyCenter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "6",
                x: "2",
                y: "5",
            }
            rect {
                height: "10",
                rx: "2",
                width: "6",
                x: "16",
                y: "7",
            }
            path {
                d: "M12 2v20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignHorizontalJustifyEnd;
impl IconShape for LdAlignHorizontalJustifyEnd {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "6",
                x: "2",
                y: "5",
            }
            rect {
                height: "10",
                rx: "2",
                width: "6",
                x: "12",
                y: "7",
            }
            path {
                d: "M22 2v20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignHorizontalJustifyStart;
impl IconShape for LdAlignHorizontalJustifyStart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "6",
                x: "6",
                y: "5",
            }
            rect {
                height: "10",
                rx: "2",
                width: "6",
                x: "16",
                y: "7",
            }
            path {
                d: "M2 2v20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignHorizontalSpaceAround;
impl IconShape for LdAlignHorizontalSpaceAround {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "10",
                rx: "2",
                width: "6",
                x: "9",
                y: "7",
            }
            path {
                d: "M4 22V2",
            }
            path {
                d: "M20 22V2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignHorizontalSpaceBetween;
impl IconShape for LdAlignHorizontalSpaceBetween {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "6",
                x: "3",
                y: "5",
            }
            rect {
                height: "10",
                rx: "2",
                width: "6",
                x: "15",
                y: "7",
            }
            path {
                d: "M3 2v20",
            }
            path {
                d: "M21 2v20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignStartHorizontal;
impl IconShape for LdAlignStartHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "16",
                rx: "2",
                width: "6",
                x: "4",
                y: "6",
            }
            rect {
                height: "9",
                rx: "2",
                width: "6",
                x: "14",
                y: "6",
            }
            path {
                d: "M22 2H2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignStartVertical;
impl IconShape for LdAlignStartVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "9",
                x: "6",
                y: "14",
            }
            rect {
                height: "6",
                rx: "2",
                width: "16",
                x: "6",
                y: "4",
            }
            path {
                d: "M2 2v20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignVerticalDistributeCenter;
impl IconShape for LdAlignVerticalDistributeCenter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17h-3",
            }
            path {
                d: "M22 7h-5",
            }
            path {
                d: "M5 17H2",
            }
            path {
                d: "M7 7H2",
            }
            rect {
                height: "6",
                rx: "2",
                width: "14",
                x: "5",
                y: "14",
            }
            rect {
                height: "6",
                rx: "2",
                width: "10",
                x: "7",
                y: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignVerticalDistributeEnd;
impl IconShape for LdAlignVerticalDistributeEnd {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "14",
                x: "5",
                y: "14",
            }
            rect {
                height: "6",
                rx: "2",
                width: "10",
                x: "7",
                y: "4",
            }
            path {
                d: "M2 20h20",
            }
            path {
                d: "M2 10h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignVerticalDistributeStart;
impl IconShape for LdAlignVerticalDistributeStart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "14",
                x: "5",
                y: "14",
            }
            rect {
                height: "6",
                rx: "2",
                width: "10",
                x: "7",
                y: "4",
            }
            path {
                d: "M2 14h20",
            }
            path {
                d: "M2 4h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignVerticalJustifyCenter;
impl IconShape for LdAlignVerticalJustifyCenter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "14",
                x: "5",
                y: "16",
            }
            rect {
                height: "6",
                rx: "2",
                width: "10",
                x: "7",
                y: "2",
            }
            path {
                d: "M2 12h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignVerticalJustifyEnd;
impl IconShape for LdAlignVerticalJustifyEnd {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "14",
                x: "5",
                y: "12",
            }
            rect {
                height: "6",
                rx: "2",
                width: "10",
                x: "7",
                y: "2",
            }
            path {
                d: "M2 22h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignVerticalJustifyStart;
impl IconShape for LdAlignVerticalJustifyStart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "14",
                x: "5",
                y: "16",
            }
            rect {
                height: "6",
                rx: "2",
                width: "10",
                x: "7",
                y: "6",
            }
            path {
                d: "M2 2h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignVerticalSpaceAround;
impl IconShape for LdAlignVerticalSpaceAround {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "10",
                x: "7",
                y: "9",
            }
            path {
                d: "M22 20H2",
            }
            path {
                d: "M22 4H2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAlignVerticalSpaceBetween;
impl IconShape for LdAlignVerticalSpaceBetween {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "14",
                x: "5",
                y: "15",
            }
            rect {
                height: "6",
                rx: "2",
                width: "10",
                x: "7",
                y: "3",
            }
            path {
                d: "M2 21h20",
            }
            path {
                d: "M2 3h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAmbulance;
impl IconShape for LdAmbulance {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 10H6",
            }
            path {
                d: "M14 18V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v11a1 1 0 0 0 1 1h2",
            }
            path {
                d: "M19 18h2a1 1 0 0 0 1-1v-3.28a1 1 0 0 0-.684-.948l-1.923-.641a1 1 0 0 1-.578-.502l-1.539-3.076A1 1 0 0 0 16.382 8H14",
            }
            path {
                d: "M8 8v4",
            }
            path {
                d: "M9 18h6",
            }
            circle {
                cx: "17",
                cy: "18",
                r: "2",
            }
            circle {
                cx: "7",
                cy: "18",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAmpersand;
impl IconShape for LdAmpersand {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 12h3",
            }
            path {
                d: "M17.5 12a8 8 0 0 1-8 8A4.5 4.5 0 0 1 5 15.5c0-6 8-4 8-8.5a3 3 0 1 0-6 0c0 3 2.5 8.5 12 13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAmpersands;
impl IconShape for LdAmpersands {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5",
            }
            path {
                d: "M22 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAmphora;
impl IconShape for LdAmphora {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2v5.632c0 .424-.272.795-.653.982A6 6 0 0 0 6 14c.006 4 3 7 5 8",
            }
            path {
                d: "M10 5H8a2 2 0 0 0 0 4h.68",
            }
            path {
                d: "M14 2v5.632c0 .424.272.795.652.982A6 6 0 0 1 18 14c0 4-3 7-5 8",
            }
            path {
                d: "M14 5h2a2 2 0 0 1 0 4h-.68",
            }
            path {
                d: "M18 22H6",
            }
            path {
                d: "M9 2h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAnchor;
impl IconShape for LdAnchor {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v16",
            }
            path {
                d: "m19 13 2-1a9 9 0 0 1-18 0l2 1",
            }
            path {
                d: "M9 11h6",
            }
            circle {
                cx: "12",
                cy: "4",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAngry;
impl IconShape for LdAngry {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M16 16s-1.5-2-4-2-4 2-4 2",
            }
            path {
                d: "M7.5 8 10 9",
            }
            path {
                d: "m14 9 2.5-1",
            }
            path {
                d: "M9 10h.01",
            }
            path {
                d: "M15 10h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAnnoyed;
impl IconShape for LdAnnoyed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M8 15h8",
            }
            path {
                d: "M8 9h2",
            }
            path {
                d: "M14 9h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAntenna;
impl IconShape for LdAntenna {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 12 7 2",
            }
            path {
                d: "m7 12 5-10",
            }
            path {
                d: "m12 12 5-10",
            }
            path {
                d: "m17 12 5-10",
            }
            path {
                d: "M4.5 7h15",
            }
            path {
                d: "M12 16v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAnvil;
impl IconShape for LdAnvil {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 10H6a4 4 0 0 1-4-4 1 1 0 0 1 1-1h4",
            }
            path {
                d: "M7 5a1 1 0 0 1 1-1h13a1 1 0 0 1 1 1 7 7 0 0 1-7 7H8a1 1 0 0 1-1-1z",
            }
            path {
                d: "M9 12v5",
            }
            path {
                d: "M15 12v5",
            }
            path {
                d: "M5 20a3 3 0 0 1 3-3h8a3 3 0 0 1 3 3 1 1 0 0 1-1 1H6a1 1 0 0 1-1-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAperture;
impl IconShape for LdAperture {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m14.31 8 5.74 9.94",
            }
            path {
                d: "M9.69 8h11.48",
            }
            path {
                d: "m7.38 12 5.74-9.94",
            }
            path {
                d: "M9.69 16 3.95 6.06",
            }
            path {
                d: "M14.31 16H2.83",
            }
            path {
                d: "m16.62 12-5.74 9.94",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAppWindowMac;
impl IconShape for LdAppWindowMac {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
            path {
                d: "M6 8h.01",
            }
            path {
                d: "M10 8h.01",
            }
            path {
                d: "M14 8h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAppWindow;
impl IconShape for LdAppWindow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
            path {
                d: "M10 4v4",
            }
            path {
                d: "M2 8h20",
            }
            path {
                d: "M6 4v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdApple;
impl IconShape for LdApple {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6.528V3a1 1 0 0 1 1-1h0",
            }
            path {
                d: "M18.237 21A15 15 0 0 0 22 11a6 6 0 0 0-10-4.472A6 6 0 0 0 2 11a15.1 15.1 0 0 0 3.763 10 3 3 0 0 0 3.648.648 5.5 5.5 0 0 1 5.178 0A3 3 0 0 0 18.237 21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArchiveRestore;
impl IconShape for LdArchiveRestore {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "5",
                rx: "1",
                width: "20",
                x: "2",
                y: "3",
            }
            path {
                d: "M4 8v11a2 2 0 0 0 2 2h2",
            }
            path {
                d: "M20 8v11a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "m9 15 3-3 3 3",
            }
            path {
                d: "M12 12v9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArchiveX;
impl IconShape for LdArchiveX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "5",
                rx: "1",
                width: "20",
                x: "2",
                y: "3",
            }
            path {
                d: "M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8",
            }
            path {
                d: "m9.5 17 5-5",
            }
            path {
                d: "m9.5 12 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArchive;
impl IconShape for LdArchive {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "5",
                rx: "1",
                width: "20",
                x: "2",
                y: "3",
            }
            path {
                d: "M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8",
            }
            path {
                d: "M10 12h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArmchair;
impl IconShape for LdArmchair {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 9V6a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2v3",
            }
            path {
                d: "M3 16a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-5a2 2 0 0 0-4 0v1.5a.5.5 0 0 1-.5.5h-9a.5.5 0 0 1-.5-.5V11a2 2 0 0 0-4 0z",
            }
            path {
                d: "M5 18v2",
            }
            path {
                d: "M19 18v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowBigDownDash;
impl IconShape for LdArrowBigDownDash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 11a1 1 0 0 0 1 1h2.939a1 1 0 0 1 .75 1.811l-6.835 6.836a1.207 1.207 0 0 1-1.707 0L4.31 13.81a1 1 0 0 1 .75-1.811H8a1 1 0 0 0 1-1V9a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1z",
            }
            path {
                d: "M9 4h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowBigDown;
impl IconShape for LdArrowBigDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 11a1 1 0 0 0 1 1h2.939a1 1 0 0 1 .75 1.811l-6.835 6.836a1.207 1.207 0 0 1-1.707 0L4.31 13.81a1 1 0 0 1 .75-1.811H8a1 1 0 0 0 1-1V5a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowBigLeftDash;
impl IconShape for LdArrowBigLeftDash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 9a1 1 0 0 1-1-1V5.061a1 1 0 0 0-1.811-.75l-6.835 6.836a1.207 1.207 0 0 0 0 1.707l6.835 6.835a1 1 0 0 0 1.811-.75V16a1 1 0 0 1 1-1h2a1 1 0 0 0 1-1v-4a1 1 0 0 0-1-1z",
            }
            path {
                d: "M20 9v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowBigLeft;
impl IconShape for LdArrowBigLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 9a1 1 0 0 1-1-1V5.061a1 1 0 0 0-1.811-.75l-6.835 6.836a1.207 1.207 0 0 0 0 1.707l6.835 6.835a1 1 0 0 0 1.811-.75V16a1 1 0 0 1 1-1h6a1 1 0 0 0 1-1v-4a1 1 0 0 0-1-1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowBigRightDash;
impl IconShape for LdArrowBigRightDash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 9a1 1 0 0 0 1-1V5.061a1 1 0 0 1 1.811-.75l6.836 6.836a1.207 1.207 0 0 1 0 1.707l-6.836 6.835a1 1 0 0 1-1.811-.75V16a1 1 0 0 0-1-1H9a1 1 0 0 1-1-1v-4a1 1 0 0 1 1-1z",
            }
            path {
                d: "M4 9v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowBigRight;
impl IconShape for LdArrowBigRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 9a1 1 0 0 0 1-1V5.061a1 1 0 0 1 1.811-.75l6.836 6.836a1.207 1.207 0 0 1 0 1.707l-6.836 6.835a1 1 0 0 1-1.811-.75V16a1 1 0 0 0-1-1H5a1 1 0 0 1-1-1v-4a1 1 0 0 1 1-1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowBigUpDash;
impl IconShape for LdArrowBigUpDash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 13a1 1 0 0 0-1-1H5.061a1 1 0 0 1-.75-1.811l6.836-6.835a1.207 1.207 0 0 1 1.707 0l6.835 6.835a1 1 0 0 1-.75 1.811H16a1 1 0 0 0-1 1v2a1 1 0 0 1-1 1h-4a1 1 0 0 1-1-1z",
            }
            path {
                d: "M9 20h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowBigUp;
impl IconShape for LdArrowBigUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 13a1 1 0 0 0-1-1H5.061a1 1 0 0 1-.75-1.811l6.836-6.835a1.207 1.207 0 0 1 1.707 0l6.835 6.835a1 1 0 0 1-.75 1.811H16a1 1 0 0 0-1 1v6a1 1 0 0 1-1 1h-4a1 1 0 0 1-1-1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDown01;
impl IconShape for LdArrowDown01 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 16 4 4 4-4",
            }
            path {
                d: "M7 20V4",
            }
            rect {
                height: "6",
                ry: "2",
                width: "4",
                x: "15",
                y: "4",
            }
            path {
                d: "M17 20v-6h-2",
            }
            path {
                d: "M15 20h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDown10;
impl IconShape for LdArrowDown10 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 16 4 4 4-4",
            }
            path {
                d: "M7 20V4",
            }
            path {
                d: "M17 10V4h-2",
            }
            path {
                d: "M15 10h4",
            }
            rect {
                height: "6",
                ry: "2",
                width: "4",
                x: "15",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDownAZ;
impl IconShape for LdArrowDownAZ {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 16 4 4 4-4",
            }
            path {
                d: "M7 20V4",
            }
            path {
                d: "M20 8h-5",
            }
            path {
                d: "M15 10V6.5a2.5 2.5 0 0 1 5 0V10",
            }
            path {
                d: "M15 14h5l-5 6h5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDownFromLine;
impl IconShape for LdArrowDownFromLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 3H5",
            }
            path {
                d: "M12 21V7",
            }
            path {
                d: "m6 15 6 6 6-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDownLeft;
impl IconShape for LdArrowDownLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 7 7 17",
            }
            path {
                d: "M17 17H7V7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDownNarrowWide;
impl IconShape for LdArrowDownNarrowWide {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 16 4 4 4-4",
            }
            path {
                d: "M7 20V4",
            }
            path {
                d: "M11 4h4",
            }
            path {
                d: "M11 8h7",
            }
            path {
                d: "M11 12h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDownRight;
impl IconShape for LdArrowDownRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m7 7 10 10",
            }
            path {
                d: "M17 7v10H7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDownToDot;
impl IconShape for LdArrowDownToDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v14",
            }
            path {
                d: "m19 9-7 7-7-7",
            }
            circle {
                cx: "12",
                cy: "21",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDownToLine;
impl IconShape for LdArrowDownToLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 17V3",
            }
            path {
                d: "m6 11 6 6 6-6",
            }
            path {
                d: "M19 21H5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDownUp;
impl IconShape for LdArrowDownUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 16 4 4 4-4",
            }
            path {
                d: "M7 20V4",
            }
            path {
                d: "m21 8-4-4-4 4",
            }
            path {
                d: "M17 4v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDownWideNarrow;
impl IconShape for LdArrowDownWideNarrow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 16 4 4 4-4",
            }
            path {
                d: "M7 20V4",
            }
            path {
                d: "M11 4h10",
            }
            path {
                d: "M11 8h7",
            }
            path {
                d: "M11 12h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDownZA;
impl IconShape for LdArrowDownZA {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 16 4 4 4-4",
            }
            path {
                d: "M7 4v16",
            }
            path {
                d: "M15 4h5l-5 6h5",
            }
            path {
                d: "M15 20v-3.5a2.5 2.5 0 0 1 5 0V20",
            }
            path {
                d: "M20 18h-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowDown;
impl IconShape for LdArrowDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 5v14",
            }
            path {
                d: "m19 12-7 7-7-7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowLeftFromLine;
impl IconShape for LdArrowLeftFromLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m9 6-6 6 6 6",
            }
            path {
                d: "M3 12h14",
            }
            path {
                d: "M21 19V5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowLeftRight;
impl IconShape for LdArrowLeftRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 3 4 7l4 4",
            }
            path {
                d: "M4 7h16",
            }
            path {
                d: "m16 21 4-4-4-4",
            }
            path {
                d: "M20 17H4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowLeftToLine;
impl IconShape for LdArrowLeftToLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 19V5",
            }
            path {
                d: "m13 6-6 6 6 6",
            }
            path {
                d: "M7 12h14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowLeft;
impl IconShape for LdArrowLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12 19-7-7 7-7",
            }
            path {
                d: "M19 12H5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowRightFromLine;
impl IconShape for LdArrowRightFromLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 5v14",
            }
            path {
                d: "M21 12H7",
            }
            path {
                d: "m15 18 6-6-6-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowRightLeft;
impl IconShape for LdArrowRightLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 3 4 4-4 4",
            }
            path {
                d: "M20 7H4",
            }
            path {
                d: "m8 21-4-4 4-4",
            }
            path {
                d: "M4 17h16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowRightToLine;
impl IconShape for LdArrowRightToLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 12H3",
            }
            path {
                d: "m11 18 6-6-6-6",
            }
            path {
                d: "M21 5v14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowRight;
impl IconShape for LdArrowRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 12h14",
            }
            path {
                d: "m12 5 7 7-7 7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUp01;
impl IconShape for LdArrowUp01 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 8 4-4 4 4",
            }
            path {
                d: "M7 4v16",
            }
            rect {
                height: "6",
                ry: "2",
                width: "4",
                x: "15",
                y: "4",
            }
            path {
                d: "M17 20v-6h-2",
            }
            path {
                d: "M15 20h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUp10;
impl IconShape for LdArrowUp10 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 8 4-4 4 4",
            }
            path {
                d: "M7 4v16",
            }
            path {
                d: "M17 10V4h-2",
            }
            path {
                d: "M15 10h4",
            }
            rect {
                height: "6",
                ry: "2",
                width: "4",
                x: "15",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUpAZ;
impl IconShape for LdArrowUpAZ {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 8 4-4 4 4",
            }
            path {
                d: "M7 4v16",
            }
            path {
                d: "M20 8h-5",
            }
            path {
                d: "M15 10V6.5a2.5 2.5 0 0 1 5 0V10",
            }
            path {
                d: "M15 14h5l-5 6h5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUpDown;
impl IconShape for LdArrowUpDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m21 16-4 4-4-4",
            }
            path {
                d: "M17 20V4",
            }
            path {
                d: "m3 8 4-4 4 4",
            }
            path {
                d: "M7 4v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUpFromDot;
impl IconShape for LdArrowUpFromDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m5 9 7-7 7 7",
            }
            path {
                d: "M12 16V2",
            }
            circle {
                cx: "12",
                cy: "21",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUpFromLine;
impl IconShape for LdArrowUpFromLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m18 9-6-6-6 6",
            }
            path {
                d: "M12 3v14",
            }
            path {
                d: "M5 21h14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUpLeft;
impl IconShape for LdArrowUpLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 17V7h10",
            }
            path {
                d: "M17 17 7 7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUpNarrowWide;
impl IconShape for LdArrowUpNarrowWide {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 8 4-4 4 4",
            }
            path {
                d: "M7 4v16",
            }
            path {
                d: "M11 12h4",
            }
            path {
                d: "M11 16h7",
            }
            path {
                d: "M11 20h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUpRight;
impl IconShape for LdArrowUpRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 7h10v10",
            }
            path {
                d: "M7 17 17 7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUpToLine;
impl IconShape for LdArrowUpToLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 3h14",
            }
            path {
                d: "m18 13-6-6-6 6",
            }
            path {
                d: "M12 7v14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUpWideNarrow;
impl IconShape for LdArrowUpWideNarrow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 8 4-4 4 4",
            }
            path {
                d: "M7 4v16",
            }
            path {
                d: "M11 12h10",
            }
            path {
                d: "M11 16h7",
            }
            path {
                d: "M11 20h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUpZA;
impl IconShape for LdArrowUpZA {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 8 4-4 4 4",
            }
            path {
                d: "M7 4v16",
            }
            path {
                d: "M15 4h5l-5 6h5",
            }
            path {
                d: "M15 20v-3.5a2.5 2.5 0 0 1 5 0V20",
            }
            path {
                d: "M20 18h-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowUp;
impl IconShape for LdArrowUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m5 12 7-7 7 7",
            }
            path {
                d: "M12 19V5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdArrowsUpFromLine;
impl IconShape for LdArrowsUpFromLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m4 6 3-3 3 3",
            }
            path {
                d: "M7 17V3",
            }
            path {
                d: "m14 6 3-3 3 3",
            }
            path {
                d: "M17 17V3",
            }
            path {
                d: "M4 21h16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAsterisk;
impl IconShape for LdAsterisk {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v12",
            }
            path {
                d: "M17.196 9 6.804 15",
            }
            path {
                d: "m6.804 9 10.392 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAtSign;
impl IconShape for LdAtSign {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "4",
            }
            path {
                d: "M16 8v5a3 3 0 0 0 6 0v-1a10 10 0 1 0-4 8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAtom;
impl IconShape for LdAtom {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "1",
            }
            path {
                d: "M20.2 20.2c2.04-2.03.02-7.36-4.5-11.9-4.54-4.52-9.87-6.54-11.9-4.5-2.04 2.03-.02 7.36 4.5 11.9 4.54 4.52 9.87 6.54 11.9 4.5Z",
            }
            path {
                d: "M15.7 15.7c4.52-4.54 6.54-9.87 4.5-11.9-2.03-2.04-7.36-.02-11.9 4.5-4.52 4.54-6.54 9.87-4.5 11.9 2.03 2.04 7.36.02 11.9-4.5Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAudioLines;
impl IconShape for LdAudioLines {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 10v3",
            }
            path {
                d: "M6 6v11",
            }
            path {
                d: "M10 3v18",
            }
            path {
                d: "M14 8v7",
            }
            path {
                d: "M18 5v13",
            }
            path {
                d: "M22 10v3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAudioWaveform;
impl IconShape for LdAudioWaveform {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 13a2 2 0 0 0 2-2V7a2 2 0 0 1 4 0v13a2 2 0 0 0 4 0V4a2 2 0 0 1 4 0v13a2 2 0 0 0 4 0v-4a2 2 0 0 1 2-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAward;
impl IconShape for LdAward {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15.477 12.89 1.515 8.526a.5.5 0 0 1-.81.47l-3.58-2.687a1 1 0 0 0-1.197 0l-3.586 2.686a.5.5 0 0 1-.81-.469l1.514-8.526",
            }
            circle {
                cx: "12",
                cy: "8",
                r: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAxe;
impl IconShape for LdAxe {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14 12-8.381 8.38a1 1 0 0 1-3.001-3L11 9",
            }
            path {
                d: "M15 15.5a.5.5 0 0 0 .5.5A6.5 6.5 0 0 0 22 9.5a.5.5 0 0 0-.5-.5h-1.672a2 2 0 0 1-1.414-.586l-5.062-5.062a1.205 1.205 0 0 0-1.704 0L9.352 5.648a1.205 1.205 0 0 0 0 1.704l5.062 5.062A2 2 0 0 1 15 13.828z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdAxis3d;
impl IconShape for LdAxis3d {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.5 10.5 15 9",
            }
            path {
                d: "M4 4v15a1 1 0 0 0 1 1h15",
            }
            path {
                d: "M4.293 19.707 6 18",
            }
            path {
                d: "m9 15 1.5-1.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBaby;
impl IconShape for LdBaby {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 16c.5.3 1.2.5 2 .5s1.5-.2 2-.5",
            }
            path {
                d: "M15 12h.01",
            }
            path {
                d: "M19.38 6.813A9 9 0 0 1 20.8 10.2a2 2 0 0 1 0 3.6 9 9 0 0 1-17.6 0 2 2 0 0 1 0-3.6A9 9 0 0 1 12 3c2 0 3.5 1.1 3.5 2.5s-.9 2.5-2 2.5c-.8 0-1.5-.4-1.5-1",
            }
            path {
                d: "M9 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBackpack;
impl IconShape for LdBackpack {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 10a4 4 0 0 1 4-4h8a4 4 0 0 1 4 4v10a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2z",
            }
            path {
                d: "M8 10h8",
            }
            path {
                d: "M8 18h8",
            }
            path {
                d: "M8 22v-6a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v6",
            }
            path {
                d: "M9 6V4a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeAlert;
impl IconShape for LdBadgeAlert {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "8",
                y2: "12",
            }
            line {
                x1: "12",
                x2: "12.01",
                y1: "16",
                y2: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeCent;
impl IconShape for LdBadgeCent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "M12 7v10",
            }
            path {
                d: "M15.4 10a4 4 0 1 0 0 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeCheck;
impl IconShape for LdBadgeCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "m9 12 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeDollarSign;
impl IconShape for LdBadgeDollarSign {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8",
            }
            path {
                d: "M12 18V6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeEuro;
impl IconShape for LdBadgeEuro {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "M7 12h5",
            }
            path {
                d: "M15 9.4a4 4 0 1 0 0 5.2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeIndianRupee;
impl IconShape for LdBadgeIndianRupee {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "M8 8h8",
            }
            path {
                d: "M8 12h8",
            }
            path {
                d: "m13 17-5-1h1a4 4 0 0 0 0-8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeInfo;
impl IconShape for LdBadgeInfo {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "16",
                y2: "12",
            }
            line {
                x1: "12",
                x2: "12.01",
                y1: "8",
                y2: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeJapaneseYen;
impl IconShape for LdBadgeJapaneseYen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "m9 8 3 3v7",
            }
            path {
                d: "m12 11 3-3",
            }
            path {
                d: "M9 12h6",
            }
            path {
                d: "M9 16h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeMinus;
impl IconShape for LdBadgeMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            line {
                x1: "8",
                x2: "16",
                y1: "12",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgePercent;
impl IconShape for LdBadgePercent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "m15 9-6 6",
            }
            path {
                d: "M9 9h.01",
            }
            path {
                d: "M15 15h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgePlus;
impl IconShape for LdBadgePlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "8",
                y2: "16",
            }
            line {
                x1: "8",
                x2: "16",
                y1: "12",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgePoundSterling;
impl IconShape for LdBadgePoundSterling {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "M8 12h4",
            }
            path {
                d: "M10 16V9.5a2.5 2.5 0 0 1 5 0",
            }
            path {
                d: "M8 16h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeQuestionMark;
impl IconShape for LdBadgeQuestionMark {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3",
            }
            line {
                x1: "12",
                x2: "12.01",
                y1: "17",
                y2: "17",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeRussianRuble;
impl IconShape for LdBadgeRussianRuble {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "M9 16h5",
            }
            path {
                d: "M9 12h5a2 2 0 1 0 0-4h-3v9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeSwissFranc;
impl IconShape for LdBadgeSwissFranc {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            path {
                d: "M11 17V8h4",
            }
            path {
                d: "M11 12h3",
            }
            path {
                d: "M9 16h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeTurkishLira;
impl IconShape for LdBadgeTurkishLira {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 7v10a5 5 0 0 0 5-5",
            }
            path {
                d: "m15 8-6 3",
            }
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadgeX;
impl IconShape for LdBadgeX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
            line {
                x1: "15",
                x2: "9",
                y1: "9",
                y2: "15",
            }
            line {
                x1: "9",
                x2: "15",
                y1: "9",
                y2: "15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBadge;
impl IconShape for LdBadge {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBaggageClaim;
impl IconShape for LdBaggageClaim {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 18H6a2 2 0 0 1-2-2V7a2 2 0 0 0-2-2",
            }
            path {
                d: "M17 14V4a2 2 0 0 0-2-2h-1a2 2 0 0 0-2 2v10",
            }
            rect {
                height: "8",
                rx: "1",
                width: "13",
                x: "8",
                y: "6",
            }
            circle {
                cx: "18",
                cy: "20",
                r: "2",
            }
            circle {
                cx: "9",
                cy: "20",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBan;
impl IconShape for LdBan {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4.929 4.929 19.07 19.071",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBanana;
impl IconShape for LdBanana {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 13c3.5-2 8-2 10 2a5.5 5.5 0 0 1 8 5",
            }
            path {
                d: "M5.15 17.89c5.52-1.52 8.65-6.89 7-12C11.55 4 11.5 2 13 2c3.22 0 5 5.5 5 8 0 6.5-4.2 12-10.49 12C5.11 22 2 22 2 20c0-1.5 1.14-1.55 3.15-2.11Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBandage;
impl IconShape for LdBandage {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 10.01h.01",
            }
            path {
                d: "M10 14.01h.01",
            }
            path {
                d: "M14 10.01h.01",
            }
            path {
                d: "M14 14.01h.01",
            }
            path {
                d: "M18 6v11.5",
            }
            path {
                d: "M6 6v12",
            }
            rect {
                height: "12",
                rx: "2",
                width: "20",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBanknoteArrowDown;
impl IconShape for LdBanknoteArrowDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5",
            }
            path {
                d: "m16 19 3 3 3-3",
            }
            path {
                d: "M18 12h.01",
            }
            path {
                d: "M19 16v6",
            }
            path {
                d: "M6 12h.01",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBanknoteArrowUp;
impl IconShape for LdBanknoteArrowUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5",
            }
            path {
                d: "M18 12h.01",
            }
            path {
                d: "M19 22v-6",
            }
            path {
                d: "m22 19-3-3-3 3",
            }
            path {
                d: "M6 12h.01",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBanknoteX;
impl IconShape for LdBanknoteX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5",
            }
            path {
                d: "m17 17 5 5",
            }
            path {
                d: "M18 12h.01",
            }
            path {
                d: "m22 17-5 5",
            }
            path {
                d: "M6 12h.01",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBanknote;
impl IconShape for LdBanknote {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "12",
                rx: "2",
                width: "20",
                x: "2",
                y: "6",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
            path {
                d: "M6 12h.01M18 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBarcode;
impl IconShape for LdBarcode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 5v14",
            }
            path {
                d: "M8 5v14",
            }
            path {
                d: "M12 5v14",
            }
            path {
                d: "M17 5v14",
            }
            path {
                d: "M21 5v14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBarrel;
impl IconShape for LdBarrel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 3a41 41 0 0 0 0 18",
            }
            path {
                d: "M14 3a41 41 0 0 1 0 18",
            }
            path {
                d: "M17 3a2 2 0 0 1 1.68.92 15.25 15.25 0 0 1 0 16.16A2 2 0 0 1 17 21H7a2 2 0 0 1-1.68-.92 15.25 15.25 0 0 1 0-16.16A2 2 0 0 1 7 3z",
            }
            path {
                d: "M3.84 17h16.32",
            }
            path {
                d: "M3.84 7h16.32",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBaseline;
impl IconShape for LdBaseline {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 20h16",
            }
            path {
                d: "m6 16 6-12 6 12",
            }
            path {
                d: "M8 12h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBath;
impl IconShape for LdBath {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 4 8 6",
            }
            path {
                d: "M17 19v2",
            }
            path {
                d: "M2 12h20",
            }
            path {
                d: "M7 19v2",
            }
            path {
                d: "M9 5 7.621 3.621A2.121 2.121 0 0 0 4 5v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBatteryCharging;
impl IconShape for LdBatteryCharging {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m11 7-3 5h4l-3 5",
            }
            path {
                d: "M14.856 6H16a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2.935",
            }
            path {
                d: "M22 14v-4",
            }
            path {
                d: "M5.14 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h2.936",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBatteryFull;
impl IconShape for LdBatteryFull {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 10v4",
            }
            path {
                d: "M14 10v4",
            }
            path {
                d: "M22 14v-4",
            }
            path {
                d: "M6 10v4",
            }
            rect {
                height: "12",
                rx: "2",
                width: "16",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBatteryLow;
impl IconShape for LdBatteryLow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 14v-4",
            }
            path {
                d: "M6 14v-4",
            }
            rect {
                height: "12",
                rx: "2",
                width: "16",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBatteryMedium;
impl IconShape for LdBatteryMedium {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 14v-4",
            }
            path {
                d: "M22 14v-4",
            }
            path {
                d: "M6 14v-4",
            }
            rect {
                height: "12",
                rx: "2",
                width: "16",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBatteryPlus;
impl IconShape for LdBatteryPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 9v6",
            }
            path {
                d: "M12.543 6H16a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-3.605",
            }
            path {
                d: "M22 14v-4",
            }
            path {
                d: "M7 12h6",
            }
            path {
                d: "M7.606 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3.606",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBatteryWarning;
impl IconShape for LdBatteryWarning {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 17h.01",
            }
            path {
                d: "M10 7v6",
            }
            path {
                d: "M14 6h2a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M22 14v-4",
            }
            path {
                d: "M6 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBattery;
impl IconShape for LdBattery {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M 22 14 L 22 10",
            }
            rect {
                height: "12",
                rx: "2",
                width: "16",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBeaker;
impl IconShape for LdBeaker {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4.5 3h15",
            }
            path {
                d: "M6 3v16a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V3",
            }
            path {
                d: "M6 14h12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBeanOff;
impl IconShape for LdBeanOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 9c-.64.64-1.521.954-2.402 1.165A6 6 0 0 0 8 22a13.96 13.96 0 0 0 9.9-4.1",
            }
            path {
                d: "M10.75 5.093A6 6 0 0 1 22 8c0 2.411-.61 4.68-1.683 6.66",
            }
            path {
                d: "M5.341 10.62a4 4 0 0 0 6.487 1.208M10.62 5.341a4.015 4.015 0 0 1 2.039 2.04",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBean;
impl IconShape for LdBean {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.165 6.598C9.954 7.478 9.64 8.36 9 9c-.64.64-1.521.954-2.402 1.165A6 6 0 0 0 8 22c7.732 0 14-6.268 14-14a6 6 0 0 0-11.835-1.402Z",
            }
            path {
                d: "M5.341 10.62a4 4 0 1 0 5.279-5.28",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBedDouble;
impl IconShape for LdBedDouble {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 20v-8a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v8",
            }
            path {
                d: "M4 10V6a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v4",
            }
            path {
                d: "M12 4v6",
            }
            path {
                d: "M2 18h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBedSingle;
impl IconShape for LdBedSingle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 20v-8a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v8",
            }
            path {
                d: "M5 10V6a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v4",
            }
            path {
                d: "M3 18h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBed;
impl IconShape for LdBed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 4v16",
            }
            path {
                d: "M2 8h18a2 2 0 0 1 2 2v10",
            }
            path {
                d: "M2 17h20",
            }
            path {
                d: "M6 8v9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBeef;
impl IconShape for LdBeef {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16.4 13.7A6.5 6.5 0 1 0 6.28 6.6c-1.1 3.13-.78 3.9-3.18 6.08A3 3 0 0 0 5 18c4 0 8.4-1.8 11.4-4.3",
            }
            path {
                d: "m18.5 6 2.19 4.5a6.48 6.48 0 0 1-2.29 7.2C15.4 20.2 11 22 7 22a3 3 0 0 1-2.68-1.66L2.4 16.5",
            }
            circle {
                cx: "12.5",
                cy: "8.5",
                r: "2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBeerOff;
impl IconShape for LdBeerOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 13v5",
            }
            path {
                d: "M17 11.47V8",
            }
            path {
                d: "M17 11h1a3 3 0 0 1 2.745 4.211",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M5 8v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2v-3",
            }
            path {
                d: "M7.536 7.535C6.766 7.649 6.154 8 5.5 8a2.5 2.5 0 0 1-1.768-4.268",
            }
            path {
                d: "M8.727 3.204C9.306 2.767 9.885 2 11 2c1.56 0 2 1.5 3 1.5s1.72-.5 2.5-.5a1 1 0 1 1 0 5c-.78 0-1.5-.5-2.5-.5a3.149 3.149 0 0 0-.842.12",
            }
            path {
                d: "M9 14.6V18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBeer;
impl IconShape for LdBeer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 11h1a3 3 0 0 1 0 6h-1",
            }
            path {
                d: "M9 12v6",
            }
            path {
                d: "M13 12v6",
            }
            path {
                d: "M14 7.5c-1 0-1.44.5-3 .5s-2-.5-3-.5-1.72.5-2.5.5a2.5 2.5 0 0 1 0-5c.78 0 1.57.5 2.5.5S9.44 2 11 2s2 1.5 3 1.5 1.72-.5 2.5-.5a2.5 2.5 0 0 1 0 5c-.78 0-1.5-.5-2.5-.5Z",
            }
            path {
                d: "M5 8v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBellDot;
impl IconShape for LdBellDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.268 21a2 2 0 0 0 3.464 0",
            }
            path {
                d: "M13.916 2.314A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.74 7.327A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673 9 9 0 0 1-.585-.665",
            }
            circle {
                cx: "18",
                cy: "8",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBellElectric;
impl IconShape for LdBellElectric {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18.518 17.347A7 7 0 0 1 14 19",
            }
            path {
                d: "M18.8 4A11 11 0 0 1 20 9",
            }
            path {
                d: "M9 9h.01",
            }
            circle {
                cx: "20",
                cy: "16",
                r: "2",
            }
            circle {
                cx: "9",
                cy: "9",
                r: "7",
            }
            rect {
                height: "6",
                rx: "2",
                width: "10",
                x: "4",
                y: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBellMinus;
impl IconShape for LdBellMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.268 21a2 2 0 0 0 3.464 0",
            }
            path {
                d: "M15 8h6",
            }
            path {
                d: "M16.243 3.757A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673A9.4 9.4 0 0 1 18.667 12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBellOff;
impl IconShape for LdBellOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.268 21a2 2 0 0 0 3.464 0",
            }
            path {
                d: "M17 17H4a1 1 0 0 1-.74-1.673C4.59 13.956 6 12.499 6 8a6 6 0 0 1 .258-1.742",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M8.668 3.01A6 6 0 0 1 18 8c0 2.687.77 4.653 1.707 6.05",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBellPlus;
impl IconShape for LdBellPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.268 21a2 2 0 0 0 3.464 0",
            }
            path {
                d: "M15 8h6",
            }
            path {
                d: "M18 5v6",
            }
            path {
                d: "M20.002 14.464a9 9 0 0 0 .738.863A1 1 0 0 1 20 17H4a1 1 0 0 1-.74-1.673C4.59 13.956 6 12.499 6 8a6 6 0 0 1 8.75-5.332",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBellRing;
impl IconShape for LdBellRing {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.268 21a2 2 0 0 0 3.464 0",
            }
            path {
                d: "M22 8c0-2.3-.8-4.3-2-6",
            }
            path {
                d: "M3.262 15.326A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673C19.41 13.956 18 12.499 18 8A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326",
            }
            path {
                d: "M4 2C2.8 3.7 2 5.7 2 8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBell;
impl IconShape for LdBell {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.268 21a2 2 0 0 0 3.464 0",
            }
            path {
                d: "M3.262 15.326A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673C19.41 13.956 18 12.499 18 8A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBetweenHorizontalEnd;
impl IconShape for LdBetweenHorizontalEnd {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "7",
                rx: "1",
                width: "13",
                x: "3",
                y: "3",
            }
            path {
                d: "m22 15-3-3 3-3",
            }
            rect {
                height: "7",
                rx: "1",
                width: "13",
                x: "3",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBetweenHorizontalStart;
impl IconShape for LdBetweenHorizontalStart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "7",
                rx: "1",
                width: "13",
                x: "8",
                y: "3",
            }
            path {
                d: "m2 9 3 3-3 3",
            }
            rect {
                height: "7",
                rx: "1",
                width: "13",
                x: "8",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBetweenVerticalEnd;
impl IconShape for LdBetweenVerticalEnd {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "13",
                rx: "1",
                width: "7",
                x: "3",
                y: "3",
            }
            path {
                d: "m9 22 3-3 3 3",
            }
            rect {
                height: "13",
                rx: "1",
                width: "7",
                x: "14",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBetweenVerticalStart;
impl IconShape for LdBetweenVerticalStart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "13",
                rx: "1",
                width: "7",
                x: "3",
                y: "8",
            }
            path {
                d: "m15 2-3 3-3-3",
            }
            rect {
                height: "13",
                rx: "1",
                width: "7",
                x: "14",
                y: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBicepsFlexed;
impl IconShape for LdBicepsFlexed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.409 13.017A5 5 0 0 1 22 15c0 3.866-4 7-9 7-4.077 0-8.153-.82-10.371-2.462-.426-.316-.631-.832-.62-1.362C2.118 12.723 2.627 2 10 2a3 3 0 0 1 3 3 2 2 0 0 1-2 2c-1.105 0-1.64-.444-2-1",
            }
            path {
                d: "M15 14a5 5 0 0 0-7.584 2",
            }
            path {
                d: "M9.964 6.825C8.019 7.977 9.5 13 8 15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBike;
impl IconShape for LdBike {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "18.5",
                cy: "17.5",
                r: "3.5",
            }
            circle {
                cx: "5.5",
                cy: "17.5",
                r: "3.5",
            }
            circle {
                cx: "15",
                cy: "5",
                r: "1",
            }
            path {
                d: "M12 17.5V14l-3-3 4-3 2 3h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBinary;
impl IconShape for LdBinary {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "4",
                x: "14",
                y: "14",
            }
            rect {
                height: "6",
                rx: "2",
                width: "4",
                x: "6",
                y: "4",
            }
            path {
                d: "M6 20h4",
            }
            path {
                d: "M14 10h4",
            }
            path {
                d: "M6 14h2v6",
            }
            path {
                d: "M14 4h2v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBinoculars;
impl IconShape for LdBinoculars {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 10h4",
            }
            path {
                d: "M19 7V4a1 1 0 0 0-1-1h-2a1 1 0 0 0-1 1v3",
            }
            path {
                d: "M20 21a2 2 0 0 0 2-2v-3.851c0-1.39-2-2.962-2-4.829V8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v11a2 2 0 0 0 2 2z",
            }
            path {
                d: "M 22 16 L 2 16",
            }
            path {
                d: "M4 21a2 2 0 0 1-2-2v-3.851c0-1.39 2-2.962 2-4.829V8a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v11a2 2 0 0 1-2 2z",
            }
            path {
                d: "M9 7V4a1 1 0 0 0-1-1H6a1 1 0 0 0-1 1v3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBiohazard;
impl IconShape for LdBiohazard {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "11.9",
                r: "2",
            }
            path {
                d: "M6.7 3.4c-.9 2.5 0 5.2 2.2 6.7C6.5 9 3.7 9.6 2 11.6",
            }
            path {
                d: "m8.9 10.1 1.4.8",
            }
            path {
                d: "M17.3 3.4c.9 2.5 0 5.2-2.2 6.7 2.4-1.2 5.2-.6 6.9 1.5",
            }
            path {
                d: "m15.1 10.1-1.4.8",
            }
            path {
                d: "M16.7 20.8c-2.6-.4-4.6-2.6-4.7-5.3-.2 2.6-2.1 4.8-4.7 5.2",
            }
            path {
                d: "M12 13.9v1.6",
            }
            path {
                d: "M13.5 5.4c-1-.2-2-.2-3 0",
            }
            path {
                d: "M17 16.4c.7-.7 1.2-1.6 1.5-2.5",
            }
            path {
                d: "M5.5 13.9c.3.9.8 1.8 1.5 2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBird;
impl IconShape for LdBird {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 7h.01",
            }
            path {
                d: "M3.4 18H12a8 8 0 0 0 8-8V7a4 4 0 0 0-7.28-2.3L2 20",
            }
            path {
                d: "m20 7 2 .5-2 .5",
            }
            path {
                d: "M10 18v3",
            }
            path {
                d: "M14 17.75V21",
            }
            path {
                d: "M7 18a6 6 0 0 0 3.84-10.61",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBirdhouse;
impl IconShape for LdBirdhouse {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 18v4",
            }
            path {
                d: "m17 18 1.956-11.468",
            }
            path {
                d: "m3 8 7.82-5.615a2 2 0 0 1 2.36 0L21 8",
            }
            path {
                d: "M4 18h16",
            }
            path {
                d: "M7 18 5.044 6.532",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBitcoin;
impl IconShape for LdBitcoin {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.767 19.089c4.924.868 6.14-6.025 1.216-6.894m-1.216 6.894L5.86 18.047m5.908 1.042-.347 1.97m1.563-8.864c4.924.869 6.14-6.025 1.215-6.893m-1.215 6.893-3.94-.694m5.155-6.2L8.29 4.26m5.908 1.042.348-1.97M7.48 20.364l3.126-17.727",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBlend;
impl IconShape for LdBlend {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "9",
                cy: "9",
                r: "7",
            }
            circle {
                cx: "15",
                cy: "15",
                r: "7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBlinds;
impl IconShape for LdBlinds {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3h18",
            }
            path {
                d: "M20 7H8",
            }
            path {
                d: "M20 11H8",
            }
            path {
                d: "M10 19h10",
            }
            path {
                d: "M8 15h12",
            }
            path {
                d: "M4 3v14",
            }
            circle {
                cx: "4",
                cy: "19",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBlocks;
impl IconShape for LdBlocks {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 22V7a1 1 0 0 0-1-1H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-5a1 1 0 0 0-1-1H2",
            }
            rect {
                height: "8",
                rx: "1",
                width: "8",
                x: "14",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBluetoothConnected;
impl IconShape for LdBluetoothConnected {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m7 7 10 10-5 5V2l5 5L7 17",
            }
            line {
                x1: "18",
                x2: "21",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "3",
                x2: "6",
                y1: "12",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBluetoothOff;
impl IconShape for LdBluetoothOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m17 17-5 5V12l-5 5",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M14.5 9.5 17 7l-5-5v4.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBluetoothSearching;
impl IconShape for LdBluetoothSearching {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m7 7 10 10-5 5V2l5 5L7 17",
            }
            path {
                d: "M20.83 14.83a4 4 0 0 0 0-5.66",
            }
            path {
                d: "M18 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBluetooth;
impl IconShape for LdBluetooth {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m7 7 10 10-5 5V2l5 5L7 17",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBold;
impl IconShape for LdBold {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBolt;
impl IconShape for LdBolt {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBomb;
impl IconShape for LdBomb {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "11",
                cy: "13",
                r: "9",
            }
            path {
                d: "M14.35 4.65 16.3 2.7a2.41 2.41 0 0 1 3.4 0l1.6 1.6a2.4 2.4 0 0 1 0 3.4l-1.95 1.95",
            }
            path {
                d: "m22 2-1.5 1.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBone;
impl IconShape for LdBone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 10c.7-.7 1.69 0 2.5 0a2.5 2.5 0 1 0 0-5 .5.5 0 0 1-.5-.5 2.5 2.5 0 1 0-5 0c0 .81.7 1.8 0 2.5l-7 7c-.7.7-1.69 0-2.5 0a2.5 2.5 0 0 0 0 5c.28 0 .5.22.5.5a2.5 2.5 0 1 0 5 0c0-.81-.7-1.8 0-2.5Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookA;
impl IconShape for LdBookA {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "m8 13 4-7 4 7",
            }
            path {
                d: "M9.1 11h5.7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookAlert;
impl IconShape for LdBookAlert {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13h.01",
            }
            path {
                d: "M12 6v3",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookAudio;
impl IconShape for LdBookAudio {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v7",
            }
            path {
                d: "M16 8v3",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "M8 8v3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookCheck;
impl IconShape for LdBookCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "m9 9.5 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookCopy;
impl IconShape for LdBookCopy {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 7a2 2 0 0 0-2 2v11",
            }
            path {
                d: "M5.803 18H5a2 2 0 0 0 0 4h9.5a.5.5 0 0 0 .5-.5V21",
            }
            path {
                d: "M9 15V4a2 2 0 0 1 2-2h9.5a.5.5 0 0 1 .5.5v14a.5.5 0 0 1-.5.5H11a2 2 0 0 1 0-4h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookDashed;
impl IconShape for LdBookDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 17h1.5",
            }
            path {
                d: "M12 22h1.5",
            }
            path {
                d: "M12 2h1.5",
            }
            path {
                d: "M17.5 22H19a1 1 0 0 0 1-1",
            }
            path {
                d: "M17.5 2H19a1 1 0 0 1 1 1v1.5",
            }
            path {
                d: "M20 14v3h-2.5",
            }
            path {
                d: "M20 8.5V10",
            }
            path {
                d: "M4 10V8.5",
            }
            path {
                d: "M4 19.5V14",
            }
            path {
                d: "M4 4.5A2.5 2.5 0 0 1 6.5 2H8",
            }
            path {
                d: "M8 22H6.5a1 1 0 0 1 0-5H8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookDown;
impl IconShape for LdBookDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13V7",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "m9 10 3 3 3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookHeadphones;
impl IconShape for LdBookHeadphones {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "M8 12v-2a4 4 0 0 1 8 0v2",
            }
            circle {
                cx: "15",
                cy: "12",
                r: "1",
            }
            circle {
                cx: "9",
                cy: "12",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookHeart;
impl IconShape for LdBookHeart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "M8.62 9.8A2.25 2.25 0 1 1 12 6.836a2.25 2.25 0 1 1 3.38 2.966l-2.626 2.856a.998.998 0 0 1-1.507 0z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookImage;
impl IconShape for LdBookImage {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m20 13.7-2.1-2.1a2 2 0 0 0-2.8 0L9.7 17",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            circle {
                cx: "10",
                cy: "8",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookKey;
impl IconShape for LdBookKey {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m19 3 1 1",
            }
            path {
                d: "m20 2-4.5 4.5",
            }
            path {
                d: "M20 7.898V21a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2h7.844",
            }
            circle {
                cx: "14",
                cy: "8",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookLock;
impl IconShape for LdBookLock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 6V4a2 2 0 1 0-4 0v2",
            }
            path {
                d: "M20 15v6a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H10",
            }
            rect {
                height: "5",
                rx: "1",
                width: "8",
                x: "12",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookMarked;
impl IconShape for LdBookMarked {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2v8l3-3 3 3V2",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookMinus;
impl IconShape for LdBookMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "M9 10h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookOpenCheck;
impl IconShape for LdBookOpenCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 21V7",
            }
            path {
                d: "m16 12 2 2 4-4",
            }
            path {
                d: "M22 6V4a1 1 0 0 0-1-1h-5a4 4 0 0 0-4 4 4 4 0 0 0-4-4H3a1 1 0 0 0-1 1v13a1 1 0 0 0 1 1h6a3 3 0 0 1 3 3 3 3 0 0 1 3-3h6a1 1 0 0 0 1-1v-1.3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookOpenText;
impl IconShape for LdBookOpenText {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 7v14",
            }
            path {
                d: "M16 12h2",
            }
            path {
                d: "M16 8h2",
            }
            path {
                d: "M3 18a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h5a4 4 0 0 1 4 4 4 4 0 0 1 4-4h5a1 1 0 0 1 1 1v13a1 1 0 0 1-1 1h-6a3 3 0 0 0-3 3 3 3 0 0 0-3-3z",
            }
            path {
                d: "M6 12h2",
            }
            path {
                d: "M6 8h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookOpen;
impl IconShape for LdBookOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 7v14",
            }
            path {
                d: "M3 18a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h5a4 4 0 0 1 4 4 4 4 0 0 1 4-4h5a1 1 0 0 1 1 1v13a1 1 0 0 1-1 1h-6a3 3 0 0 0-3 3 3 3 0 0 0-3-3z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookPlus;
impl IconShape for LdBookPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 7v6",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "M9 10h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookText;
impl IconShape for LdBookText {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "M8 11h8",
            }
            path {
                d: "M8 7h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookType;
impl IconShape for LdBookType {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 13h4",
            }
            path {
                d: "M12 6v7",
            }
            path {
                d: "M16 8V6H8v2",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookUp2;
impl IconShape for LdBookUp2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13V7",
            }
            path {
                d: "M18 2h1a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2",
            }
            path {
                d: "m9 10 3-3 3 3",
            }
            path {
                d: "m9 5 3-3 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookUp;
impl IconShape for LdBookUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13V7",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "m9 10 3-3 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookUser;
impl IconShape for LdBookUser {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 13a3 3 0 1 0-6 0",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            circle {
                cx: "12",
                cy: "8",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookX;
impl IconShape for LdBookX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14.5 7-5 5",
            }
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
            path {
                d: "m9.5 7 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBook;
impl IconShape for LdBook {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookmarkCheck;
impl IconShape for LdBookmarkCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2Z",
            }
            path {
                d: "m9 10 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookmarkMinus;
impl IconShape for LdBookmarkMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z",
            }
            line {
                x1: "15",
                x2: "9",
                y1: "10",
                y2: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookmarkPlus;
impl IconShape for LdBookmarkPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "7",
                y2: "13",
            }
            line {
                x1: "15",
                x2: "9",
                y1: "10",
                y2: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookmarkX;
impl IconShape for LdBookmarkX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2Z",
            }
            path {
                d: "m14.5 7.5-5 5",
            }
            path {
                d: "m9.5 7.5 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBookmark;
impl IconShape for LdBookmark {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBoomBox;
impl IconShape for LdBoomBox {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 9V5a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v4",
            }
            path {
                d: "M8 8v1",
            }
            path {
                d: "M12 8v1",
            }
            path {
                d: "M16 8v1",
            }
            rect {
                height: "12",
                rx: "2",
                width: "20",
                x: "2",
                y: "9",
            }
            circle {
                cx: "8",
                cy: "15",
                r: "2",
            }
            circle {
                cx: "16",
                cy: "15",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBotMessageSquare;
impl IconShape for LdBotMessageSquare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6V2H8",
            }
            path {
                d: "M15 11v2",
            }
            path {
                d: "M2 12h2",
            }
            path {
                d: "M20 12h2",
            }
            path {
                d: "M20 16a2 2 0 0 1-2 2H8.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 4 20.286V8a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2z",
            }
            path {
                d: "M9 11v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBotOff;
impl IconShape for LdBotOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.67 8H18a2 2 0 0 1 2 2v4.33",
            }
            path {
                d: "M2 14h2",
            }
            path {
                d: "M20 14h2",
            }
            path {
                d: "M22 22 2 2",
            }
            path {
                d: "M8 8H6a2 2 0 0 0-2 2v8a2 2 0 0 0 2 2h12a2 2 0 0 0 1.414-.586",
            }
            path {
                d: "M9 13v2",
            }
            path {
                d: "M9.67 4H12v2.33",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBot;
impl IconShape for LdBot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 8V4H8",
            }
            rect {
                height: "12",
                rx: "2",
                width: "16",
                x: "4",
                y: "8",
            }
            path {
                d: "M2 14h2",
            }
            path {
                d: "M20 14h2",
            }
            path {
                d: "M15 13v2",
            }
            path {
                d: "M9 13v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBottleWine;
impl IconShape for LdBottleWine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 3a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v2a6 6 0 0 0 1.2 3.6l.6.8A6 6 0 0 1 17 13v8a1 1 0 0 1-1 1H8a1 1 0 0 1-1-1v-8a6 6 0 0 1 1.2-3.6l.6-.8A6 6 0 0 0 10 5z",
            }
            path {
                d: "M17 13h-4a1 1 0 0 0-1 1v3a1 1 0 0 0 1 1h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBowArrow;
impl IconShape for LdBowArrow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 3h4v4",
            }
            path {
                d: "M18.575 11.082a13 13 0 0 1 1.048 9.027 1.17 1.17 0 0 1-1.914.597L14 17",
            }
            path {
                d: "M7 10 3.29 6.29a1.17 1.17 0 0 1 .6-1.91 13 13 0 0 1 9.03 1.05",
            }
            path {
                d: "M7 14a1.7 1.7 0 0 0-1.207.5l-2.646 2.646A.5.5 0 0 0 3.5 18H5a1 1 0 0 1 1 1v1.5a.5.5 0 0 0 .854.354L9.5 18.207A1.7 1.7 0 0 0 10 17v-2a1 1 0 0 0-1-1z",
            }
            path {
                d: "M9.707 14.293 21 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBox;
impl IconShape for LdBox {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z",
            }
            path {
                d: "m3.3 7 8.7 5 8.7-5",
            }
            path {
                d: "M12 22V12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBoxes;
impl IconShape for LdBoxes {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.97 12.92A2 2 0 0 0 2 14.63v3.24a2 2 0 0 0 .97 1.71l3 1.8a2 2 0 0 0 2.06 0L12 19v-5.5l-5-3-4.03 2.42Z",
            }
            path {
                d: "m7 16.5-4.74-2.85",
            }
            path {
                d: "m7 16.5 5-3",
            }
            path {
                d: "M7 16.5v5.17",
            }
            path {
                d: "M12 13.5V19l3.97 2.38a2 2 0 0 0 2.06 0l3-1.8a2 2 0 0 0 .97-1.71v-3.24a2 2 0 0 0-.97-1.71L17 10.5l-5 3Z",
            }
            path {
                d: "m17 16.5-5-3",
            }
            path {
                d: "m17 16.5 4.74-2.85",
            }
            path {
                d: "M17 16.5v5.17",
            }
            path {
                d: "M7.97 4.42A2 2 0 0 0 7 6.13v4.37l5 3 5-3V6.13a2 2 0 0 0-.97-1.71l-3-1.8a2 2 0 0 0-2.06 0l-3 1.8Z",
            }
            path {
                d: "M12 8 7.26 5.15",
            }
            path {
                d: "m12 8 4.74-2.85",
            }
            path {
                d: "M12 13.5V8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBraces;
impl IconShape for LdBraces {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 3H7a2 2 0 0 0-2 2v5a2 2 0 0 1-2 2 2 2 0 0 1 2 2v5c0 1.1.9 2 2 2h1",
            }
            path {
                d: "M16 21h1a2 2 0 0 0 2-2v-5c0-1.1.9-2 2-2a2 2 0 0 1-2-2V5a2 2 0 0 0-2-2h-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBrackets;
impl IconShape for LdBrackets {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 3h3a1 1 0 0 1 1 1v16a1 1 0 0 1-1 1h-3",
            }
            path {
                d: "M8 21H5a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBrainCircuit;
impl IconShape for LdBrainCircuit {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 5a3 3 0 1 0-5.997.125 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588A4 4 0 1 0 12 18Z",
            }
            path {
                d: "M9 13a4.5 4.5 0 0 0 3-4",
            }
            path {
                d: "M6.003 5.125A3 3 0 0 0 6.401 6.5",
            }
            path {
                d: "M3.477 10.896a4 4 0 0 1 .585-.396",
            }
            path {
                d: "M6 18a4 4 0 0 1-1.967-.516",
            }
            path {
                d: "M12 13h4",
            }
            path {
                d: "M12 18h6a2 2 0 0 1 2 2v1",
            }
            path {
                d: "M12 8h8",
            }
            path {
                d: "M16 8V5a2 2 0 0 1 2-2",
            }
            circle {
                cx: "16",
                cy: "13",
                r: ".5",
            }
            circle {
                cx: "18",
                cy: "3",
                r: ".5",
            }
            circle {
                cx: "20",
                cy: "21",
                r: ".5",
            }
            circle {
                cx: "20",
                cy: "8",
                r: ".5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBrainCog;
impl IconShape for LdBrainCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10.852 14.772-.383.923",
            }
            path {
                d: "m10.852 9.228-.383-.923",
            }
            path {
                d: "m13.148 14.772.382.924",
            }
            path {
                d: "m13.531 8.305-.383.923",
            }
            path {
                d: "m14.772 10.852.923-.383",
            }
            path {
                d: "m14.772 13.148.923.383",
            }
            path {
                d: "M17.598 6.5A3 3 0 1 0 12 5a3 3 0 0 0-5.63-1.446 3 3 0 0 0-.368 1.571 4 4 0 0 0-2.525 5.771",
            }
            path {
                d: "M17.998 5.125a4 4 0 0 1 2.525 5.771",
            }
            path {
                d: "M19.505 10.294a4 4 0 0 1-1.5 7.706",
            }
            path {
                d: "M4.032 17.483A4 4 0 0 0 11.464 20c.18-.311.892-.311 1.072 0a4 4 0 0 0 7.432-2.516",
            }
            path {
                d: "M4.5 10.291A4 4 0 0 0 6 18",
            }
            path {
                d: "M6.002 5.125a3 3 0 0 0 .4 1.375",
            }
            path {
                d: "m9.228 10.852-.923-.383",
            }
            path {
                d: "m9.228 13.148-.923.383",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBrain;
impl IconShape for LdBrain {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 18V5",
            }
            path {
                d: "M15 13a4.17 4.17 0 0 1-3-4 4.17 4.17 0 0 1-3 4",
            }
            path {
                d: "M17.598 6.5A3 3 0 1 0 12 5a3 3 0 1 0-5.598 1.5",
            }
            path {
                d: "M17.997 5.125a4 4 0 0 1 2.526 5.77",
            }
            path {
                d: "M18 18a4 4 0 0 0 2-7.464",
            }
            path {
                d: "M19.967 17.483A4 4 0 1 1 12 18a4 4 0 1 1-7.967-.517",
            }
            path {
                d: "M6 18a4 4 0 0 1-2-7.464",
            }
            path {
                d: "M6.003 5.125a4 4 0 0 0-2.526 5.77",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBrickWallFire;
impl IconShape for LdBrickWallFire {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 3v2.107",
            }
            path {
                d: "M17 9c1 3 2.5 3.5 3.5 4.5A5 5 0 0 1 22 17a5 5 0 0 1-10 0c0-.3 0-.6.1-.9a2 2 0 1 0 3.3-2C13 11.5 16 9 17 9",
            }
            path {
                d: "M21 8.274V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h3.938",
            }
            path {
                d: "M3 15h5.253",
            }
            path {
                d: "M3 9h8.228",
            }
            path {
                d: "M8 15v6",
            }
            path {
                d: "M8 3v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBrickWallShield;
impl IconShape for LdBrickWallShield {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 9v1.258",
            }
            path {
                d: "M16 3v5.46",
            }
            path {
                d: "M21 9.118V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h5.75",
            }
            path {
                d: "M22 17.5c0 2.499-1.75 3.749-3.83 4.474a.5.5 0 0 1-.335-.005c-2.085-.72-3.835-1.97-3.835-4.47V14a.5.5 0 0 1 .5-.499c1 0 2.25-.6 3.12-1.36a.6.6 0 0 1 .76-.001c.875.765 2.12 1.36 3.12 1.36a.5.5 0 0 1 .5.5z",
            }
            path {
                d: "M3 15h7",
            }
            path {
                d: "M3 9h12.142",
            }
            path {
                d: "M8 15v6",
            }
            path {
                d: "M8 3v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBrickWall;
impl IconShape for LdBrickWall {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M12 9v6",
            }
            path {
                d: "M16 15v6",
            }
            path {
                d: "M16 3v6",
            }
            path {
                d: "M3 15h18",
            }
            path {
                d: "M3 9h18",
            }
            path {
                d: "M8 15v6",
            }
            path {
                d: "M8 3v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBriefcaseBusiness;
impl IconShape for LdBriefcaseBusiness {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 12h.01",
            }
            path {
                d: "M16 6V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2",
            }
            path {
                d: "M22 13a18.15 18.15 0 0 1-20 0",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBriefcaseConveyorBelt;
impl IconShape for LdBriefcaseConveyorBelt {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 20v2",
            }
            path {
                d: "M14 20v2",
            }
            path {
                d: "M18 20v2",
            }
            path {
                d: "M21 20H3",
            }
            path {
                d: "M6 20v2",
            }
            path {
                d: "M8 16V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v12",
            }
            rect {
                height: "10",
                rx: "2",
                width: "16",
                x: "4",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBriefcaseMedical;
impl IconShape for LdBriefcaseMedical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 11v4",
            }
            path {
                d: "M14 13h-4",
            }
            path {
                d: "M16 6V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2",
            }
            path {
                d: "M18 6v14",
            }
            path {
                d: "M6 6v14",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBriefcase;
impl IconShape for LdBriefcase {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 20V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBringToFront;
impl IconShape for LdBringToFront {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "8",
                rx: "2",
                width: "8",
                x: "8",
                y: "8",
            }
            path {
                d: "M4 10a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2",
            }
            path {
                d: "M14 20a2 2 0 0 0 2 2h4a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBrushCleaning;
impl IconShape for LdBrushCleaning {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 22-1-4",
            }
            path {
                d: "M19 13.99a1 1 0 0 0 1-1V12a2 2 0 0 0-2-2h-3a1 1 0 0 1-1-1V4a2 2 0 0 0-4 0v5a1 1 0 0 1-1 1H6a2 2 0 0 0-2 2v.99a1 1 0 0 0 1 1",
            }
            path {
                d: "M5 14h14l1.973 6.767A1 1 0 0 1 20 22H4a1 1 0 0 1-.973-1.233z",
            }
            path {
                d: "m8 22 1-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBrush;
impl IconShape for LdBrush {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m11 10 3 3",
            }
            path {
                d: "M6.5 21A3.5 3.5 0 1 0 3 17.5a2.62 2.62 0 0 1-.708 1.792A1 1 0 0 0 3 21z",
            }
            path {
                d: "M9.969 17.031 21.378 5.624a1 1 0 0 0-3.002-3.002L6.967 14.031",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBubbles;
impl IconShape for LdBubbles {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7.2 14.8a2 2 0 0 1 2 2",
            }
            circle {
                cx: "18.5",
                cy: "8.5",
                r: "3.5",
            }
            circle {
                cx: "7.5",
                cy: "16.5",
                r: "5.5",
            }
            circle {
                cx: "7.5",
                cy: "4.5",
                r: "2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBugOff;
impl IconShape for LdBugOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 20v-8",
            }
            path {
                d: "M14.12 3.88 16 2",
            }
            path {
                d: "M15 7.13V6a3 3 0 0 0-5.14-2.1L8 2",
            }
            path {
                d: "M18 12.34V11a4 4 0 0 0-4-4h-1.3",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M21 5a4 4 0 0 1-3.55 3.97",
            }
            path {
                d: "M22 13h-3.34",
            }
            path {
                d: "M3 21a4 4 0 0 1 3.81-4",
            }
            path {
                d: "M6 13H2",
            }
            path {
                d: "M7.7 7.7A4 4 0 0 0 6 11v3a6 6 0 0 0 11.13 3.13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBugPlay;
impl IconShape for LdBugPlay {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 19.655A6 6 0 0 1 6 14v-3a4 4 0 0 1 4-4h4a4 4 0 0 1 4 3.97",
            }
            path {
                d: "M14 15.003a1 1 0 0 1 1.517-.859l4.997 2.997a1 1 0 0 1 0 1.718l-4.997 2.997a1 1 0 0 1-1.517-.86z",
            }
            path {
                d: "M14.12 3.88 16 2",
            }
            path {
                d: "M21 5a4 4 0 0 1-3.55 3.97",
            }
            path {
                d: "M3 21a4 4 0 0 1 3.81-4",
            }
            path {
                d: "M3 5a4 4 0 0 0 3.55 3.97",
            }
            path {
                d: "M6 13H2",
            }
            path {
                d: "m8 2 1.88 1.88",
            }
            path {
                d: "M9 7.13V6a3 3 0 1 1 6 0v1.13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBug;
impl IconShape for LdBug {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 20v-9",
            }
            path {
                d: "M14 7a4 4 0 0 1 4 4v3a6 6 0 0 1-12 0v-3a4 4 0 0 1 4-4z",
            }
            path {
                d: "M14.12 3.88 16 2",
            }
            path {
                d: "M21 21a4 4 0 0 0-3.81-4",
            }
            path {
                d: "M21 5a4 4 0 0 1-3.55 3.97",
            }
            path {
                d: "M22 13h-4",
            }
            path {
                d: "M3 21a4 4 0 0 1 3.81-4",
            }
            path {
                d: "M3 5a4 4 0 0 0 3.55 3.97",
            }
            path {
                d: "M6 13H2",
            }
            path {
                d: "m8 2 1.88 1.88",
            }
            path {
                d: "M9 7.13V6a3 3 0 1 1 6 0v1.13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBuilding2;
impl IconShape for LdBuilding2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 12h4",
            }
            path {
                d: "M10 8h4",
            }
            path {
                d: "M14 21v-3a2 2 0 0 0-4 0v3",
            }
            path {
                d: "M6 10H4a2 2 0 0 0-2 2v7a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V9a2 2 0 0 0-2-2h-2",
            }
            path {
                d: "M6 21V5a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBuilding;
impl IconShape for LdBuilding {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 10h.01",
            }
            path {
                d: "M12 14h.01",
            }
            path {
                d: "M12 6h.01",
            }
            path {
                d: "M16 10h.01",
            }
            path {
                d: "M16 14h.01",
            }
            path {
                d: "M16 6h.01",
            }
            path {
                d: "M8 10h.01",
            }
            path {
                d: "M8 14h.01",
            }
            path {
                d: "M8 6h.01",
            }
            path {
                d: "M9 22v-3a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v3",
            }
            rect {
                height: "20",
                rx: "2",
                width: "16",
                x: "4",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBusFront;
impl IconShape for LdBusFront {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 6 2 7",
            }
            path {
                d: "M10 6h4",
            }
            path {
                d: "m22 7-2-1",
            }
            rect {
                height: "16",
                rx: "2",
                width: "16",
                x: "4",
                y: "3",
            }
            path {
                d: "M4 11h16",
            }
            path {
                d: "M8 15h.01",
            }
            path {
                d: "M16 15h.01",
            }
            path {
                d: "M6 19v2",
            }
            path {
                d: "M18 21v-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdBus;
impl IconShape for LdBus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 6v6",
            }
            path {
                d: "M15 6v6",
            }
            path {
                d: "M2 12h19.6",
            }
            path {
                d: "M18 18h3s.5-1.7.8-2.8c.1-.4.2-.8.2-1.2 0-.4-.1-.8-.2-1.2l-1.4-5C20.1 6.8 19.1 6 18 6H4a2 2 0 0 0-2 2v10h3",
            }
            circle {
                cx: "7",
                cy: "18",
                r: "2",
            }
            path {
                d: "M9 18h5",
            }
            circle {
                cx: "16",
                cy: "18",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCableCar;
impl IconShape for LdCableCar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 3h.01",
            }
            path {
                d: "M14 2h.01",
            }
            path {
                d: "m2 9 20-5",
            }
            path {
                d: "M12 12V6.5",
            }
            rect {
                height: "10",
                rx: "3",
                width: "16",
                x: "4",
                y: "12",
            }
            path {
                d: "M9 12v5",
            }
            path {
                d: "M15 12v5",
            }
            path {
                d: "M4 17h16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCable;
impl IconShape for LdCable {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 19a1 1 0 0 1-1-1v-2a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2v2a1 1 0 0 1-1 1z",
            }
            path {
                d: "M17 21v-2",
            }
            path {
                d: "M19 14V6.5a1 1 0 0 0-7 0v11a1 1 0 0 1-7 0V10",
            }
            path {
                d: "M21 21v-2",
            }
            path {
                d: "M3 5V3",
            }
            path {
                d: "M4 10a2 2 0 0 1-2-2V6a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2a2 2 0 0 1-2 2z",
            }
            path {
                d: "M7 5V3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCakeSlice;
impl IconShape for LdCakeSlice {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 13H3",
            }
            path {
                d: "M16 17H3",
            }
            path {
                d: "m7.2 7.9-3.388 2.5A2 2 0 0 0 3 12.01V20a1 1 0 0 0 1 1h16a1 1 0 0 0 1-1v-8.654c0-2-2.44-6.026-6.44-8.026a1 1 0 0 0-1.082.057L10.4 5.6",
            }
            circle {
                cx: "9",
                cy: "7",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCake;
impl IconShape for LdCake {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 21v-8a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v8",
            }
            path {
                d: "M4 16s.5-1 2-1 2.5 2 4 2 2.5-2 4-2 2.5 2 4 2 2-1 2-1",
            }
            path {
                d: "M2 21h20",
            }
            path {
                d: "M7 8v3",
            }
            path {
                d: "M12 8v3",
            }
            path {
                d: "M17 8v3",
            }
            path {
                d: "M7 4h.01",
            }
            path {
                d: "M12 4h.01",
            }
            path {
                d: "M17 4h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalculator;
impl IconShape for LdCalculator {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "2",
                width: "16",
                x: "4",
                y: "2",
            }
            line {
                x1: "8",
                x2: "16",
                y1: "6",
                y2: "6",
            }
            line {
                x1: "16",
                x2: "16",
                y1: "14",
                y2: "18",
            }
            path {
                d: "M16 10h.01",
            }
            path {
                d: "M12 10h.01",
            }
            path {
                d: "M8 10h.01",
            }
            path {
                d: "M12 14h.01",
            }
            path {
                d: "M8 14h.01",
            }
            path {
                d: "M12 18h.01",
            }
            path {
                d: "M8 18h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendar1;
impl IconShape for LdCalendar1 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 14h1v4",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M8 2v4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarArrowDown;
impl IconShape for LdCalendarArrowDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14 18 4 4 4-4",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M18 14v8",
            }
            path {
                d: "M21 11.354V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7.343",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M8 2v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarArrowUp;
impl IconShape for LdCalendarArrowUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14 18 4-4 4 4",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M18 22v-8",
            }
            path {
                d: "M21 11.343V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h9",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M8 2v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarCheck2;
impl IconShape for LdCalendarCheck2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2v4",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M21 14V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "m16 20 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarCheck;
impl IconShape for LdCalendarCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2v4",
            }
            path {
                d: "M16 2v4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "m9 16 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarClock;
impl IconShape for LdCalendarClock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 14v2.2l1.6 1",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M21 7.5V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h3.5",
            }
            path {
                d: "M3 10h5",
            }
            path {
                d: "M8 2v4",
            }
            circle {
                cx: "16",
                cy: "16",
                r: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarCog;
impl IconShape for LdCalendarCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15.228 16.852-.923-.383",
            }
            path {
                d: "m15.228 19.148-.923.383",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "m16.47 14.305.382.923",
            }
            path {
                d: "m16.852 20.772-.383.924",
            }
            path {
                d: "m19.148 15.228.383-.923",
            }
            path {
                d: "m19.53 21.696-.382-.924",
            }
            path {
                d: "m20.772 16.852.924-.383",
            }
            path {
                d: "m20.772 19.148.924.383",
            }
            path {
                d: "M21 10.592V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M8 2v4",
            }
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarDays;
impl IconShape for LdCalendarDays {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2v4",
            }
            path {
                d: "M16 2v4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M8 14h.01",
            }
            path {
                d: "M12 14h.01",
            }
            path {
                d: "M16 14h.01",
            }
            path {
                d: "M8 18h.01",
            }
            path {
                d: "M12 18h.01",
            }
            path {
                d: "M16 18h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarFold;
impl IconShape for LdCalendarFold {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 20a2 2 0 0 0 2 2h10a2.4 2.4 0 0 0 1.706-.706l3.588-3.588A2.4 2.4 0 0 0 21 16V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2z",
            }
            path {
                d: "M15 22v-5a1 1 0 0 1 1-1h5",
            }
            path {
                d: "M8 2v4",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M3 10h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarHeart;
impl IconShape for LdCalendarHeart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.127 22H5a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v5.125",
            }
            path {
                d: "M14.62 18.8A2.25 2.25 0 1 1 18 15.836a2.25 2.25 0 1 1 3.38 2.966l-2.626 2.856a.998.998 0 0 1-1.507 0z",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M8 2v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarMinus2;
impl IconShape for LdCalendarMinus2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2v4",
            }
            path {
                d: "M16 2v4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M10 16h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarMinus;
impl IconShape for LdCalendarMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 19h6",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M21 15V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8.5",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M8 2v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarOff;
impl IconShape for LdCalendarOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4.2 4.2A2 2 0 0 0 3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 1.82-1.18",
            }
            path {
                d: "M21 15.5V6a2 2 0 0 0-2-2H9.5",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M3 10h7",
            }
            path {
                d: "M21 10h-5.5",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarPlus2;
impl IconShape for LdCalendarPlus2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2v4",
            }
            path {
                d: "M16 2v4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M10 16h4",
            }
            path {
                d: "M12 14v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarPlus;
impl IconShape for LdCalendarPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 19h6",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M19 16v6",
            }
            path {
                d: "M21 12.598V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8.5",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M8 2v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarRange;
impl IconShape for LdCalendarRange {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M8 2v4",
            }
            path {
                d: "M17 14h-6",
            }
            path {
                d: "M13 18H7",
            }
            path {
                d: "M7 14h.01",
            }
            path {
                d: "M17 18h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarSearch;
impl IconShape for LdCalendarSearch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 2v4",
            }
            path {
                d: "M21 11.75V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7.25",
            }
            path {
                d: "m22 22-1.875-1.875",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "M8 2v4",
            }
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarSync;
impl IconShape for LdCalendarSync {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 10v4h4",
            }
            path {
                d: "m11 14 1.535-1.605a5 5 0 0 1 8 1.5",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "m21 18-1.535 1.605a5 5 0 0 1-8-1.5",
            }
            path {
                d: "M21 22v-4h-4",
            }
            path {
                d: "M21 8.5V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h4.3",
            }
            path {
                d: "M3 10h4",
            }
            path {
                d: "M8 2v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarX2;
impl IconShape for LdCalendarX2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2v4",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M21 13V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "m17 22 5-5",
            }
            path {
                d: "m17 17 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendarX;
impl IconShape for LdCalendarX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2v4",
            }
            path {
                d: "M16 2v4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
            path {
                d: "M3 10h18",
            }
            path {
                d: "m14 14-4 4",
            }
            path {
                d: "m10 14 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendar;
impl IconShape for LdCalendar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2v4",
            }
            path {
                d: "M16 2v4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
            path {
                d: "M3 10h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCalendars;
impl IconShape for LdCalendars {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v2",
            }
            path {
                d: "M15.726 21.01A2 2 0 0 1 14 22H4a2 2 0 0 1-2-2V10a2 2 0 0 1 2-2",
            }
            path {
                d: "M18 2v2",
            }
            path {
                d: "M2 13h2",
            }
            path {
                d: "M8 8h14",
            }
            rect {
                height: "14",
                rx: "2",
                width: "14",
                x: "8",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCameraOff;
impl IconShape for LdCameraOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14.564 14.558a3 3 0 1 1-4.122-4.121",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M20 20H4a2 2 0 0 1-2-2V9a2 2 0 0 1 2-2h1.997a2 2 0 0 0 .819-.175",
            }
            path {
                d: "M9.695 4.024A2 2 0 0 1 10.004 4h3.993a2 2 0 0 1 1.76 1.05l.486.9A2 2 0 0 0 18.003 7H20a2 2 0 0 1 2 2v7.344",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCamera;
impl IconShape for LdCamera {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.997 4a2 2 0 0 1 1.76 1.05l.486.9A2 2 0 0 0 18.003 7H20a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9a2 2 0 0 1 2-2h1.997a2 2 0 0 0 1.759-1.048l.489-.904A2 2 0 0 1 10.004 4z",
            }
            circle {
                cx: "12",
                cy: "13",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCandyCane;
impl IconShape for LdCandyCane {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5.7 21a2 2 0 0 1-3.5-2l8.6-14a6 6 0 0 1 10.4 6 2 2 0 1 1-3.464-2 2 2 0 1 0-3.464-2Z",
            }
            path {
                d: "M17.75 7 15 2.1",
            }
            path {
                d: "M10.9 4.8 13 9",
            }
            path {
                d: "m7.9 9.7 2 4.4",
            }
            path {
                d: "M4.9 14.7 7 18.9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCandyOff;
impl IconShape for LdCandyOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 10v7.9",
            }
            path {
                d: "M11.802 6.145a5 5 0 0 1 6.053 6.053",
            }
            path {
                d: "M14 6.1v2.243",
            }
            path {
                d: "m15.5 15.571-.964.964a5 5 0 0 1-7.071 0 5 5 0 0 1 0-7.07l.964-.965",
            }
            path {
                d: "M16 7V3a1 1 0 0 1 1.707-.707 2.5 2.5 0 0 0 2.152.717 1 1 0 0 1 1.131 1.131 2.5 2.5 0 0 0 .717 2.152A1 1 0 0 1 21 8h-4",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M8 17v4a1 1 0 0 1-1.707.707 2.5 2.5 0 0 0-2.152-.717 1 1 0 0 1-1.131-1.131 2.5 2.5 0 0 0-.717-2.152A1 1 0 0 1 3 16h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCandy;
impl IconShape for LdCandy {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 7v10.9",
            }
            path {
                d: "M14 6.1V17",
            }
            path {
                d: "M16 7V3a1 1 0 0 1 1.707-.707 2.5 2.5 0 0 0 2.152.717 1 1 0 0 1 1.131 1.131 2.5 2.5 0 0 0 .717 2.152A1 1 0 0 1 21 8h-4",
            }
            path {
                d: "M16.536 7.465a5 5 0 0 0-7.072 0l-2 2a5 5 0 0 0 0 7.07 5 5 0 0 0 7.072 0l2-2a5 5 0 0 0 0-7.07",
            }
            path {
                d: "M8 17v4a1 1 0 0 1-1.707.707 2.5 2.5 0 0 0-2.152-.717 1 1 0 0 1-1.131-1.131 2.5 2.5 0 0 0-.717-2.152A1 1 0 0 1 3 16h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCannabis;
impl IconShape for LdCannabis {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 22v-4",
            }
            path {
                d: "M7 12c-1.5 0-4.5 1.5-5 3 3.5 1.5 6 1 6 1-1.5 1.5-2 3.5-2 5 2.5 0 4.5-1.5 6-3 1.5 1.5 3.5 3 6 3 0-1.5-.5-3.5-2-5 0 0 2.5.5 6-1-.5-1.5-3.5-3-5-3 1.5-1 4-4 4-6-2.5 0-5.5 1.5-7 3 0-2.5-.5-5-2-7-1.5 2-2 4.5-2 7-1.5-1.5-4.5-3-7-3 0 2 2.5 5 4 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCaptionsOff;
impl IconShape for LdCaptionsOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.5 5H19a2 2 0 0 1 2 2v8.5",
            }
            path {
                d: "M17 11h-.5",
            }
            path {
                d: "M19 19H5a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M7 11h4",
            }
            path {
                d: "M7 15h2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCaptions;
impl IconShape for LdCaptions {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "5",
            }
            path {
                d: "M7 15h4M15 15h2M7 11h2M13 11h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCarFront;
impl IconShape for LdCarFront {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m21 8-2 2-1.5-3.7A2 2 0 0 0 15.646 5H8.4a2 2 0 0 0-1.903 1.257L5 10 3 8",
            }
            path {
                d: "M7 14h.01",
            }
            path {
                d: "M17 14h.01",
            }
            rect {
                height: "8",
                rx: "2",
                width: "18",
                x: "3",
                y: "10",
            }
            path {
                d: "M5 18v2",
            }
            path {
                d: "M19 18v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCarTaxiFront;
impl IconShape for LdCarTaxiFront {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2h4",
            }
            path {
                d: "m21 8-2 2-1.5-3.7A2 2 0 0 0 15.646 5H8.4a2 2 0 0 0-1.903 1.257L5 10 3 8",
            }
            path {
                d: "M7 14h.01",
            }
            path {
                d: "M17 14h.01",
            }
            rect {
                height: "8",
                rx: "2",
                width: "18",
                x: "3",
                y: "10",
            }
            path {
                d: "M5 18v2",
            }
            path {
                d: "M19 18v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCar;
impl IconShape for LdCar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 17h2c.6 0 1-.4 1-1v-3c0-.9-.7-1.7-1.5-1.9C18.7 10.6 16 10 16 10s-1.3-1.4-2.2-2.3c-.5-.4-1.1-.7-1.8-.7H5c-.6 0-1.1.4-1.4.9l-1.4 2.9A3.7 3.7 0 0 0 2 12v4c0 .6.4 1 1 1h2",
            }
            circle {
                cx: "7",
                cy: "17",
                r: "2",
            }
            path {
                d: "M9 17h6",
            }
            circle {
                cx: "17",
                cy: "17",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCaravan;
impl IconShape for LdCaravan {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 19V9a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v8a2 2 0 0 0 2 2h2",
            }
            path {
                d: "M2 9h3a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1H2",
            }
            path {
                d: "M22 17v1a1 1 0 0 1-1 1H10v-9a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v9",
            }
            circle {
                cx: "8",
                cy: "19",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCardSim;
impl IconShape for LdCardSim {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 14v4",
            }
            path {
                d: "M14.172 2a2 2 0 0 1 1.414.586l3.828 3.828A2 2 0 0 1 20 7.828V20a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2z",
            }
            path {
                d: "M8 14h8",
            }
            rect {
                height: "8",
                rx: "1",
                width: "8",
                x: "8",
                y: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCarrot;
impl IconShape for LdCarrot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.27 21.7s9.87-3.5 12.73-6.36a4.5 4.5 0 0 0-6.36-6.37C5.77 11.84 2.27 21.7 2.27 21.7zM8.64 14l-2.05-2.04M15.34 15l-2.46-2.46",
            }
            path {
                d: "M22 9s-1.33-2-3.5-2C16.86 7 15 9 15 9s1.33 2 3.5 2S22 9 22 9z",
            }
            path {
                d: "M15 2s-2 1.33-2 3.5S15 9 15 9s2-1.84 2-3.5C17 3.33 15 2 15 2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCaseLower;
impl IconShape for LdCaseLower {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 9v7",
            }
            path {
                d: "M14 6v10",
            }
            circle {
                cx: "17.5",
                cy: "12.5",
                r: "3.5",
            }
            circle {
                cx: "6.5",
                cy: "12.5",
                r: "3.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCaseSensitive;
impl IconShape for LdCaseSensitive {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 16 4.039-9.69a.5.5 0 0 1 .923 0L11 16",
            }
            path {
                d: "M22 9v7",
            }
            path {
                d: "M3.304 13h6.392",
            }
            circle {
                cx: "18.5",
                cy: "12.5",
                r: "3.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCaseUpper;
impl IconShape for LdCaseUpper {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 11h4.5a1 1 0 0 1 0 5h-4a.5.5 0 0 1-.5-.5v-9a.5.5 0 0 1 .5-.5h3a1 1 0 0 1 0 5",
            }
            path {
                d: "m2 16 4.039-9.69a.5.5 0 0 1 .923 0L11 16",
            }
            path {
                d: "M3.304 13h6.392",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCassetteTape;
impl IconShape for LdCassetteTape {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
            circle {
                cx: "8",
                cy: "10",
                r: "2",
            }
            path {
                d: "M8 12h8",
            }
            circle {
                cx: "16",
                cy: "10",
                r: "2",
            }
            path {
                d: "m6 20 .7-2.9A1.4 1.4 0 0 1 8.1 16h7.8a1.4 1.4 0 0 1 1.4 1l.7 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCast;
impl IconShape for LdCast {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 8V6a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-6",
            }
            path {
                d: "M2 12a9 9 0 0 1 8 8",
            }
            path {
                d: "M2 16a5 5 0 0 1 4 4",
            }
            line {
                x1: "2",
                x2: "2.01",
                y1: "20",
                y2: "20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCastle;
impl IconShape for LdCastle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 5V3",
            }
            path {
                d: "M14 5V3",
            }
            path {
                d: "M15 21v-3a3 3 0 0 0-6 0v3",
            }
            path {
                d: "M18 3v8",
            }
            path {
                d: "M18 5H6",
            }
            path {
                d: "M22 11H2",
            }
            path {
                d: "M22 9v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9",
            }
            path {
                d: "M6 3v8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCat;
impl IconShape for LdCat {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 5c.67 0 1.35.09 2 .26 1.78-2 5.03-2.84 6.42-2.26 1.4.58-.42 7-.42 7 .57 1.07 1 2.24 1 3.44C21 17.9 16.97 21 12 21s-9-3-9-7.56c0-1.25.5-2.4 1-3.44 0 0-1.89-6.42-.5-7 1.39-.58 4.72.23 6.5 2.23A9.04 9.04 0 0 1 12 5Z",
            }
            path {
                d: "M8 14v.5",
            }
            path {
                d: "M16 14v.5",
            }
            path {
                d: "M11.25 16.25h1.5L12 17l-.75-.75Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCctv;
impl IconShape for LdCctv {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16.75 12h3.632a1 1 0 0 1 .894 1.447l-2.034 4.069a1 1 0 0 1-1.708.134l-2.124-2.97",
            }
            path {
                d: "M17.106 9.053a1 1 0 0 1 .447 1.341l-3.106 6.211a1 1 0 0 1-1.342.447L3.61 12.3a2.92 2.92 0 0 1-1.3-3.91L3.69 5.6a2.92 2.92 0 0 1 3.92-1.3z",
            }
            path {
                d: "M2 19h3.76a2 2 0 0 0 1.8-1.1L9 15",
            }
            path {
                d: "M2 21v-4",
            }
            path {
                d: "M7 9h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartArea;
impl IconShape for LdChartArea {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            path {
                d: "M7 11.207a.5.5 0 0 1 .146-.353l2-2a.5.5 0 0 1 .708 0l3.292 3.292a.5.5 0 0 0 .708 0l4.292-4.292a.5.5 0 0 1 .854.353V16a1 1 0 0 1-1 1H8a1 1 0 0 1-1-1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartBarBig;
impl IconShape for LdChartBarBig {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            rect {
                height: "4",
                rx: "1",
                width: "9",
                x: "7",
                y: "13",
            }
            rect {
                height: "4",
                rx: "1",
                width: "12",
                x: "7",
                y: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartBarDecreasing;
impl IconShape for LdChartBarDecreasing {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            path {
                d: "M7 11h8",
            }
            path {
                d: "M7 16h3",
            }
            path {
                d: "M7 6h12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartBarIncreasing;
impl IconShape for LdChartBarIncreasing {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            path {
                d: "M7 11h8",
            }
            path {
                d: "M7 16h12",
            }
            path {
                d: "M7 6h3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartBarStacked;
impl IconShape for LdChartBarStacked {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 13v4",
            }
            path {
                d: "M15 5v4",
            }
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            rect {
                height: "4",
                rx: "1",
                width: "9",
                x: "7",
                y: "13",
            }
            rect {
                height: "4",
                rx: "1",
                width: "12",
                x: "7",
                y: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartBar;
impl IconShape for LdChartBar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            path {
                d: "M7 16h8",
            }
            path {
                d: "M7 11h12",
            }
            path {
                d: "M7 6h3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartCandlestick;
impl IconShape for LdChartCandlestick {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 5v4",
            }
            rect {
                height: "6",
                rx: "1",
                width: "4",
                x: "7",
                y: "9",
            }
            path {
                d: "M9 15v2",
            }
            path {
                d: "M17 3v2",
            }
            rect {
                height: "8",
                rx: "1",
                width: "4",
                x: "15",
                y: "5",
            }
            path {
                d: "M17 13v3",
            }
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartColumnBig;
impl IconShape for LdChartColumnBig {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            rect {
                height: "12",
                rx: "1",
                width: "4",
                x: "15",
                y: "5",
            }
            rect {
                height: "9",
                rx: "1",
                width: "4",
                x: "7",
                y: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartColumnDecreasing;
impl IconShape for LdChartColumnDecreasing {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 17V9",
            }
            path {
                d: "M18 17v-3",
            }
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            path {
                d: "M8 17V5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartColumnIncreasing;
impl IconShape for LdChartColumnIncreasing {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 17V9",
            }
            path {
                d: "M18 17V5",
            }
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            path {
                d: "M8 17v-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartColumnStacked;
impl IconShape for LdChartColumnStacked {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 13H7",
            }
            path {
                d: "M19 9h-4",
            }
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            rect {
                height: "12",
                rx: "1",
                width: "4",
                x: "15",
                y: "5",
            }
            rect {
                height: "9",
                rx: "1",
                width: "4",
                x: "7",
                y: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartColumn;
impl IconShape for LdChartColumn {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            path {
                d: "M18 17V9",
            }
            path {
                d: "M13 17V5",
            }
            path {
                d: "M8 17v-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartGantt;
impl IconShape for LdChartGantt {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 6h8",
            }
            path {
                d: "M12 16h6",
            }
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            path {
                d: "M8 11h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartLine;
impl IconShape for LdChartLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            path {
                d: "m19 9-5 5-4-4-3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartNetwork;
impl IconShape for LdChartNetwork {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m13.11 7.664 1.78 2.672",
            }
            path {
                d: "m14.162 12.788-3.324 1.424",
            }
            path {
                d: "m20 4-6.06 1.515",
            }
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            circle {
                cx: "12",
                cy: "6",
                r: "2",
            }
            circle {
                cx: "16",
                cy: "12",
                r: "2",
            }
            circle {
                cx: "9",
                cy: "15",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartNoAxesColumnDecreasing;
impl IconShape for LdChartNoAxesColumnDecreasing {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 21V3",
            }
            path {
                d: "M12 21V9",
            }
            path {
                d: "M19 21v-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartNoAxesColumnIncreasing;
impl IconShape for LdChartNoAxesColumnIncreasing {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 21v-6",
            }
            path {
                d: "M12 21V9",
            }
            path {
                d: "M19 21V3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartNoAxesColumn;
impl IconShape for LdChartNoAxesColumn {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 21v-6",
            }
            path {
                d: "M12 21V3",
            }
            path {
                d: "M19 21V9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartNoAxesCombined;
impl IconShape for LdChartNoAxesCombined {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 16v5",
            }
            path {
                d: "M16 14v7",
            }
            path {
                d: "M20 10v11",
            }
            path {
                d: "m22 3-8.646 8.646a.5.5 0 0 1-.708 0L9.354 8.354a.5.5 0 0 0-.707 0L2 15",
            }
            path {
                d: "M4 18v3",
            }
            path {
                d: "M8 14v7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartNoAxesGantt;
impl IconShape for LdChartNoAxesGantt {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 5h12",
            }
            path {
                d: "M4 12h10",
            }
            path {
                d: "M12 19h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartPie;
impl IconShape for LdChartPie {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 12c.552 0 1.005-.449.95-.998a10 10 0 0 0-8.953-8.951c-.55-.055-.998.398-.998.95v8a1 1 0 0 0 1 1z",
            }
            path {
                d: "M21.21 15.89A10 10 0 1 1 8 2.83",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartScatter;
impl IconShape for LdChartScatter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "7.5",
                cy: "7.5",
                r: ".5",
            }
            circle {
                cx: "18.5",
                cy: "5.5",
                r: ".5",
            }
            circle {
                cx: "11.5",
                cy: "11.5",
                r: ".5",
            }
            circle {
                cx: "7.5",
                cy: "16.5",
                r: ".5",
            }
            circle {
                cx: "17.5",
                cy: "14.5",
                r: ".5",
            }
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChartSpline;
impl IconShape for LdChartSpline {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3v16a2 2 0 0 0 2 2h16",
            }
            path {
                d: "M7 16c.5-2 1.5-7 4-7 2 0 2 3 4 3 2.5 0 4.5-5 5-7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCheckCheck;
impl IconShape for LdCheckCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 6 7 17l-5-5",
            }
            path {
                d: "m22 10-7.5 7.5L13 16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCheckLine;
impl IconShape for LdCheckLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 4L9 15",
            }
            path {
                d: "M21 19L3 19",
            }
            path {
                d: "M9 15L4 10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCheck;
impl IconShape for LdCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 6 9 17l-5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChefHat;
impl IconShape for LdChefHat {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 21a1 1 0 0 0 1-1v-5.35c0-.457.316-.844.727-1.041a4 4 0 0 0-2.134-7.589 5 5 0 0 0-9.186 0 4 4 0 0 0-2.134 7.588c.411.198.727.585.727 1.041V20a1 1 0 0 0 1 1Z",
            }
            path {
                d: "M6 17h12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCherry;
impl IconShape for LdCherry {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 17a5 5 0 0 0 10 0c0-2.76-2.5-5-5-3-2.5-2-5 .24-5 3Z",
            }
            path {
                d: "M12 17a5 5 0 0 0 10 0c0-2.76-2.5-5-5-3-2.5-2-5 .24-5 3Z",
            }
            path {
                d: "M7 14c3.22-2.91 4.29-8.75 5-12 1.66 2.38 4.94 9 5 12",
            }
            path {
                d: "M22 9c-4.29 0-7.14-2.33-10-7 5.71 0 10 4.67 10 7Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChessBishop;
impl IconShape for LdChessBishop {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 20a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1z",
            }
            path {
                d: "M15 18c1.5-.615 3-2.461 3-4.923C18 8.769 14.5 4.462 12 2 9.5 4.462 6 8.77 6 13.077 6 15.539 7.5 17.385 9 18",
            }
            path {
                d: "m16 7-2.5 2.5",
            }
            path {
                d: "M9 2h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChessKing;
impl IconShape for LdChessKing {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 20a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1z",
            }
            path {
                d: "m6.7 18-1-1C4.35 15.682 3 14.09 3 12a5 5 0 0 1 4.95-5c1.584 0 2.7.455 4.05 1.818C13.35 7.455 14.466 7 16.05 7A5 5 0 0 1 21 12c0 2.082-1.359 3.673-2.7 5l-1 1",
            }
            path {
                d: "M10 4h4",
            }
            path {
                d: "M12 2v6.818",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChessKnight;
impl IconShape for LdChessKnight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 20a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1z",
            }
            path {
                d: "M16.5 18c1-2 2.5-5 2.5-9a7 7 0 0 0-7-7H6.635a1 1 0 0 0-.768 1.64L7 5l-2.32 5.802a2 2 0 0 0 .95 2.526l2.87 1.456",
            }
            path {
                d: "m15 5 1.425-1.425",
            }
            path {
                d: "m17 8 1.53-1.53",
            }
            path {
                d: "M9.713 12.185 7 18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChessPawn;
impl IconShape for LdChessPawn {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 20a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1z",
            }
            path {
                d: "m14.5 10 1.5 8",
            }
            path {
                d: "M7 10h10",
            }
            path {
                d: "m8 18 1.5-8",
            }
            circle {
                cx: "12",
                cy: "6",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChessQueen;
impl IconShape for LdChessQueen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 20a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1z",
            }
            path {
                d: "m12.474 5.943 1.567 5.34a1 1 0 0 0 1.75.328l2.616-3.402",
            }
            path {
                d: "m20 9-3 9",
            }
            path {
                d: "m5.594 8.209 2.615 3.403a1 1 0 0 0 1.75-.329l1.567-5.34",
            }
            path {
                d: "M7 18 4 9",
            }
            circle {
                cx: "12",
                cy: "4",
                r: "2",
            }
            circle {
                cx: "20",
                cy: "7",
                r: "2",
            }
            circle {
                cx: "4",
                cy: "7",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChessRook;
impl IconShape for LdChessRook {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 20a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1z",
            }
            path {
                d: "M10 2v2",
            }
            path {
                d: "M14 2v2",
            }
            path {
                d: "m17 18-1-9",
            }
            path {
                d: "M6 2v5a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V2",
            }
            path {
                d: "M6 4h12",
            }
            path {
                d: "m7 18 1-9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronDown;
impl IconShape for LdChevronDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m6 9 6 6 6-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronFirst;
impl IconShape for LdChevronFirst {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m17 18-6-6 6-6",
            }
            path {
                d: "M7 6v12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronLast;
impl IconShape for LdChevronLast {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m7 18 6-6-6-6",
            }
            path {
                d: "M17 6v12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronLeft;
impl IconShape for LdChevronLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 18-6-6 6-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronRight;
impl IconShape for LdChevronRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m9 18 6-6-6-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronUp;
impl IconShape for LdChevronUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m18 15-6-6-6 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronsDownUp;
impl IconShape for LdChevronsDownUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m7 20 5-5 5 5",
            }
            path {
                d: "m7 4 5 5 5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronsDown;
impl IconShape for LdChevronsDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m7 6 5 5 5-5",
            }
            path {
                d: "m7 13 5 5 5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronsLeftRightEllipsis;
impl IconShape for LdChevronsLeftRightEllipsis {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 12h.01",
            }
            path {
                d: "M16 12h.01",
            }
            path {
                d: "m17 7 5 5-5 5",
            }
            path {
                d: "m7 7-5 5 5 5",
            }
            path {
                d: "M8 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronsLeftRight;
impl IconShape for LdChevronsLeftRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m9 7-5 5 5 5",
            }
            path {
                d: "m15 7 5 5-5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronsLeft;
impl IconShape for LdChevronsLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m11 17-5-5 5-5",
            }
            path {
                d: "m18 17-5-5 5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronsRightLeft;
impl IconShape for LdChevronsRightLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m20 17-5-5 5-5",
            }
            path {
                d: "m4 17 5-5-5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronsRight;
impl IconShape for LdChevronsRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m6 17 5-5-5-5",
            }
            path {
                d: "m13 17 5-5-5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronsUpDown;
impl IconShape for LdChevronsUpDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m7 15 5 5 5-5",
            }
            path {
                d: "m7 9 5-5 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChevronsUp;
impl IconShape for LdChevronsUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m17 11-5-5-5 5",
            }
            path {
                d: "m17 18-5-5-5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChromium;
impl IconShape for LdChromium {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.88 21.94 15.46 14",
            }
            path {
                d: "M21.17 8H12",
            }
            path {
                d: "M3.95 6.06 8.54 14",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdChurch;
impl IconShape for LdChurch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 9h4",
            }
            path {
                d: "M12 7v5",
            }
            path {
                d: "M14 21v-3a2 2 0 0 0-4 0v3",
            }
            path {
                d: "m18 9 3.52 2.147a1 1 0 0 1 .48.854V19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-6.999a1 1 0 0 1 .48-.854L6 9",
            }
            path {
                d: "M6 21V7a1 1 0 0 1 .376-.782l5-3.999a1 1 0 0 1 1.249.001l5 4A1 1 0 0 1 18 7v14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCigaretteOff;
impl IconShape for LdCigaretteOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 12H3a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h13",
            }
            path {
                d: "M18 8c0-2.5-2-2.5-2-5",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M21 12a1 1 0 0 1 1 1v2a1 1 0 0 1-.5.866",
            }
            path {
                d: "M22 8c0-2.5-2-2.5-2-5",
            }
            path {
                d: "M7 12v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCigarette;
impl IconShape for LdCigarette {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 12H3a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h14",
            }
            path {
                d: "M18 8c0-2.5-2-2.5-2-5",
            }
            path {
                d: "M21 16a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1",
            }
            path {
                d: "M22 8c0-2.5-2-2.5-2-5",
            }
            path {
                d: "M7 12v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleAlert;
impl IconShape for LdCircleAlert {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "8",
                y2: "12",
            }
            line {
                x1: "12",
                x2: "12.01",
                y1: "16",
                y2: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleArrowDown;
impl IconShape for LdCircleArrowDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M12 8v8",
            }
            path {
                d: "m8 12 4 4 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleArrowLeft;
impl IconShape for LdCircleArrowLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m12 8-4 4 4 4",
            }
            path {
                d: "M16 12H8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleArrowOutDownLeft;
impl IconShape for LdCircleArrowOutDownLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 12a10 10 0 1 1 10 10",
            }
            path {
                d: "m2 22 10-10",
            }
            path {
                d: "M8 22H2v-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleArrowOutDownRight;
impl IconShape for LdCircleArrowOutDownRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 22a10 10 0 1 1 10-10",
            }
            path {
                d: "M22 22 12 12",
            }
            path {
                d: "M22 16v6h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleArrowOutUpLeft;
impl IconShape for LdCircleArrowOutUpLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 8V2h6",
            }
            path {
                d: "m2 2 10 10",
            }
            path {
                d: "M12 2A10 10 0 1 1 2 12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleArrowOutUpRight;
impl IconShape for LdCircleArrowOutUpRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 12A10 10 0 1 1 12 2",
            }
            path {
                d: "M22 2 12 12",
            }
            path {
                d: "M16 2h6v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleArrowRight;
impl IconShape for LdCircleArrowRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m12 16 4-4-4-4",
            }
            path {
                d: "M8 12h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleArrowUp;
impl IconShape for LdCircleArrowUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m16 12-4-4-4 4",
            }
            path {
                d: "M12 16V8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleCheckBig;
impl IconShape for LdCircleCheckBig {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21.801 10A10 10 0 1 1 17 3.335",
            }
            path {
                d: "m9 11 3 3L22 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleCheck;
impl IconShape for LdCircleCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m9 12 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleChevronDown;
impl IconShape for LdCircleChevronDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m16 10-4 4-4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleChevronLeft;
impl IconShape for LdCircleChevronLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m14 16-4-4 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleChevronRight;
impl IconShape for LdCircleChevronRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m10 8 4 4-4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleChevronUp;
impl IconShape for LdCircleChevronUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m8 14 4-4 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleDashed;
impl IconShape for LdCircleDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.1 2.182a10 10 0 0 1 3.8 0",
            }
            path {
                d: "M13.9 21.818a10 10 0 0 1-3.8 0",
            }
            path {
                d: "M17.609 3.721a10 10 0 0 1 2.69 2.7",
            }
            path {
                d: "M2.182 13.9a10 10 0 0 1 0-3.8",
            }
            path {
                d: "M20.279 17.609a10 10 0 0 1-2.7 2.69",
            }
            path {
                d: "M21.818 10.1a10 10 0 0 1 0 3.8",
            }
            path {
                d: "M3.721 6.391a10 10 0 0 1 2.7-2.69",
            }
            path {
                d: "M6.391 20.279a10 10 0 0 1-2.69-2.7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleDivide;
impl IconShape for LdCircleDivide {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "8",
                x2: "16",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "16",
                y2: "16",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "8",
                y2: "8",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleDollarSign;
impl IconShape for LdCircleDollarSign {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8",
            }
            path {
                d: "M12 18V6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleDotDashed;
impl IconShape for LdCircleDotDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.1 2.18a9.93 9.93 0 0 1 3.8 0",
            }
            path {
                d: "M17.6 3.71a9.95 9.95 0 0 1 2.69 2.7",
            }
            path {
                d: "M21.82 10.1a9.93 9.93 0 0 1 0 3.8",
            }
            path {
                d: "M20.29 17.6a9.95 9.95 0 0 1-2.7 2.69",
            }
            path {
                d: "M13.9 21.82a9.94 9.94 0 0 1-3.8 0",
            }
            path {
                d: "M6.4 20.29a9.95 9.95 0 0 1-2.69-2.7",
            }
            path {
                d: "M2.18 13.9a9.93 9.93 0 0 1 0-3.8",
            }
            path {
                d: "M3.71 6.4a9.95 9.95 0 0 1 2.7-2.69",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleDot;
impl IconShape for LdCircleDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleEllipsis;
impl IconShape for LdCircleEllipsis {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M17 12h.01",
            }
            path {
                d: "M12 12h.01",
            }
            path {
                d: "M7 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleEqual;
impl IconShape for LdCircleEqual {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 10h10",
            }
            path {
                d: "M7 14h10",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleFadingArrowUp;
impl IconShape for LdCircleFadingArrowUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2a10 10 0 0 1 7.38 16.75",
            }
            path {
                d: "m16 12-4-4-4 4",
            }
            path {
                d: "M12 16V8",
            }
            path {
                d: "M2.5 8.875a10 10 0 0 0-.5 3",
            }
            path {
                d: "M2.83 16a10 10 0 0 0 2.43 3.4",
            }
            path {
                d: "M4.636 5.235a10 10 0 0 1 .891-.857",
            }
            path {
                d: "M8.644 21.42a10 10 0 0 0 7.631-.38",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleFadingPlus;
impl IconShape for LdCircleFadingPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2a10 10 0 0 1 7.38 16.75",
            }
            path {
                d: "M12 8v8",
            }
            path {
                d: "M16 12H8",
            }
            path {
                d: "M2.5 8.875a10 10 0 0 0-.5 3",
            }
            path {
                d: "M2.83 16a10 10 0 0 0 2.43 3.4",
            }
            path {
                d: "M4.636 5.235a10 10 0 0 1 .891-.857",
            }
            path {
                d: "M8.644 21.42a10 10 0 0 0 7.631-.38",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleGauge;
impl IconShape for LdCircleGauge {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.6 2.7a10 10 0 1 0 5.7 5.7",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
            path {
                d: "M13.4 10.6 19 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleMinus;
impl IconShape for LdCircleMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M8 12h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleOff;
impl IconShape for LdCircleOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M8.35 2.69A10 10 0 0 1 21.3 15.65",
            }
            path {
                d: "M19.08 19.08A10 10 0 1 1 4.92 4.92",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleParkingOff;
impl IconShape for LdCircleParkingOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.656 7H13a3 3 0 0 1 2.984 3.307",
            }
            path {
                d: "M13 13H9",
            }
            path {
                d: "M19.071 19.071A1 1 0 0 1 4.93 4.93",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M8.357 2.687a10 10 0 0 1 12.956 12.956",
            }
            path {
                d: "M9 17V9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleParking;
impl IconShape for LdCircleParking {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M9 17V7h4a3 3 0 0 1 0 6H9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCirclePause;
impl IconShape for LdCirclePause {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            line {
                x1: "10",
                x2: "10",
                y1: "15",
                y2: "9",
            }
            line {
                x1: "14",
                x2: "14",
                y1: "15",
                y2: "9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCirclePercent;
impl IconShape for LdCirclePercent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m15 9-6 6",
            }
            path {
                d: "M9 9h.01",
            }
            path {
                d: "M15 15h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCirclePlay;
impl IconShape for LdCirclePlay {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 9.003a1 1 0 0 1 1.517-.859l4.997 2.997a1 1 0 0 1 0 1.718l-4.997 2.997A1 1 0 0 1 9 14.996z",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCirclePlus;
impl IconShape for LdCirclePlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M8 12h8",
            }
            path {
                d: "M12 8v8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCirclePoundSterling;
impl IconShape for LdCirclePoundSterling {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 16V9.5a1 1 0 0 1 5 0",
            }
            path {
                d: "M8 12h4",
            }
            path {
                d: "M8 16h7",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCirclePower;
impl IconShape for LdCirclePower {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 7v4",
            }
            path {
                d: "M7.998 9.003a5 5 0 1 0 8-.005",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleQuestionMark;
impl IconShape for LdCircleQuestionMark {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3",
            }
            path {
                d: "M12 17h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleSlash2;
impl IconShape for LdCircleSlash2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 2 2 22",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleSlash;
impl IconShape for LdCircleSlash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            line {
                x1: "9",
                x2: "15",
                y1: "15",
                y2: "9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleSmall;
impl IconShape for LdCircleSmall {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleStar;
impl IconShape for LdCircleStar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.051 7.616a1 1 0 0 1 1.909.024l.737 1.452a1 1 0 0 0 .737.535l1.634.256a1 1 0 0 1 .588 1.806l-1.172 1.168a1 1 0 0 0-.282.866l.259 1.613a1 1 0 0 1-1.541 1.134l-1.465-.75a1 1 0 0 0-.912 0l-1.465.75a1 1 0 0 1-1.539-1.133l.258-1.613a1 1 0 0 0-.282-.867l-1.156-1.152a1 1 0 0 1 .572-1.822l1.633-.256a1 1 0 0 0 .737-.535z",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleStop;
impl IconShape for LdCircleStop {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            rect {
                height: "6",
                rx: "1",
                width: "6",
                x: "9",
                y: "9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleUserRound;
impl IconShape for LdCircleUserRound {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 20a6 6 0 0 0-12 0",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "4",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleUser;
impl IconShape for LdCircleUser {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "3",
            }
            path {
                d: "M7 20.662V19a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v1.662",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircleX;
impl IconShape for LdCircleX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m15 9-6 6",
            }
            path {
                d: "m9 9 6 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircle;
impl IconShape for LdCircle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCircuitBoard;
impl IconShape for LdCircuitBoard {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M11 9h4a2 2 0 0 0 2-2V3",
            }
            circle {
                cx: "9",
                cy: "9",
                r: "2",
            }
            path {
                d: "M7 21v-4a2 2 0 0 1 2-2h4",
            }
            circle {
                cx: "15",
                cy: "15",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCitrus;
impl IconShape for LdCitrus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21.66 17.67a1.08 1.08 0 0 1-.04 1.6A12 12 0 0 1 4.73 2.38a1.1 1.1 0 0 1 1.61-.04z",
            }
            path {
                d: "M19.65 15.66A8 8 0 0 1 8.35 4.34",
            }
            path {
                d: "m14 10-5.5 5.5",
            }
            path {
                d: "M14 17.85V10H6.15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClapperboard;
impl IconShape for LdClapperboard {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20.2 6 3 11l-.9-2.4c-.3-1.1.3-2.2 1.3-2.5l13.5-4c1.1-.3 2.2.3 2.5 1.3Z",
            }
            path {
                d: "m6.2 5.3 3.1 3.9",
            }
            path {
                d: "m12.4 3.4 3.1 4",
            }
            path {
                d: "M3 11h18v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardCheck;
impl IconShape for LdClipboardCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                ry: "1",
                width: "8",
                x: "8",
                y: "2",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2",
            }
            path {
                d: "m9 14 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardClock;
impl IconShape for LdClipboardClock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 14v2.2l1.6 1",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v.832",
            }
            path {
                d: "M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h2",
            }
            circle {
                cx: "16",
                cy: "16",
                r: "6",
            }
            rect {
                height: "4",
                rx: "1",
                width: "8",
                x: "8",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardCopy;
impl IconShape for LdClipboardCopy {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                ry: "1",
                width: "8",
                x: "8",
                y: "2",
            }
            path {
                d: "M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-2",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v4",
            }
            path {
                d: "M21 14H11",
            }
            path {
                d: "m15 10-4 4 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardList;
impl IconShape for LdClipboardList {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                ry: "1",
                width: "8",
                x: "8",
                y: "2",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M12 11h4",
            }
            path {
                d: "M12 16h4",
            }
            path {
                d: "M8 11h.01",
            }
            path {
                d: "M8 16h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardMinus;
impl IconShape for LdClipboardMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                ry: "1",
                width: "8",
                x: "8",
                y: "2",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M9 14h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardPaste;
impl IconShape for LdClipboardPaste {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 14h10",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v1.344",
            }
            path {
                d: "m17 18 4-4-4-4",
            }
            path {
                d: "M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 1.793-1.113",
            }
            rect {
                height: "4",
                rx: "1",
                width: "8",
                x: "8",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardPenLine;
impl IconShape for LdClipboardPenLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                width: "8",
                x: "8",
                y: "2",
            }
            path {
                d: "M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-.5",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 1.73 1",
            }
            path {
                d: "M8 18h1",
            }
            path {
                d: "M21.378 12.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardPen;
impl IconShape for LdClipboardPen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                width: "8",
                x: "8",
                y: "2",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-5.5",
            }
            path {
                d: "M4 13.5V6a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M13.378 15.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardPlus;
impl IconShape for LdClipboardPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                ry: "1",
                width: "8",
                x: "8",
                y: "2",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M9 14h6",
            }
            path {
                d: "M12 17v-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardType;
impl IconShape for LdClipboardType {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                ry: "1",
                width: "8",
                x: "8",
                y: "2",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M9 12v-1h6v1",
            }
            path {
                d: "M11 17h2",
            }
            path {
                d: "M12 11v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboardX;
impl IconShape for LdClipboardX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                ry: "1",
                width: "8",
                x: "8",
                y: "2",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2",
            }
            path {
                d: "m15 11-6 6",
            }
            path {
                d: "m9 11 6 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClipboard;
impl IconShape for LdClipboard {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                ry: "1",
                width: "8",
                x: "8",
                y: "2",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock1;
impl IconShape for LdClock1 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l2-4",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock10;
impl IconShape for LdClock10 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l-4-2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock11;
impl IconShape for LdClock11 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l-2-4",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock12;
impl IconShape for LdClock12 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock2;
impl IconShape for LdClock2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l4-2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock3;
impl IconShape for LdClock3 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6h4",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock4;
impl IconShape for LdClock4 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l4 2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock5;
impl IconShape for LdClock5 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l2 4",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock6;
impl IconShape for LdClock6 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v10",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock7;
impl IconShape for LdClock7 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l-2 4",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock8;
impl IconShape for LdClock8 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l-4 2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock9;
impl IconShape for LdClock9 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6H8",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClockAlert;
impl IconShape for LdClockAlert {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l4 2",
            }
            path {
                d: "M20 12v5",
            }
            path {
                d: "M20 21h.01",
            }
            path {
                d: "M21.25 8.2A10 10 0 1 0 16 21.16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClockArrowDown;
impl IconShape for LdClockArrowDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l2 1",
            }
            path {
                d: "M12.337 21.994a10 10 0 1 1 9.588-8.767",
            }
            path {
                d: "m14 18 4 4 4-4",
            }
            path {
                d: "M18 14v8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClockArrowUp;
impl IconShape for LdClockArrowUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l1.56.78",
            }
            path {
                d: "M13.227 21.925a10 10 0 1 1 8.767-9.588",
            }
            path {
                d: "m14 18 4-4 4 4",
            }
            path {
                d: "M18 22v-8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClockCheck;
impl IconShape for LdClockCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l4 2",
            }
            path {
                d: "M22 12a10 10 0 1 0-11 9.95",
            }
            path {
                d: "m22 16-5.5 5.5L14 19",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClockFading;
impl IconShape for LdClockFading {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2a10 10 0 0 1 7.38 16.75",
            }
            path {
                d: "M12 6v6l4 2",
            }
            path {
                d: "M2.5 8.875a10 10 0 0 0-.5 3",
            }
            path {
                d: "M2.83 16a10 10 0 0 0 2.43 3.4",
            }
            path {
                d: "M4.636 5.235a10 10 0 0 1 .891-.857",
            }
            path {
                d: "M8.644 21.42a10 10 0 0 0 7.631-.38",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClockPlus;
impl IconShape for LdClockPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l3.644 1.822",
            }
            path {
                d: "M16 19h6",
            }
            path {
                d: "M19 16v6",
            }
            path {
                d: "M21.92 13.267a10 10 0 1 0-8.653 8.653",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClock;
impl IconShape for LdClock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v6l4 2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClosedCaption;
impl IconShape for LdClosedCaption {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 9.17a3 3 0 1 0 0 5.66",
            }
            path {
                d: "M17 9.17a3 3 0 1 0 0 5.66",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudAlert;
impl IconShape for LdCloudAlert {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 12v4",
            }
            path {
                d: "M12 20h.01",
            }
            path {
                d: "M17 18h.5a1 1 0 0 0 0-9h-1.79A7 7 0 1 0 7 17.708",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudCheck;
impl IconShape for LdCloudCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m17 15-5.5 5.5L9 18",
            }
            path {
                d: "M5 17.743A7 7 0 1 1 15.71 10h1.79a4.5 4.5 0 0 1 1.5 8.742",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudCog;
impl IconShape for LdCloudCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10.852 19.772-.383.924",
            }
            path {
                d: "m13.148 14.228.383-.923",
            }
            path {
                d: "M13.148 19.772a3 3 0 1 0-2.296-5.544l-.383-.923",
            }
            path {
                d: "m13.53 20.696-.382-.924a3 3 0 1 1-2.296-5.544",
            }
            path {
                d: "m14.772 15.852.923-.383",
            }
            path {
                d: "m14.772 18.148.923.383",
            }
            path {
                d: "M4.2 15.1a7 7 0 1 1 9.93-9.858A7 7 0 0 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.2",
            }
            path {
                d: "m9.228 15.852-.923-.383",
            }
            path {
                d: "m9.228 18.148-.923.383",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudDownload;
impl IconShape for LdCloudDownload {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13v8l-4-4",
            }
            path {
                d: "m12 21 4-4",
            }
            path {
                d: "M4.393 15.269A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.436 8.284",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudDrizzle;
impl IconShape for LdCloudDrizzle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242",
            }
            path {
                d: "M8 19v1",
            }
            path {
                d: "M8 14v1",
            }
            path {
                d: "M16 19v1",
            }
            path {
                d: "M16 14v1",
            }
            path {
                d: "M12 21v1",
            }
            path {
                d: "M12 16v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudFog;
impl IconShape for LdCloudFog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242",
            }
            path {
                d: "M16 17H7",
            }
            path {
                d: "M17 21H9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudHail;
impl IconShape for LdCloudHail {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242",
            }
            path {
                d: "M16 14v2",
            }
            path {
                d: "M8 14v2",
            }
            path {
                d: "M16 20h.01",
            }
            path {
                d: "M8 20h.01",
            }
            path {
                d: "M12 16v2",
            }
            path {
                d: "M12 22h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudLightning;
impl IconShape for LdCloudLightning {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 16.326A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 .5 8.973",
            }
            path {
                d: "m13 12-3 5h4l-3 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudMoonRain;
impl IconShape for LdCloudMoonRain {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 20v2",
            }
            path {
                d: "M18.376 14.512a6 6 0 0 0 3.461-4.127c.148-.625-.659-.97-1.248-.714a4 4 0 0 1-5.259-5.26c.255-.589-.09-1.395-.716-1.248a6 6 0 0 0-4.594 5.36",
            }
            path {
                d: "M3 20a5 5 0 1 1 8.9-4H13a3 3 0 0 1 2 5.24",
            }
            path {
                d: "M7 19v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudMoon;
impl IconShape for LdCloudMoon {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 16a3 3 0 0 1 0 6H7a5 5 0 1 1 4.9-6z",
            }
            path {
                d: "M18.376 14.512a6 6 0 0 0 3.461-4.127c.148-.625-.659-.97-1.248-.714a4 4 0 0 1-5.259-5.26c.255-.589-.09-1.395-.716-1.248a6 6 0 0 0-4.594 5.36",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudOff;
impl IconShape for LdCloudOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M5.782 5.782A7 7 0 0 0 9 19h8.5a4.5 4.5 0 0 0 1.307-.193",
            }
            path {
                d: "M21.532 16.5A4.5 4.5 0 0 0 17.5 10h-1.79A7.008 7.008 0 0 0 10 5.07",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudRainWind;
impl IconShape for LdCloudRainWind {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242",
            }
            path {
                d: "m9.2 22 3-7",
            }
            path {
                d: "m9 13-3 7",
            }
            path {
                d: "m17 13-3 7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudRain;
impl IconShape for LdCloudRain {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242",
            }
            path {
                d: "M16 14v6",
            }
            path {
                d: "M8 14v6",
            }
            path {
                d: "M12 16v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudSnow;
impl IconShape for LdCloudSnow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242",
            }
            path {
                d: "M8 15h.01",
            }
            path {
                d: "M8 19h.01",
            }
            path {
                d: "M12 17h.01",
            }
            path {
                d: "M12 21h.01",
            }
            path {
                d: "M16 15h.01",
            }
            path {
                d: "M16 19h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudSunRain;
impl IconShape for LdCloudSunRain {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v2",
            }
            path {
                d: "m4.93 4.93 1.41 1.41",
            }
            path {
                d: "M20 12h2",
            }
            path {
                d: "m19.07 4.93-1.41 1.41",
            }
            path {
                d: "M15.947 12.65a4 4 0 0 0-5.925-4.128",
            }
            path {
                d: "M3 20a5 5 0 1 1 8.9-4H13a3 3 0 0 1 2 5.24",
            }
            path {
                d: "M11 20v2",
            }
            path {
                d: "M7 19v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudSun;
impl IconShape for LdCloudSun {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v2",
            }
            path {
                d: "m4.93 4.93 1.41 1.41",
            }
            path {
                d: "M20 12h2",
            }
            path {
                d: "m19.07 4.93-1.41 1.41",
            }
            path {
                d: "M15.947 12.65a4 4 0 0 0-5.925-4.128",
            }
            path {
                d: "M13 22H7a5 5 0 1 1 4.9-6H13a3 3 0 0 1 0 6Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudUpload;
impl IconShape for LdCloudUpload {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13v8",
            }
            path {
                d: "M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242",
            }
            path {
                d: "m8 17 4-4 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloud;
impl IconShape for LdCloud {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCloudy;
impl IconShape for LdCloudy {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17.5 21H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z",
            }
            path {
                d: "M22 10a3 3 0 0 0-3-3h-2.207a5.502 5.502 0 0 0-10.702.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClover;
impl IconShape for LdClover {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16.17 7.83 2 22",
            }
            path {
                d: "M4.02 12a2.827 2.827 0 1 1 3.81-4.17A2.827 2.827 0 1 1 12 4.02a2.827 2.827 0 1 1 4.17 3.81A2.827 2.827 0 1 1 19.98 12a2.827 2.827 0 1 1-3.81 4.17A2.827 2.827 0 1 1 12 19.98a2.827 2.827 0 1 1-4.17-3.81A1 1 0 1 1 4 12",
            }
            path {
                d: "m7.83 7.83 8.34 8.34",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdClub;
impl IconShape for LdClub {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17.28 9.05a5.5 5.5 0 1 0-10.56 0A5.5 5.5 0 1 0 12 17.66a5.5 5.5 0 1 0 5.28-8.6Z",
            }
            path {
                d: "M12 17.66L12 22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCodeXml;
impl IconShape for LdCodeXml {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m18 16 4-4-4-4",
            }
            path {
                d: "m6 8-4 4 4 4",
            }
            path {
                d: "m14.5 4-5 16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCode;
impl IconShape for LdCode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 18 6-6-6-6",
            }
            path {
                d: "m8 6-6 6 6 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCodepen;
impl IconShape for LdCodepen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            polygon {
                points: "12 2 22 8.5 22 15.5 12 22 2 15.5 2 8.5 12 2",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "22",
                y2: "15.5",
            }
            polyline {
                points: "22 8.5 12 15.5 2 8.5",
            }
            polyline {
                points: "2 15.5 12 8.5 22 15.5",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "2",
                y2: "8.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCodesandbox;
impl IconShape for LdCodesandbox {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z",
            }
            polyline {
                points: "7.5 4.21 12 6.81 16.5 4.21",
            }
            polyline {
                points: "7.5 19.79 7.5 14.6 3 12",
            }
            polyline {
                points: "21 12 16.5 14.6 16.5 19.79",
            }
            polyline {
                points: "3.27 6.96 12 12.01 20.73 6.96",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "22.08",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCoffee;
impl IconShape for LdCoffee {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2v2",
            }
            path {
                d: "M14 2v2",
            }
            path {
                d: "M16 8a1 1 0 0 1 1 1v8a4 4 0 0 1-4 4H7a4 4 0 0 1-4-4V9a1 1 0 0 1 1-1h14a4 4 0 1 1 0 8h-1",
            }
            path {
                d: "M6 2v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCog;
impl IconShape for LdCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 10.27 7 3.34",
            }
            path {
                d: "m11 13.73-4 6.93",
            }
            path {
                d: "M12 22v-2",
            }
            path {
                d: "M12 2v2",
            }
            path {
                d: "M14 12h8",
            }
            path {
                d: "m17 20.66-1-1.73",
            }
            path {
                d: "m17 3.34-1 1.73",
            }
            path {
                d: "M2 12h2",
            }
            path {
                d: "m20.66 17-1.73-1",
            }
            path {
                d: "m20.66 7-1.73 1",
            }
            path {
                d: "m3.34 17 1.73-1",
            }
            path {
                d: "m3.34 7 1.73 1",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCoins;
impl IconShape for LdCoins {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "8",
                cy: "8",
                r: "6",
            }
            path {
                d: "M18.09 10.37A6 6 0 1 1 10.34 18",
            }
            path {
                d: "M7 6h1v4",
            }
            path {
                d: "m16.71 13.88.7.71-2.82 2.82",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdColumns2;
impl IconShape for LdColumns2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M12 3v18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdColumns3Cog;
impl IconShape for LdColumns3Cog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.5 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v5.5",
            }
            path {
                d: "m14.3 19.6 1-.4",
            }
            path {
                d: "M15 3v7.5",
            }
            path {
                d: "m15.2 16.9-.9-.3",
            }
            path {
                d: "m16.6 21.7.3-.9",
            }
            path {
                d: "m16.8 15.3-.4-1",
            }
            path {
                d: "m19.1 15.2.3-.9",
            }
            path {
                d: "m19.6 21.7-.4-1",
            }
            path {
                d: "m20.7 16.8 1-.4",
            }
            path {
                d: "m21.7 19.4-.9-.3",
            }
            path {
                d: "M9 3v18",
            }
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdColumns3;
impl IconShape for LdColumns3 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M9 3v18",
            }
            path {
                d: "M15 3v18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdColumns4;
impl IconShape for LdColumns4 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M7.5 3v18",
            }
            path {
                d: "M12 3v18",
            }
            path {
                d: "M16.5 3v18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCombine;
impl IconShape for LdCombine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 3a1 1 0 0 1 1 1v5a1 1 0 0 1-1 1",
            }
            path {
                d: "M19 3a1 1 0 0 1 1 1v5a1 1 0 0 1-1 1",
            }
            path {
                d: "m7 15 3 3",
            }
            path {
                d: "m7 21 3-3H5a2 2 0 0 1-2-2v-2",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "14",
                y: "14",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCommand;
impl IconShape for LdCommand {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 6v12a3 3 0 1 0 3-3H6a3 3 0 1 0 3 3V6a3 3 0 1 0-3 3h12a3 3 0 1 0-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCompass;
impl IconShape for LdCompass {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16.24 7.76-1.804 5.411a2 2 0 0 1-1.265 1.265L7.76 16.24l1.804-5.411a2 2 0 0 1 1.265-1.265z",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdComponent;
impl IconShape for LdComponent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.536 11.293a1 1 0 0 0 0 1.414l2.376 2.377a1 1 0 0 0 1.414 0l2.377-2.377a1 1 0 0 0 0-1.414l-2.377-2.377a1 1 0 0 0-1.414 0z",
            }
            path {
                d: "M2.297 11.293a1 1 0 0 0 0 1.414l2.377 2.377a1 1 0 0 0 1.414 0l2.377-2.377a1 1 0 0 0 0-1.414L6.088 8.916a1 1 0 0 0-1.414 0z",
            }
            path {
                d: "M8.916 17.912a1 1 0 0 0 0 1.415l2.377 2.376a1 1 0 0 0 1.414 0l2.377-2.376a1 1 0 0 0 0-1.415l-2.377-2.376a1 1 0 0 0-1.414 0z",
            }
            path {
                d: "M8.916 4.674a1 1 0 0 0 0 1.414l2.377 2.376a1 1 0 0 0 1.414 0l2.377-2.376a1 1 0 0 0 0-1.414l-2.377-2.377a1 1 0 0 0-1.414 0z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdComputer;
impl IconShape for LdComputer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "8",
                rx: "2",
                width: "14",
                x: "5",
                y: "2",
            }
            rect {
                height: "8",
                rx: "2",
                width: "20",
                x: "2",
                y: "14",
            }
            path {
                d: "M6 18h2",
            }
            path {
                d: "M12 18h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdConciergeBell;
impl IconShape for LdConciergeBell {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 20a1 1 0 0 1-1-1v-1a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1Z",
            }
            path {
                d: "M20 16a8 8 0 1 0-16 0",
            }
            path {
                d: "M12 4v4",
            }
            path {
                d: "M10 4h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCone;
impl IconShape for LdCone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m20.9 18.55-8-15.98a1 1 0 0 0-1.8 0l-8 15.98",
            }
            ellipse {
                cx: "12",
                cy: "19",
                rx: "9",
                ry: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdConstruction;
impl IconShape for LdConstruction {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "8",
                rx: "1",
                width: "20",
                x: "2",
                y: "6",
            }
            path {
                d: "M17 14v7",
            }
            path {
                d: "M7 14v7",
            }
            path {
                d: "M17 3v3",
            }
            path {
                d: "M7 3v3",
            }
            path {
                d: "M10 14 2.3 6.3",
            }
            path {
                d: "m14 6 7.7 7.7",
            }
            path {
                d: "m8 6 8 8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdContactRound;
impl IconShape for LdContactRound {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 2v2",
            }
            path {
                d: "M17.915 22a6 6 0 0 0-12 0",
            }
            path {
                d: "M8 2v2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdContact;
impl IconShape for LdContact {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 2v2",
            }
            path {
                d: "M7 22v-2a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M8 2v2",
            }
            circle {
                cx: "12",
                cy: "11",
                r: "3",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdContainer;
impl IconShape for LdContainer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 7.7c0-.6-.4-1.2-.8-1.5l-6.3-3.9a1.72 1.72 0 0 0-1.7 0l-10.3 6c-.5.2-.9.8-.9 1.4v6.6c0 .5.4 1.2.8 1.5l6.3 3.9a1.72 1.72 0 0 0 1.7 0l10.3-6c.5-.3.9-1 .9-1.5Z",
            }
            path {
                d: "M10 21.9V14L2.1 9.1",
            }
            path {
                d: "m10 14 11.9-6.9",
            }
            path {
                d: "M14 19.8v-8.1",
            }
            path {
                d: "M18 17.5V9.4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdContrast;
impl IconShape for LdContrast {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M12 18a6 6 0 0 0 0-12v12z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCookie;
impl IconShape for LdCookie {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2a10 10 0 1 0 10 10 4 4 0 0 1-5-5 4 4 0 0 1-5-5",
            }
            path {
                d: "M8.5 8.5v.01",
            }
            path {
                d: "M16 15.5v.01",
            }
            path {
                d: "M12 12v.01",
            }
            path {
                d: "M11 17v.01",
            }
            path {
                d: "M7 14v.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCookingPot;
impl IconShape for LdCookingPot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 12h20",
            }
            path {
                d: "M20 12v8a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-8",
            }
            path {
                d: "m4 8 16-4",
            }
            path {
                d: "m8.86 6.78-.45-1.81a2 2 0 0 1 1.45-2.43l1.94-.48a2 2 0 0 1 2.43 1.46l.45 1.8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCopyCheck;
impl IconShape for LdCopyCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12 15 2 2 4-4",
            }
            rect {
                height: "14",
                rx: "2",
                ry: "2",
                width: "14",
                x: "8",
                y: "8",
            }
            path {
                d: "M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCopyMinus;
impl IconShape for LdCopyMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "12",
                x2: "18",
                y1: "15",
                y2: "15",
            }
            rect {
                height: "14",
                rx: "2",
                ry: "2",
                width: "14",
                x: "8",
                y: "8",
            }
            path {
                d: "M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCopyPlus;
impl IconShape for LdCopyPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "15",
                x2: "15",
                y1: "12",
                y2: "18",
            }
            line {
                x1: "12",
                x2: "18",
                y1: "15",
                y2: "15",
            }
            rect {
                height: "14",
                rx: "2",
                ry: "2",
                width: "14",
                x: "8",
                y: "8",
            }
            path {
                d: "M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCopySlash;
impl IconShape for LdCopySlash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "12",
                x2: "18",
                y1: "18",
                y2: "12",
            }
            rect {
                height: "14",
                rx: "2",
                ry: "2",
                width: "14",
                x: "8",
                y: "8",
            }
            path {
                d: "M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCopyX;
impl IconShape for LdCopyX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "12",
                x2: "18",
                y1: "12",
                y2: "18",
            }
            line {
                x1: "12",
                x2: "18",
                y1: "18",
                y2: "12",
            }
            rect {
                height: "14",
                rx: "2",
                ry: "2",
                width: "14",
                x: "8",
                y: "8",
            }
            path {
                d: "M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCopy;
impl IconShape for LdCopy {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                ry: "2",
                width: "14",
                x: "8",
                y: "8",
            }
            path {
                d: "M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCopyleft;
impl IconShape for LdCopyleft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M9.17 14.83a4 4 0 1 0 0-5.66",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCopyright;
impl IconShape for LdCopyright {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M14.83 14.83a4 4 0 1 1 0-5.66",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCornerDownLeft;
impl IconShape for LdCornerDownLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 4v7a4 4 0 0 1-4 4H4",
            }
            path {
                d: "m9 10-5 5 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCornerDownRight;
impl IconShape for LdCornerDownRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 10 5 5-5 5",
            }
            path {
                d: "M4 4v7a4 4 0 0 0 4 4h12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCornerLeftDown;
impl IconShape for LdCornerLeftDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14 15-5 5-5-5",
            }
            path {
                d: "M20 4h-7a4 4 0 0 0-4 4v12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCornerLeftUp;
impl IconShape for LdCornerLeftUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 9 9 4 4 9",
            }
            path {
                d: "M20 20h-7a4 4 0 0 1-4-4V4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCornerRightDown;
impl IconShape for LdCornerRightDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 15 5 5 5-5",
            }
            path {
                d: "M4 4h7a4 4 0 0 1 4 4v12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCornerRightUp;
impl IconShape for LdCornerRightUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 9 5-5 5 5",
            }
            path {
                d: "M4 20h7a4 4 0 0 0 4-4V4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCornerUpLeft;
impl IconShape for LdCornerUpLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 20v-7a4 4 0 0 0-4-4H4",
            }
            path {
                d: "M9 14 4 9l5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCornerUpRight;
impl IconShape for LdCornerUpRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 14 5-5-5-5",
            }
            path {
                d: "M4 20v-7a4 4 0 0 1 4-4h12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCpu;
impl IconShape for LdCpu {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 20v2",
            }
            path {
                d: "M12 2v2",
            }
            path {
                d: "M17 20v2",
            }
            path {
                d: "M17 2v2",
            }
            path {
                d: "M2 12h2",
            }
            path {
                d: "M2 17h2",
            }
            path {
                d: "M2 7h2",
            }
            path {
                d: "M20 12h2",
            }
            path {
                d: "M20 17h2",
            }
            path {
                d: "M20 7h2",
            }
            path {
                d: "M7 20v2",
            }
            path {
                d: "M7 2v2",
            }
            rect {
                height: "16",
                rx: "2",
                width: "16",
                x: "4",
                y: "4",
            }
            rect {
                height: "8",
                rx: "1",
                width: "8",
                x: "8",
                y: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCreativeCommons;
impl IconShape for LdCreativeCommons {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M10 9.3a2.8 2.8 0 0 0-3.5 1 3.1 3.1 0 0 0 0 3.4 2.7 2.7 0 0 0 3.5 1",
            }
            path {
                d: "M17 9.3a2.8 2.8 0 0 0-3.5 1 3.1 3.1 0 0 0 0 3.4 2.7 2.7 0 0 0 3.5 1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCreditCard;
impl IconShape for LdCreditCard {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "5",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "10",
                y2: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCroissant;
impl IconShape for LdCroissant {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.2 18H4.774a1.5 1.5 0 0 1-1.352-.97 11 11 0 0 1 .132-6.487",
            }
            path {
                d: "M18 10.2V4.774a1.5 1.5 0 0 0-.97-1.352 11 11 0 0 0-6.486.132",
            }
            path {
                d: "M18 5a4 3 0 0 1 4 3 2 2 0 0 1-2 2 10 10 0 0 0-5.139 1.42",
            }
            path {
                d: "M5 18a3 4 0 0 0 3 4 2 2 0 0 0 2-2 10 10 0 0 1 1.42-5.14",
            }
            path {
                d: "M8.709 2.554a10 10 0 0 0-6.155 6.155 1.5 1.5 0 0 0 .676 1.626l9.807 5.42a2 2 0 0 0 2.718-2.718l-5.42-9.807a1.5 1.5 0 0 0-1.626-.676",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCrop;
impl IconShape for LdCrop {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 2v14a2 2 0 0 0 2 2h14",
            }
            path {
                d: "M18 22V8a2 2 0 0 0-2-2H2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCross;
impl IconShape for LdCross {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 9a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h4a1 1 0 0 1 1 1v4a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-4a1 1 0 0 1 1-1h4a2 2 0 0 0 2-2v-2a2 2 0 0 0-2-2h-4a1 1 0 0 1-1-1V4a2 2 0 0 0-2-2h-2a2 2 0 0 0-2 2v4a1 1 0 0 1-1 1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCrosshair;
impl IconShape for LdCrosshair {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            line {
                x1: "22",
                x2: "18",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "6",
                x2: "2",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "6",
                y2: "2",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "22",
                y2: "18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCrown;
impl IconShape for LdCrown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.562 3.266a.5.5 0 0 1 .876 0L15.39 8.87a1 1 0 0 0 1.516.294L21.183 5.5a.5.5 0 0 1 .798.519l-2.834 10.246a1 1 0 0 1-.956.734H5.81a1 1 0 0 1-.957-.734L2.02 6.02a.5.5 0 0 1 .798-.519l4.276 3.664a1 1 0 0 0 1.516-.294z",
            }
            path {
                d: "M5 21h14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCuboid;
impl IconShape for LdCuboid {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m21.12 6.4-6.05-4.06a2 2 0 0 0-2.17-.05L2.95 8.41a2 2 0 0 0-.95 1.7v5.82a2 2 0 0 0 .88 1.66l6.05 4.07a2 2 0 0 0 2.17.05l9.95-6.12a2 2 0 0 0 .95-1.7V8.06a2 2 0 0 0-.88-1.66Z",
            }
            path {
                d: "M10 22v-8L2.25 9.15",
            }
            path {
                d: "m10 14 11.77-6.87",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCupSoda;
impl IconShape for LdCupSoda {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m6 8 1.75 12.28a2 2 0 0 0 2 1.72h4.54a2 2 0 0 0 2-1.72L18 8",
            }
            path {
                d: "M5 8h14",
            }
            path {
                d: "M7 15a6.47 6.47 0 0 1 5 0 6.47 6.47 0 0 0 5 0",
            }
            path {
                d: "m12 8 1-6h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCurrency;
impl IconShape for LdCurrency {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "8",
            }
            line {
                x1: "3",
                x2: "6",
                y1: "3",
                y2: "6",
            }
            line {
                x1: "21",
                x2: "18",
                y1: "3",
                y2: "6",
            }
            line {
                x1: "3",
                x2: "6",
                y1: "21",
                y2: "18",
            }
            line {
                x1: "21",
                x2: "18",
                y1: "21",
                y2: "18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdCylinder;
impl IconShape for LdCylinder {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            ellipse {
                cx: "12",
                cy: "5",
                rx: "9",
                ry: "3",
            }
            path {
                d: "M3 5v14a9 3 0 0 0 18 0V5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDam;
impl IconShape for LdDam {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 11.31c1.17.56 1.54 1.69 3.5 1.69 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1",
            }
            path {
                d: "M11.75 18c.35.5 1.45 1 2.75 1 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1",
            }
            path {
                d: "M2 10h4",
            }
            path {
                d: "M2 14h4",
            }
            path {
                d: "M2 18h4",
            }
            path {
                d: "M2 6h4",
            }
            path {
                d: "M7 3a1 1 0 0 0-1 1v16a1 1 0 0 0 1 1h4a1 1 0 0 0 1-1L10 4a1 1 0 0 0-1-1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDatabaseBackup;
impl IconShape for LdDatabaseBackup {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            ellipse {
                cx: "12",
                cy: "5",
                rx: "9",
                ry: "3",
            }
            path {
                d: "M3 12a9 3 0 0 0 5 2.69",
            }
            path {
                d: "M21 9.3V5",
            }
            path {
                d: "M3 5v14a9 3 0 0 0 6.47 2.88",
            }
            path {
                d: "M12 12v4h4",
            }
            path {
                d: "M13 20a5 5 0 0 0 9-3 4.5 4.5 0 0 0-4.5-4.5c-1.33 0-2.54.54-3.41 1.41L12 16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDatabaseZap;
impl IconShape for LdDatabaseZap {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            ellipse {
                cx: "12",
                cy: "5",
                rx: "9",
                ry: "3",
            }
            path {
                d: "M3 5V19A9 3 0 0 0 15 21.84",
            }
            path {
                d: "M21 5V8",
            }
            path {
                d: "M21 12L18 17H22L19 22",
            }
            path {
                d: "M3 12A9 3 0 0 0 14.59 14.87",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDatabase;
impl IconShape for LdDatabase {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            ellipse {
                cx: "12",
                cy: "5",
                rx: "9",
                ry: "3",
            }
            path {
                d: "M3 5V19A9 3 0 0 0 21 19V5",
            }
            path {
                d: "M3 12A9 3 0 0 0 21 12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDecimalsArrowLeft;
impl IconShape for LdDecimalsArrowLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m13 21-3-3 3-3",
            }
            path {
                d: "M20 18H10",
            }
            path {
                d: "M3 11h.01",
            }
            rect {
                height: "8",
                rx: "2.5",
                width: "5",
                x: "6",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDecimalsArrowRight;
impl IconShape for LdDecimalsArrowRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 18h10",
            }
            path {
                d: "m17 21 3-3-3-3",
            }
            path {
                d: "M3 11h.01",
            }
            rect {
                height: "8",
                rx: "2.5",
                width: "5",
                x: "15",
                y: "3",
            }
            rect {
                height: "8",
                rx: "2.5",
                width: "5",
                x: "6",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDelete;
impl IconShape for LdDelete {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 5a2 2 0 0 0-1.344.519l-6.328 5.74a1 1 0 0 0 0 1.481l6.328 5.741A2 2 0 0 0 10 19h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2z",
            }
            path {
                d: "m12 9 6 6",
            }
            path {
                d: "m18 9-6 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDessert;
impl IconShape for LdDessert {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.162 3.167A10 10 0 0 0 2 13a2 2 0 0 0 4 0v-1a2 2 0 0 1 4 0v4a2 2 0 0 0 4 0v-4a2 2 0 0 1 4 0v1a2 2 0 0 0 4-.006 10 10 0 0 0-8.161-9.826",
            }
            path {
                d: "M20.804 14.869a9 9 0 0 1-17.608 0",
            }
            circle {
                cx: "12",
                cy: "4",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDiameter;
impl IconShape for LdDiameter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "19",
                cy: "19",
                r: "2",
            }
            circle {
                cx: "5",
                cy: "5",
                r: "2",
            }
            path {
                d: "M6.48 3.66a10 10 0 0 1 13.86 13.86",
            }
            path {
                d: "m6.41 6.41 11.18 11.18",
            }
            path {
                d: "M3.66 6.48a10 10 0 0 0 13.86 13.86",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDiamondMinus;
impl IconShape for LdDiamondMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0z",
            }
            path {
                d: "M8 12h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDiamondPercent;
impl IconShape for LdDiamondPercent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0Z",
            }
            path {
                d: "M9.2 9.2h.01",
            }
            path {
                d: "m14.5 9.5-5 5",
            }
            path {
                d: "M14.7 14.8h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDiamondPlus;
impl IconShape for LdDiamondPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 8v8",
            }
            path {
                d: "M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0z",
            }
            path {
                d: "M8 12h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDiamond;
impl IconShape for LdDiamond {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41l-7.59-7.59a2.41 2.41 0 0 0-3.41 0Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDice1;
impl IconShape for LdDice1 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M12 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDice2;
impl IconShape for LdDice2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M15 9h.01",
            }
            path {
                d: "M9 15h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDice3;
impl IconShape for LdDice3 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M16 8h.01",
            }
            path {
                d: "M12 12h.01",
            }
            path {
                d: "M8 16h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDice4;
impl IconShape for LdDice4 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M16 8h.01",
            }
            path {
                d: "M8 8h.01",
            }
            path {
                d: "M8 16h.01",
            }
            path {
                d: "M16 16h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDice5;
impl IconShape for LdDice5 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M16 8h.01",
            }
            path {
                d: "M8 8h.01",
            }
            path {
                d: "M8 16h.01",
            }
            path {
                d: "M16 16h.01",
            }
            path {
                d: "M12 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDice6;
impl IconShape for LdDice6 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M16 8h.01",
            }
            path {
                d: "M16 12h.01",
            }
            path {
                d: "M16 16h.01",
            }
            path {
                d: "M8 8h.01",
            }
            path {
                d: "M8 12h.01",
            }
            path {
                d: "M8 16h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDices;
impl IconShape for LdDices {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "12",
                rx: "2",
                ry: "2",
                width: "12",
                x: "2",
                y: "10",
            }
            path {
                d: "m17.92 14 3.5-3.5a2.24 2.24 0 0 0 0-3l-5-4.92a2.24 2.24 0 0 0-3 0L10 6",
            }
            path {
                d: "M6 18h.01",
            }
            path {
                d: "M10 14h.01",
            }
            path {
                d: "M15 6h.01",
            }
            path {
                d: "M18 9h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDiff;
impl IconShape for LdDiff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v14",
            }
            path {
                d: "M5 10h14",
            }
            path {
                d: "M5 21h14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDisc2;
impl IconShape for LdDisc2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "4",
            }
            path {
                d: "M12 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDisc3;
impl IconShape for LdDisc3 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M6 12c0-1.7.7-3.2 1.8-4.2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
            path {
                d: "M18 12c0 1.7-.7 3.2-1.8 4.2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDiscAlbum;
impl IconShape for LdDiscAlbum {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "5",
            }
            path {
                d: "M12 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDisc;
impl IconShape for LdDisc {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDivide;
impl IconShape for LdDivide {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "6",
                r: "1",
            }
            line {
                x1: "5",
                x2: "19",
                y1: "12",
                y2: "12",
            }
            circle {
                cx: "12",
                cy: "18",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDnaOff;
impl IconShape for LdDnaOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 2c-1.35 1.5-2.092 3-2.5 4.5L14 8",
            }
            path {
                d: "m17 6-2.891-2.891",
            }
            path {
                d: "M2 15c3.333-3 6.667-3 10-3",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "m20 9 .891.891",
            }
            path {
                d: "M22 9c-1.5 1.35-3 2.092-4.5 2.5l-1-1",
            }
            path {
                d: "M3.109 14.109 4 15",
            }
            path {
                d: "m6.5 12.5 1 1",
            }
            path {
                d: "m7 18 2.891 2.891",
            }
            path {
                d: "M9 22c1.35-1.5 2.092-3 2.5-4.5L10 16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDna;
impl IconShape for LdDna {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 16 1.5 1.5",
            }
            path {
                d: "m14 8-1.5-1.5",
            }
            path {
                d: "M15 2c-1.798 1.998-2.518 3.995-2.807 5.993",
            }
            path {
                d: "m16.5 10.5 1 1",
            }
            path {
                d: "m17 6-2.891-2.891",
            }
            path {
                d: "M2 15c6.667-6 13.333 0 20-6",
            }
            path {
                d: "m20 9 .891.891",
            }
            path {
                d: "M3.109 14.109 4 15",
            }
            path {
                d: "m6.5 12.5 1 1",
            }
            path {
                d: "m7 18 2.891 2.891",
            }
            path {
                d: "M9 22c1.798-1.998 2.518-3.995 2.807-5.993",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDock;
impl IconShape for LdDock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 8h20",
            }
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
            path {
                d: "M6 16h12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDog;
impl IconShape for LdDog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.25 16.25h1.5L12 17z",
            }
            path {
                d: "M16 14v.5",
            }
            path {
                d: "M4.42 11.247A13.152 13.152 0 0 0 4 14.556C4 18.728 7.582 21 12 21s8-2.272 8-6.444a11.702 11.702 0 0 0-.493-3.309",
            }
            path {
                d: "M8 14v.5",
            }
            path {
                d: "M8.5 8.5c-.384 1.05-1.083 2.028-2.344 2.5-1.931.722-3.576-.297-3.656-1-.113-.994 1.177-6.53 4-7 1.923-.321 3.651.845 3.651 2.235A7.497 7.497 0 0 1 14 5.277c0-1.39 1.844-2.598 3.767-2.277 2.823.47 4.113 6.006 4 7-.08.703-1.725 1.722-3.656 1-1.261-.472-1.855-1.45-2.239-2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDollarSign;
impl IconShape for LdDollarSign {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "12",
                x2: "12",
                y1: "2",
                y2: "22",
            }
            path {
                d: "M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDonut;
impl IconShape for LdDonut {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20.5 10a2.5 2.5 0 0 1-2.4-3H18a2.95 2.95 0 0 1-2.6-4.4 10 10 0 1 0 6.3 7.1c-.3.2-.8.3-1.2.3",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDoorClosedLocked;
impl IconShape for LdDoorClosedLocked {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 12h.01",
            }
            path {
                d: "M18 9V6a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v14",
            }
            path {
                d: "M2 20h8",
            }
            path {
                d: "M20 17v-2a2 2 0 1 0-4 0v2",
            }
            rect {
                height: "5",
                rx: "1",
                width: "8",
                x: "14",
                y: "17",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDoorClosed;
impl IconShape for LdDoorClosed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 12h.01",
            }
            path {
                d: "M18 20V6a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v14",
            }
            path {
                d: "M2 20h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDoorOpen;
impl IconShape for LdDoorOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 20H2",
            }
            path {
                d: "M11 4.562v16.157a1 1 0 0 0 1.242.97L19 20V5.562a2 2 0 0 0-1.515-1.94l-4-1A2 2 0 0 0 11 4.561z",
            }
            path {
                d: "M11 4H8a2 2 0 0 0-2 2v14",
            }
            path {
                d: "M14 12h.01",
            }
            path {
                d: "M22 20h-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDot;
impl IconShape for LdDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12.1",
                cy: "12.1",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDownload;
impl IconShape for LdDownload {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 15V3",
            }
            path {
                d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4",
            }
            path {
                d: "m7 10 5 5 5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDraftingCompass;
impl IconShape for LdDraftingCompass {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12.99 6.74 1.93 3.44",
            }
            path {
                d: "M19.136 12a10 10 0 0 1-14.271 0",
            }
            path {
                d: "m21 21-2.16-3.84",
            }
            path {
                d: "m3 21 8.02-14.26",
            }
            circle {
                cx: "12",
                cy: "5",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDrama;
impl IconShape for LdDrama {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 11h.01",
            }
            path {
                d: "M14 6h.01",
            }
            path {
                d: "M18 6h.01",
            }
            path {
                d: "M6.5 13.1h.01",
            }
            path {
                d: "M22 5c0 9-4 12-6 12s-6-3-6-12c0-2 2-3 6-3s6 1 6 3",
            }
            path {
                d: "M17.4 9.9c-.8.8-2 .8-2.8 0",
            }
            path {
                d: "M10.1 7.1C9 7.2 7.7 7.7 6 8.6c-3.5 2-4.7 3.9-3.7 5.6 4.5 7.8 9.5 8.4 11.2 7.4.9-.5 1.9-2.1 1.9-4.7",
            }
            path {
                d: "M9.1 16.5c.3-1.1 1.4-1.7 2.4-1.4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDribbble;
impl IconShape for LdDribbble {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M19.13 5.09C15.22 9.14 10 10.44 2.25 10.94",
            }
            path {
                d: "M21.75 12.84c-6.62-1.41-12.14 1-16.38 6.32",
            }
            path {
                d: "M8.56 2.75c4.37 6 6 9.42 8 17.72",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDrill;
impl IconShape for LdDrill {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 18a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1H5a3 3 0 0 1-3-3 1 1 0 0 1 1-1z",
            }
            path {
                d: "M13 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a1 1 0 0 1 1 1v6a1 1 0 0 1-1 1l-.81 3.242a1 1 0 0 1-.97.758H8",
            }
            path {
                d: "M14 4h3a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1h-3",
            }
            path {
                d: "M18 6h4",
            }
            path {
                d: "m5 10-2 8",
            }
            path {
                d: "m7 18 2-8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDrone;
impl IconShape for LdDrone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 10 7 7",
            }
            path {
                d: "m10 14-3 3",
            }
            path {
                d: "m14 10 3-3",
            }
            path {
                d: "m14 14 3 3",
            }
            path {
                d: "M14.205 4.139a4 4 0 1 1 5.439 5.863",
            }
            path {
                d: "M19.637 14a4 4 0 1 1-5.432 5.868",
            }
            path {
                d: "M4.367 10a4 4 0 1 1 5.438-5.862",
            }
            path {
                d: "M9.795 19.862a4 4 0 1 1-5.429-5.873",
            }
            rect {
                height: "8",
                rx: "1",
                width: "4",
                x: "10",
                y: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDropletOff;
impl IconShape for LdDropletOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18.715 13.186C18.29 11.858 17.384 10.607 16 9.5c-2-1.6-3.5-4-4-6.5a10.7 10.7 0 0 1-.884 2.586",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M8.795 8.797A11 11 0 0 1 8 9.5C6 11.1 5 13 5 15a7 7 0 0 0 13.222 3.208",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDroplet;
impl IconShape for LdDroplet {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 22a7 7 0 0 0 7-7c0-2-1-3.9-3-5.5s-3.5-4-4-6.5c-.5 2.5-2 4.9-4 6.5C6 11.1 5 13 5 15a7 7 0 0 0 7 7z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDroplets;
impl IconShape for LdDroplets {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 16.3c2.2 0 4-1.83 4-4.05 0-1.16-.57-2.26-1.71-3.19S7.29 6.75 7 5.3c-.29 1.45-1.14 2.84-2.29 3.76S3 11.1 3 12.25c0 2.22 1.8 4.05 4 4.05z",
            }
            path {
                d: "M12.56 6.6A10.97 10.97 0 0 0 14 3.02c.5 2.5 2 4.9 4 6.5s3 3.5 3 5.5a6.98 6.98 0 0 1-11.91 4.97",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDrum;
impl IconShape for LdDrum {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 2 8 8",
            }
            path {
                d: "m22 2-8 8",
            }
            ellipse {
                cx: "12",
                cy: "9",
                rx: "10",
                ry: "5",
            }
            path {
                d: "M7 13.4v7.9",
            }
            path {
                d: "M12 14v8",
            }
            path {
                d: "M17 13.4v7.9",
            }
            path {
                d: "M2 9v8a10 5 0 0 0 20 0V9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDrumstick;
impl IconShape for LdDrumstick {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.4 15.63a7.875 6 135 1 1 6.23-6.23 4.5 3.43 135 0 0-6.23 6.23",
            }
            path {
                d: "m8.29 12.71-2.6 2.6a2.5 2.5 0 1 0-1.65 4.65A2.5 2.5 0 1 0 8.7 18.3l2.59-2.59",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdDumbbell;
impl IconShape for LdDumbbell {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17.596 12.768a2 2 0 1 0 2.829-2.829l-1.768-1.767a2 2 0 0 0 2.828-2.829l-2.828-2.828a2 2 0 0 0-2.829 2.828l-1.767-1.768a2 2 0 1 0-2.829 2.829z",
            }
            path {
                d: "m2.5 21.5 1.4-1.4",
            }
            path {
                d: "m20.1 3.9 1.4-1.4",
            }
            path {
                d: "M5.343 21.485a2 2 0 1 0 2.829-2.828l1.767 1.768a2 2 0 1 0 2.829-2.829l-6.364-6.364a2 2 0 1 0-2.829 2.829l1.768 1.767a2 2 0 0 0-2.828 2.829z",
            }
            path {
                d: "m9.6 14.4 4.8-4.8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEarOff;
impl IconShape for LdEarOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 18.5a3.5 3.5 0 1 0 7 0c0-1.57.92-2.52 2.04-3.46",
            }
            path {
                d: "M6 8.5c0-.75.13-1.47.36-2.14",
            }
            path {
                d: "M8.8 3.15A6.5 6.5 0 0 1 19 8.5c0 1.63-.44 2.81-1.09 3.76",
            }
            path {
                d: "M12.5 6A2.5 2.5 0 0 1 15 8.5M10 13a2 2 0 0 0 1.82-1.18",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEar;
impl IconShape for LdEar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 8.5a6.5 6.5 0 1 1 13 0c0 6-6 6-6 10a3.5 3.5 0 1 1-7 0",
            }
            path {
                d: "M15 8.5a2.5 2.5 0 0 0-5 0v1a2 2 0 1 1 0 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEarthLock;
impl IconShape for LdEarthLock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 3.34V5a3 3 0 0 0 3 3",
            }
            path {
                d: "M11 21.95V18a2 2 0 0 0-2-2 2 2 0 0 1-2-2v-1a2 2 0 0 0-2-2H2.05",
            }
            path {
                d: "M21.54 15H17a2 2 0 0 0-2 2v4.54",
            }
            path {
                d: "M12 2a10 10 0 1 0 9.54 13",
            }
            path {
                d: "M20 6V4a2 2 0 1 0-4 0v2",
            }
            rect {
                height: "5",
                rx: "1",
                width: "8",
                x: "14",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEarth;
impl IconShape for LdEarth {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21.54 15H17a2 2 0 0 0-2 2v4.54",
            }
            path {
                d: "M7 3.34V5a3 3 0 0 0 3 3a2 2 0 0 1 2 2c0 1.1.9 2 2 2a2 2 0 0 0 2-2c0-1.1.9-2 2-2h3.17",
            }
            path {
                d: "M11 21.95V18a2 2 0 0 0-2-2a2 2 0 0 1-2-2v-1a2 2 0 0 0-2-2H2.05",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEclipse;
impl IconShape for LdEclipse {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M12 2a7 7 0 1 0 10 10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEggFried;
impl IconShape for LdEggFried {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "11.5",
                cy: "12.5",
                r: "3.5",
            }
            path {
                d: "M3 8c0-3.5 2.5-6 6.5-6 5 0 4.83 3 7.5 5s5 2 5 6c0 4.5-2.5 6.5-7 6.5-2.5 0-2.5 2.5-6 2.5s-7-2-7-5.5c0-3 1.5-3 1.5-5C3.5 10 3 9 3 8Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEggOff;
impl IconShape for LdEggOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M20 14.347V14c0-6-4-12-8-12-1.078 0-2.157.436-3.157 1.19",
            }
            path {
                d: "M6.206 6.21C4.871 8.4 4 11.2 4 14a8 8 0 0 0 14.568 4.568",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEgg;
impl IconShape for LdEgg {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2C8 2 4 8 4 14a8 8 0 0 0 16 0c0-6-4-12-8-12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEllipsisVertical;
impl IconShape for LdEllipsisVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "1",
            }
            circle {
                cx: "12",
                cy: "5",
                r: "1",
            }
            circle {
                cx: "12",
                cy: "19",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEllipsis;
impl IconShape for LdEllipsis {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "1",
            }
            circle {
                cx: "19",
                cy: "12",
                r: "1",
            }
            circle {
                cx: "5",
                cy: "12",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEqualApproximately;
impl IconShape for LdEqualApproximately {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 15a6.5 6.5 0 0 1 7 0 6.5 6.5 0 0 0 7 0",
            }
            path {
                d: "M5 9a6.5 6.5 0 0 1 7 0 6.5 6.5 0 0 0 7 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEqualNot;
impl IconShape for LdEqualNot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "5",
                x2: "19",
                y1: "9",
                y2: "9",
            }
            line {
                x1: "5",
                x2: "19",
                y1: "15",
                y2: "15",
            }
            line {
                x1: "19",
                x2: "5",
                y1: "5",
                y2: "19",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEqual;
impl IconShape for LdEqual {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "5",
                x2: "19",
                y1: "9",
                y2: "9",
            }
            line {
                x1: "5",
                x2: "19",
                y1: "15",
                y2: "15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEraser;
impl IconShape for LdEraser {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 21H8a2 2 0 0 1-1.42-.587l-3.994-3.999a2 2 0 0 1 0-2.828l10-10a2 2 0 0 1 2.829 0l5.999 6a2 2 0 0 1 0 2.828L12.834 21",
            }
            path {
                d: "m5.082 11.09 8.828 8.828",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEthernetPort;
impl IconShape for LdEthernetPort {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 20 3-3h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h2l3 3z",
            }
            path {
                d: "M6 8v1",
            }
            path {
                d: "M10 8v1",
            }
            path {
                d: "M14 8v1",
            }
            path {
                d: "M18 8v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEuro;
impl IconShape for LdEuro {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 10h12",
            }
            path {
                d: "M4 14h9",
            }
            path {
                d: "M19 6a7.7 7.7 0 0 0-5.2-2A7.9 7.9 0 0 0 6 12c0 4.4 3.5 8 7.8 8 2 0 3.8-.8 5.2-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEvCharger;
impl IconShape for LdEvCharger {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 13h2a2 2 0 0 1 2 2v2a2 2 0 0 0 4 0v-6.998a2 2 0 0 0-.59-1.42L18 5",
            }
            path {
                d: "M14 21V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v16",
            }
            path {
                d: "M2 21h13",
            }
            path {
                d: "M3 7h11",
            }
            path {
                d: "m9 11-2 3h3l-2 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdExpand;
impl IconShape for LdExpand {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 15 6 6",
            }
            path {
                d: "m15 9 6-6",
            }
            path {
                d: "M21 16v5h-5",
            }
            path {
                d: "M21 8V3h-5",
            }
            path {
                d: "M3 16v5h5",
            }
            path {
                d: "m3 21 6-6",
            }
            path {
                d: "M3 8V3h5",
            }
            path {
                d: "M9 9 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdExternalLink;
impl IconShape for LdExternalLink {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 3h6v6",
            }
            path {
                d: "M10 14 21 3",
            }
            path {
                d: "M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEyeClosed;
impl IconShape for LdEyeClosed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 18-.722-3.25",
            }
            path {
                d: "M2 8a10.645 10.645 0 0 0 20 0",
            }
            path {
                d: "m20 15-1.726-2.05",
            }
            path {
                d: "m4 15 1.726-2.05",
            }
            path {
                d: "m9 18 .722-3.25",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEyeOff;
impl IconShape for LdEyeOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.733 5.076a10.744 10.744 0 0 1 11.205 6.575 1 1 0 0 1 0 .696 10.747 10.747 0 0 1-1.444 2.49",
            }
            path {
                d: "M14.084 14.158a3 3 0 0 1-4.242-4.242",
            }
            path {
                d: "M17.479 17.499a10.75 10.75 0 0 1-15.417-5.151 1 1 0 0 1 0-.696 10.75 10.75 0 0 1 4.446-5.143",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdEye;
impl IconShape for LdEye {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.062 12.348a1 1 0 0 1 0-.696 10.75 10.75 0 0 1 19.876 0 1 1 0 0 1 0 .696 10.75 10.75 0 0 1-19.876 0",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFacebook;
impl IconShape for LdFacebook {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 2h-3a5 5 0 0 0-5 5v3H7v4h3v8h4v-8h3l1-4h-4V7a1 1 0 0 1 1-1h3z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFactory;
impl IconShape for LdFactory {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 16h.01",
            }
            path {
                d: "M16 16h.01",
            }
            path {
                d: "M3 19a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V8.5a.5.5 0 0 0-.769-.422l-4.462 2.844A.5.5 0 0 1 15 10.5v-2a.5.5 0 0 0-.769-.422L9.77 10.922A.5.5 0 0 1 9 10.5V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2z",
            }
            path {
                d: "M8 16h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFan;
impl IconShape for LdFan {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.827 16.379a6.082 6.082 0 0 1-8.618-7.002l5.412 1.45a6.082 6.082 0 0 1 7.002-8.618l-1.45 5.412a6.082 6.082 0 0 1 8.618 7.002l-5.412-1.45a6.082 6.082 0 0 1-7.002 8.618l1.45-5.412Z",
            }
            path {
                d: "M12 12v.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFastForward;
impl IconShape for LdFastForward {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6a2 2 0 0 1 3.414-1.414l6 6a2 2 0 0 1 0 2.828l-6 6A2 2 0 0 1 12 18z",
            }
            path {
                d: "M2 6a2 2 0 0 1 3.414-1.414l6 6a2 2 0 0 1 0 2.828l-6 6A2 2 0 0 1 2 18z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFeather;
impl IconShape for LdFeather {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.67 19a2 2 0 0 0 1.416-.588l6.154-6.172a6 6 0 0 0-8.49-8.49L5.586 9.914A2 2 0 0 0 5 11.328V18a1 1 0 0 0 1 1z",
            }
            path {
                d: "M16 8 2 22",
            }
            path {
                d: "M17.5 15H9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFence;
impl IconShape for LdFence {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 3 2 5v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z",
            }
            path {
                d: "M6 8h4",
            }
            path {
                d: "M6 18h4",
            }
            path {
                d: "m12 3-2 2v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z",
            }
            path {
                d: "M14 8h4",
            }
            path {
                d: "M14 18h4",
            }
            path {
                d: "m20 3-2 2v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFerrisWheel;
impl IconShape for LdFerrisWheel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
            path {
                d: "M12 2v4",
            }
            path {
                d: "m6.8 15-3.5 2",
            }
            path {
                d: "m20.7 7-3.5 2",
            }
            path {
                d: "M6.8 9 3.3 7",
            }
            path {
                d: "m20.7 17-3.5-2",
            }
            path {
                d: "m9 22 3-8 3 8",
            }
            path {
                d: "M8 22h8",
            }
            path {
                d: "M18 18.7a9 9 0 1 0-12 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFigma;
impl IconShape for LdFigma {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 5.5A3.5 3.5 0 0 1 8.5 2H12v7H8.5A3.5 3.5 0 0 1 5 5.5z",
            }
            path {
                d: "M12 2h3.5a3.5 3.5 0 1 1 0 7H12V2z",
            }
            path {
                d: "M12 12.5a3.5 3.5 0 1 1 7 0 3.5 3.5 0 1 1-7 0z",
            }
            path {
                d: "M5 19.5A3.5 3.5 0 0 1 8.5 16H12v3.5a3.5 3.5 0 1 1-7 0z",
            }
            path {
                d: "M5 12.5A3.5 3.5 0 0 1 8.5 9H12v7H8.5A3.5 3.5 0 0 1 5 12.5z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileArchive;
impl IconShape for LdFileArchive {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.659 22H18a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v11.5",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M8 12v-1",
            }
            path {
                d: "M8 18v-2",
            }
            path {
                d: "M8 7V6",
            }
            circle {
                cx: "8",
                cy: "20",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileAxis3d;
impl IconShape for LdFileAxis3d {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m8 18 4-4",
            }
            path {
                d: "M8 10v8h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileBadge;
impl IconShape for LdFileBadge {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 22h5a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v3.3",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m7.69 16.479 1.29 4.88a.5.5 0 0 1-.698.591l-1.843-.849a1 1 0 0 0-.879.001l-1.846.85a.5.5 0 0 1-.692-.593l1.29-4.88",
            }
            circle {
                cx: "6",
                cy: "14",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileBox;
impl IconShape for LdFileBox {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14.5 22H18a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v3.8",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M11.7 14.2 7 17l-4.7-2.8",
            }
            path {
                d: "M3 13.1a2 2 0 0 0-.999 1.76v3.24a2 2 0 0 0 .969 1.78L6 21.7a2 2 0 0 0 2.03.01L11 19.9a2 2 0 0 0 1-1.76V14.9a2 2 0 0 0-.97-1.78L8 11.3a2 2 0 0 0-2.03-.01z",
            }
            path {
                d: "M7 17v5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileBracesCorner;
impl IconShape for LdFileBracesCorner {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 22h4a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v6",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M5 14a1 1 0 0 0-1 1v2a1 1 0 0 1-1 1 1 1 0 0 1 1 1v2a1 1 0 0 0 1 1",
            }
            path {
                d: "M9 22a1 1 0 0 0 1-1v-2a1 1 0 0 1 1-1 1 1 0 0 1-1-1v-2a1 1 0 0 0-1-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileBraces;
impl IconShape for LdFileBraces {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M10 12a1 1 0 0 0-1 1v1a1 1 0 0 1-1 1 1 1 0 0 1 1 1v1a1 1 0 0 0 1 1",
            }
            path {
                d: "M14 18a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1 1 1 0 0 1-1-1v-1a1 1 0 0 0-1-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileChartColumnIncreasing;
impl IconShape for LdFileChartColumnIncreasing {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M8 18v-2",
            }
            path {
                d: "M12 18v-4",
            }
            path {
                d: "M16 18v-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileChartColumn;
impl IconShape for LdFileChartColumn {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M8 18v-1",
            }
            path {
                d: "M12 18v-6",
            }
            path {
                d: "M16 18v-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileChartLine;
impl IconShape for LdFileChartLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m16 13-3.5 3.5-2-2L8 17",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileChartPie;
impl IconShape for LdFileChartPie {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.941 22H18a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.704l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v3.512",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M4.017 11.512a6 6 0 1 0 8.466 8.475",
            }
            path {
                d: "M9 16a1 1 0 0 1-1-1v-4c0-.552.45-1.008.995-.917a6 6 0 0 1 4.922 4.922c.091.544-.365.995-.917.995z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileCheckCorner;
impl IconShape for LdFileCheckCorner {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.5 22H6a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v6",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m14 20 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileCheck;
impl IconShape for LdFileCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m9 15 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileClock;
impl IconShape for LdFileClock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 22h2a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v2.85",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M8 14v2.2l1.6 1",
            }
            circle {
                cx: "8",
                cy: "16",
                r: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileCodeCorner;
impl IconShape for LdFileCodeCorner {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 12.15V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2h-3.35",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m5 16-3 3 3 3",
            }
            path {
                d: "m9 22 3-3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileCode;
impl IconShape for LdFileCode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M10 12.5 8 15l2 2.5",
            }
            path {
                d: "m14 12.5 2 2.5-2 2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileCog;
impl IconShape for LdFileCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.85 22H18a2 2 0 0 0 2-2V8a2 2 0 0 0-.586-1.414l-4-4A2 2 0 0 0 14 2H6a2 2 0 0 0-2 2v6.6",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m3.305 19.53.923-.382",
            }
            path {
                d: "m4.228 16.852-.924-.383",
            }
            path {
                d: "m5.852 15.228-.383-.923",
            }
            path {
                d: "m5.852 20.772-.383.924",
            }
            path {
                d: "m8.148 15.228.383-.923",
            }
            path {
                d: "m8.53 21.696-.382-.924",
            }
            path {
                d: "m9.773 16.852.922-.383",
            }
            path {
                d: "m9.773 19.148.922.383",
            }
            circle {
                cx: "7",
                cy: "18",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileDiff;
impl IconShape for LdFileDiff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M9 10h6",
            }
            path {
                d: "M12 13V7",
            }
            path {
                d: "M9 17h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileDigit;
impl IconShape for LdFileDigit {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 12V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M10 16h2v6",
            }
            path {
                d: "M10 22h4",
            }
            rect {
                height: "6",
                rx: "2",
                width: "4",
                x: "2",
                y: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileDown;
impl IconShape for LdFileDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M12 18v-6",
            }
            path {
                d: "m9 15 3 3 3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileExclamationPoint;
impl IconShape for LdFileExclamationPoint {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M12 9v4",
            }
            path {
                d: "M12 17h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileHeadphone;
impl IconShape for LdFileHeadphone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 6.835V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2h-.343",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M2 19a2 2 0 0 1 4 0v1a2 2 0 0 1-4 0v-4a6 6 0 0 1 12 0v4a2 2 0 0 1-4 0v-1a2 2 0 0 1 4 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileHeart;
impl IconShape for LdFileHeart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 22h5a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v7",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M3.62 18.8A2.25 2.25 0 1 1 7 15.836a2.25 2.25 0 1 1 3.38 2.966l-2.626 2.856a1 1 0 0 1-1.507 0z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileImage;
impl IconShape for LdFileImage {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            circle {
                cx: "10",
                cy: "12",
                r: "2",
            }
            path {
                d: "m20 17-1.296-1.296a2.41 2.41 0 0 0-3.408 0L9 22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileInput;
impl IconShape for LdFileInput {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 11V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-1",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M2 15h10",
            }
            path {
                d: "m9 18 3-3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileKey;
impl IconShape for LdFileKey {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.65 22H18a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v10.1",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m10 15 1 1",
            }
            path {
                d: "m11 14-4.586 4.586",
            }
            circle {
                cx: "5",
                cy: "20",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileLock;
impl IconShape for LdFileLock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 9.8V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2h-3",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M9 17v-2a2 2 0 0 0-4 0v2",
            }
            rect {
                height: "5",
                rx: "1",
                width: "8",
                x: "3",
                y: "17",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileMinusCorner;
impl IconShape for LdFileMinusCorner {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 14V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M14 18h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileMinus;
impl IconShape for LdFileMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M9 15h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileMusic;
impl IconShape for LdFileMusic {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.65 22H18a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v10.35",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M8 20v-7l3 1.474",
            }
            circle {
                cx: "6",
                cy: "20",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileOutput;
impl IconShape for LdFileOutput {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4.226 20.925A2 2 0 0 0 6 22h12a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v3.127",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m5 11-3 3",
            }
            path {
                d: "m5 17-3-3h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFilePenLine;
impl IconShape for LdFilePenLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m18.226 5.226-2.52-2.52A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-.351",
            }
            path {
                d: "M21.378 12.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z",
            }
            path {
                d: "M8 18h1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFilePen;
impl IconShape for LdFilePen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.659 22H18a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v9.34",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M10.378 12.622a1 1 0 0 1 3 3.003L8.36 20.637a2 2 0 0 1-.854.506l-2.867.837a.5.5 0 0 1-.62-.62l.836-2.869a2 2 0 0 1 .506-.853z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFilePlay;
impl IconShape for LdFilePlay {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M15.033 13.44a.647.647 0 0 1 0 1.12l-4.065 2.352a.645.645 0 0 1-.968-.56v-4.704a.645.645 0 0 1 .967-.56z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFilePlusCorner;
impl IconShape for LdFilePlusCorner {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.35 22H6a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v5.35",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M14 19h6",
            }
            path {
                d: "M17 16v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFilePlus;
impl IconShape for LdFilePlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M9 15h6",
            }
            path {
                d: "M12 18v-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileQuestionMark;
impl IconShape for LdFileQuestionMark {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M12 17h.01",
            }
            path {
                d: "M9.1 9a3 3 0 0 1 5.82 1c0 2-3 3-3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileScan;
impl IconShape for LdFileScan {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 10V8a2.4 2.4 0 0 0-.706-1.704l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h4.35",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M16 14a2 2 0 0 0-2 2",
            }
            path {
                d: "M16 22a2 2 0 0 1-2-2",
            }
            path {
                d: "M20 14a2 2 0 0 1 2 2",
            }
            path {
                d: "M20 22a2 2 0 0 0 2-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileSearchCorner;
impl IconShape for LdFileSearchCorner {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.1 22H6a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.589 3.588A2.4 2.4 0 0 1 20 8v3.25",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m21 22-2.88-2.88",
            }
            circle {
                cx: "16",
                cy: "17",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileSearch;
impl IconShape for LdFileSearch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            circle {
                cx: "11.5",
                cy: "14.5",
                r: "2.5",
            }
            path {
                d: "M13.3 16.3 15 18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileSignal;
impl IconShape for LdFileSignal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M8 15h.01",
            }
            path {
                d: "M11.5 13.5a2.5 2.5 0 0 1 0 3",
            }
            path {
                d: "M15 12a5 5 0 0 1 0 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileSliders;
impl IconShape for LdFileSliders {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M8 12h8",
            }
            path {
                d: "M10 11v2",
            }
            path {
                d: "M8 17h8",
            }
            path {
                d: "M14 16v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileSpreadsheet;
impl IconShape for LdFileSpreadsheet {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M8 13h2",
            }
            path {
                d: "M14 13h2",
            }
            path {
                d: "M8 17h2",
            }
            path {
                d: "M14 17h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileStack;
impl IconShape for LdFileStack {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 21a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1v-8a1 1 0 0 1 1-1",
            }
            path {
                d: "M16 16a1 1 0 0 1-1 1H9a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1",
            }
            path {
                d: "M21 6a2 2 0 0 0-.586-1.414l-2-2A2 2 0 0 0 17 2h-3a1 1 0 0 0-1 1v8a1 1 0 0 0 1 1h6a1 1 0 0 0 1-1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileSymlink;
impl IconShape for LdFileSymlink {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 11V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h7",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m10 18 3-3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileTerminal;
impl IconShape for LdFileTerminal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m8 16 2-2-2-2",
            }
            path {
                d: "M12 18h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileText;
impl IconShape for LdFileText {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M10 9H8",
            }
            path {
                d: "M16 13H8",
            }
            path {
                d: "M16 17H8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileTypeCorner;
impl IconShape for LdFileTypeCorner {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 22h6a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v6",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M3 16v-1.5a.5.5 0 0 1 .5-.5h7a.5.5 0 0 1 .5.5V16",
            }
            path {
                d: "M6 22h2",
            }
            path {
                d: "M7 14v8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileType;
impl IconShape for LdFileType {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M11 18h2",
            }
            path {
                d: "M12 12v6",
            }
            path {
                d: "M9 13v-.5a.5.5 0 0 1 .5-.5h5a.5.5 0 0 1 .5.5v.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileUp;
impl IconShape for LdFileUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M12 12v6",
            }
            path {
                d: "m15 15-3-3-3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileUser;
impl IconShape for LdFileUser {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M16 22a4 4 0 0 0-8 0",
            }
            circle {
                cx: "12",
                cy: "15",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileVideoCamera;
impl IconShape for LdFileVideoCamera {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 12V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m10 17.843 3.033-1.755a.64.64 0 0 1 .967.56v4.704a.65.65 0 0 1-.967.56L10 20.157",
            }
            rect {
                height: "6",
                rx: "1",
                width: "7",
                x: "3",
                y: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileVolume;
impl IconShape for LdFileVolume {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 11.55V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2h-1.95",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M12 15a5 5 0 0 1 0 6",
            }
            path {
                d: "M8 14.502a.5.5 0 0 0-.826-.381l-1.893 1.631a1 1 0 0 1-.651.243H3.5a.5.5 0 0 0-.5.501v3.006a.5.5 0 0 0 .5.501h1.129a1 1 0 0 1 .652.243l1.893 1.633a.5.5 0 0 0 .826-.38z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileXCorner;
impl IconShape for LdFileXCorner {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 22H6a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v5",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m15 17 5 5",
            }
            path {
                d: "m20 17-5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFileX;
impl IconShape for LdFileX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "m14.5 12.5-5 5",
            }
            path {
                d: "m9.5 12.5 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFile;
impl IconShape for LdFile {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFiles;
impl IconShape for LdFiles {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 2h-4a2 2 0 0 0-2 2v11a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V8",
            }
            path {
                d: "M16.706 2.706A2.4 2.4 0 0 0 15 2v5a1 1 0 0 0 1 1h5a2.4 2.4 0 0 0-.706-1.706z",
            }
            path {
                d: "M5 7a2 2 0 0 0-2 2v11a2 2 0 0 0 2 2h8a2 2 0 0 0 1.732-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFilm;
impl IconShape for LdFilm {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M7 3v18",
            }
            path {
                d: "M3 7.5h4",
            }
            path {
                d: "M3 12h18",
            }
            path {
                d: "M3 16.5h4",
            }
            path {
                d: "M17 3v18",
            }
            path {
                d: "M17 7.5h4",
            }
            path {
                d: "M17 16.5h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFingerprintPattern;
impl IconShape for LdFingerprintPattern {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 10a2 2 0 0 0-2 2c0 1.02-.1 2.51-.26 4",
            }
            path {
                d: "M14 13.12c0 2.38 0 6.38-1 8.88",
            }
            path {
                d: "M17.29 21.02c.12-.6.43-2.3.5-3.02",
            }
            path {
                d: "M2 12a10 10 0 0 1 18-6",
            }
            path {
                d: "M2 16h.01",
            }
            path {
                d: "M21.8 16c.2-2 .131-5.354 0-6",
            }
            path {
                d: "M5 19.5C5.5 18 6 15 6 12a6 6 0 0 1 .34-2",
            }
            path {
                d: "M8.65 22c.21-.66.45-1.32.57-2",
            }
            path {
                d: "M9 6.8a6 6 0 0 1 9 5.2v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFireExtinguisher;
impl IconShape for LdFireExtinguisher {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 6.5V3a1 1 0 0 0-1-1h-2a1 1 0 0 0-1 1v3.5",
            }
            path {
                d: "M9 18h8",
            }
            path {
                d: "M18 3h-3",
            }
            path {
                d: "M11 3a6 6 0 0 0-6 6v11",
            }
            path {
                d: "M5 13h4",
            }
            path {
                d: "M17 10a4 4 0 0 0-8 0v10a2 2 0 0 0 2 2h4a2 2 0 0 0 2-2Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFishOff;
impl IconShape for LdFishOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 12.47v.03m0-.5v.47m-.475 5.056A6.744 6.744 0 0 1 15 18c-3.56 0-7.56-2.53-8.5-6 .348-1.28 1.114-2.433 2.121-3.38m3.444-2.088A8.802 8.802 0 0 1 15 6c3.56 0 6.06 2.54 7 6-.309 1.14-.786 2.177-1.413 3.058",
            }
            path {
                d: "M7 10.67C7 8 5.58 5.97 2.73 5.5c-1 1.5-1 5 .23 6.5-1.24 1.5-1.24 5-.23 6.5C5.58 18.03 7 16 7 13.33m7.48-4.372A9.77 9.77 0 0 1 16 6.07m0 11.86a9.77 9.77 0 0 1-1.728-3.618",
            }
            path {
                d: "m16.01 17.93-.23 1.4A2 2 0 0 1 13.8 21H9.5a5.96 5.96 0 0 0 1.49-3.98M8.53 3h5.27a2 2 0 0 1 1.98 1.67l.23 1.4M2 2l20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFishSymbol;
impl IconShape for LdFishSymbol {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 16s9-15 20-4C11 23 2 8 2 8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFish;
impl IconShape for LdFish {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6.5 12c.94-3.46 4.94-6 8.5-6 3.56 0 6.06 2.54 7 6-.94 3.47-3.44 6-7 6s-7.56-2.53-8.5-6Z",
            }
            path {
                d: "M18 12v.5",
            }
            path {
                d: "M16 17.93a9.77 9.77 0 0 1 0-11.86",
            }
            path {
                d: "M7 10.67C7 8 5.58 5.97 2.73 5.5c-1 1.5-1 5 .23 6.5-1.24 1.5-1.24 5-.23 6.5C5.58 18.03 7 16 7 13.33",
            }
            path {
                d: "M10.46 7.26C10.2 5.88 9.17 4.24 8 3h5.8a2 2 0 0 1 1.98 1.67l.23 1.4",
            }
            path {
                d: "m16.01 17.93-.23 1.4A2 2 0 0 1 13.8 21H9.5a5.96 5.96 0 0 0 1.49-3.98",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlagOff;
impl IconShape for LdFlagOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 16c-3 0-5-2-8-2a6 6 0 0 0-4 1.528",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M4 22V4",
            }
            path {
                d: "M7.656 2H8c3 0 5 2 7.333 2q2 0 3.067-.8A1 1 0 0 1 20 4v10.347",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlagTriangleLeft;
impl IconShape for LdFlagTriangleLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 22V2.8a.8.8 0 0 0-1.17-.71L5.45 7.78a.8.8 0 0 0 0 1.44L18 15.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlagTriangleRight;
impl IconShape for LdFlagTriangleRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 22V2.8a.8.8 0 0 1 1.17-.71l11.38 5.69a.8.8 0 0 1 0 1.44L6 15.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlag;
impl IconShape for LdFlag {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 22V4a1 1 0 0 1 .4-.8A6 6 0 0 1 8 2c3 0 5 2 7.333 2q2 0 3.067-.8A1 1 0 0 1 20 4v10a1 1 0 0 1-.4.8A6 6 0 0 1 16 16c-3 0-5-2-8-2a6 6 0 0 0-4 1.528",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlameKindling;
impl IconShape for LdFlameKindling {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2c1 3 2.5 3.5 3.5 4.5A5 5 0 0 1 17 10a5 5 0 1 1-10 0c0-.3 0-.6.1-.9a2 2 0 1 0 3.3-2C8 4.5 11 2 12 2Z",
            }
            path {
                d: "m5 22 14-4",
            }
            path {
                d: "m5 18 14 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlame;
impl IconShape for LdFlame {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3q1 4 4 6.5t3 5.5a1 1 0 0 1-14 0 5 5 0 0 1 1-3 1 1 0 0 0 5 0c0-2-1.5-3-1.5-5q0-2 2.5-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlashlightOff;
impl IconShape for LdFlashlightOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 16v4a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2V10c0-2-2-2-2-4",
            }
            path {
                d: "M7 2h11v4c0 2-2 2-2 4v1",
            }
            line {
                x1: "11",
                x2: "18",
                y1: "6",
                y2: "6",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlashlight;
impl IconShape for LdFlashlight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 6c0 2-2 2-2 4v10a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2V10c0-2-2-2-2-4V2h12z",
            }
            line {
                x1: "6",
                x2: "18",
                y1: "6",
                y2: "6",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "12",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlaskConicalOff;
impl IconShape for LdFlaskConicalOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2v2.343",
            }
            path {
                d: "M14 2v6.343",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M20 20a2 2 0 0 1-2 2H6a2 2 0 0 1-1.755-2.96l5.227-9.563",
            }
            path {
                d: "M6.453 15H15",
            }
            path {
                d: "M8.5 2h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlaskConical;
impl IconShape for LdFlaskConical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 2v6a2 2 0 0 0 .245.96l5.51 10.08A2 2 0 0 1 18 22H6a2 2 0 0 1-1.755-2.96l5.51-10.08A2 2 0 0 0 10 8V2",
            }
            path {
                d: "M6.453 15h11.094",
            }
            path {
                d: "M8.5 2h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlaskRound;
impl IconShape for LdFlaskRound {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2v6.292a7 7 0 1 0 4 0V2",
            }
            path {
                d: "M5 15h14",
            }
            path {
                d: "M8.5 2h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlipHorizontal2;
impl IconShape for LdFlipHorizontal2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m3 7 5 5-5 5V7",
            }
            path {
                d: "m21 7-5 5 5 5V7",
            }
            path {
                d: "M12 20v2",
            }
            path {
                d: "M12 14v2",
            }
            path {
                d: "M12 8v2",
            }
            path {
                d: "M12 2v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlipHorizontal;
impl IconShape for LdFlipHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 3H5a2 2 0 0 0-2 2v14c0 1.1.9 2 2 2h3",
            }
            path {
                d: "M16 3h3a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-3",
            }
            path {
                d: "M12 20v2",
            }
            path {
                d: "M12 14v2",
            }
            path {
                d: "M12 8v2",
            }
            path {
                d: "M12 2v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlipVertical2;
impl IconShape for LdFlipVertical2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m17 3-5 5-5-5h10",
            }
            path {
                d: "m17 21-5-5-5 5h10",
            }
            path {
                d: "M4 12H2",
            }
            path {
                d: "M10 12H8",
            }
            path {
                d: "M16 12h-2",
            }
            path {
                d: "M22 12h-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlipVertical;
impl IconShape for LdFlipVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 8V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v3",
            }
            path {
                d: "M21 16v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-3",
            }
            path {
                d: "M4 12H2",
            }
            path {
                d: "M10 12H8",
            }
            path {
                d: "M16 12h-2",
            }
            path {
                d: "M22 12h-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlower2;
impl IconShape for LdFlower2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 5a3 3 0 1 1 3 3m-3-3a3 3 0 1 0-3 3m3-3v1M9 8a3 3 0 1 0 3 3M9 8h1m5 0a3 3 0 1 1-3 3m3-3h-1m-2 3v-1",
            }
            circle {
                cx: "12",
                cy: "8",
                r: "2",
            }
            path {
                d: "M12 10v12",
            }
            path {
                d: "M12 22c4.2 0 7-1.667 7-5-4.2 0-7 1.667-7 5Z",
            }
            path {
                d: "M12 22c-4.2 0-7-1.667-7-5 4.2 0 7 1.667 7 5Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFlower;
impl IconShape for LdFlower {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
            path {
                d: "M12 16.5A4.5 4.5 0 1 1 7.5 12 4.5 4.5 0 1 1 12 7.5a4.5 4.5 0 1 1 4.5 4.5 4.5 4.5 0 1 1-4.5 4.5",
            }
            path {
                d: "M12 7.5V9",
            }
            path {
                d: "M7.5 12H9",
            }
            path {
                d: "M16.5 12H15",
            }
            path {
                d: "M12 16.5V15",
            }
            path {
                d: "m8 8 1.88 1.88",
            }
            path {
                d: "M14.12 9.88 16 8",
            }
            path {
                d: "m8 16 1.88-1.88",
            }
            path {
                d: "M14.12 14.12 16 16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFocus;
impl IconShape for LdFocus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFoldHorizontal;
impl IconShape for LdFoldHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 12h6",
            }
            path {
                d: "M22 12h-6",
            }
            path {
                d: "M12 2v2",
            }
            path {
                d: "M12 8v2",
            }
            path {
                d: "M12 14v2",
            }
            path {
                d: "M12 20v2",
            }
            path {
                d: "m19 9-3 3 3 3",
            }
            path {
                d: "m5 15 3-3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFoldVertical;
impl IconShape for LdFoldVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 22v-6",
            }
            path {
                d: "M12 8V2",
            }
            path {
                d: "M4 12H2",
            }
            path {
                d: "M10 12H8",
            }
            path {
                d: "M16 12h-2",
            }
            path {
                d: "M22 12h-2",
            }
            path {
                d: "m15 19-3-3-3 3",
            }
            path {
                d: "m15 5-3 3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderArchive;
impl IconShape for LdFolderArchive {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "15",
                cy: "19",
                r: "2",
            }
            path {
                d: "M20.9 19.8A2 2 0 0 0 22 18V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2h5.1",
            }
            path {
                d: "M15 11v-1",
            }
            path {
                d: "M15 17v-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderCheck;
impl IconShape for LdFolderCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
            }
            path {
                d: "m9 13 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderClock;
impl IconShape for LdFolderClock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 14v2.2l1.6 1",
            }
            path {
                d: "M7 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2",
            }
            circle {
                cx: "16",
                cy: "16",
                r: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderClosed;
impl IconShape for LdFolderClosed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
            }
            path {
                d: "M2 10h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderCode;
impl IconShape for LdFolderCode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 10.5 8 13l2 2.5",
            }
            path {
                d: "m14 10.5 2 2.5-2 2.5",
            }
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderCog;
impl IconShape for LdFolderCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.3 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.98a2 2 0 0 1 1.69.9l.66 1.2A2 2 0 0 0 12 6h8a2 2 0 0 1 2 2v3.3",
            }
            path {
                d: "m14.305 19.53.923-.382",
            }
            path {
                d: "m15.228 16.852-.923-.383",
            }
            path {
                d: "m16.852 15.228-.383-.923",
            }
            path {
                d: "m16.852 20.772-.383.924",
            }
            path {
                d: "m19.148 15.228.383-.923",
            }
            path {
                d: "m19.53 21.696-.382-.924",
            }
            path {
                d: "m20.772 16.852.924-.383",
            }
            path {
                d: "m20.772 19.148.924.383",
            }
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderDot;
impl IconShape for LdFolderDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z",
            }
            circle {
                cx: "12",
                cy: "13",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderDown;
impl IconShape for LdFolderDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
            }
            path {
                d: "M12 10v6",
            }
            path {
                d: "m15 13-3 3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderGit2;
impl IconShape for LdFolderGit2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 19a5 5 0 0 1-5-5v8",
            }
            path {
                d: "M9 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v5",
            }
            circle {
                cx: "13",
                cy: "12",
                r: "2",
            }
            circle {
                cx: "20",
                cy: "19",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderGit;
impl IconShape for LdFolderGit {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "13",
                r: "2",
            }
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
            }
            path {
                d: "M14 13h3",
            }
            path {
                d: "M7 13h3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderHeart;
impl IconShape for LdFolderHeart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.638 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v3.417",
            }
            path {
                d: "M14.62 18.8A2.25 2.25 0 1 1 18 15.836a2.25 2.25 0 1 1 3.38 2.966l-2.626 2.856a.998.998 0 0 1-1.507 0z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderInput;
impl IconShape for LdFolderInput {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-1",
            }
            path {
                d: "M2 13h10",
            }
            path {
                d: "m9 16 3-3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderKanban;
impl IconShape for LdFolderKanban {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z",
            }
            path {
                d: "M8 10v4",
            }
            path {
                d: "M12 10v2",
            }
            path {
                d: "M16 10v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderKey;
impl IconShape for LdFolderKey {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "16",
                cy: "20",
                r: "2",
            }
            path {
                d: "M10 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v2",
            }
            path {
                d: "m22 14-4.5 4.5",
            }
            path {
                d: "m21 15 1 1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderLock;
impl IconShape for LdFolderLock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "5",
                rx: "1",
                width: "8",
                x: "14",
                y: "17",
            }
            path {
                d: "M10 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v2.5",
            }
            path {
                d: "M20 17v-2a2 2 0 1 0-4 0v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderMinus;
impl IconShape for LdFolderMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 13h6",
            }
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderOpenDot;
impl IconShape for LdFolderOpenDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m6 14 1.45-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.55 6a2 2 0 0 1-1.94 1.5H4a2 2 0 0 1-2-2V5c0-1.1.9-2 2-2h3.93a2 2 0 0 1 1.66.9l.82 1.2a2 2 0 0 0 1.66.9H18a2 2 0 0 1 2 2v2",
            }
            circle {
                cx: "14",
                cy: "15",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderOpen;
impl IconShape for LdFolderOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderOutput;
impl IconShape for LdFolderOutput {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 7.5V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-1.5",
            }
            path {
                d: "M2 13h10",
            }
            path {
                d: "m5 10-3 3 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderPen;
impl IconShape for LdFolderPen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 11.5V5a2 2 0 0 1 2-2h3.9c.7 0 1.3.3 1.7.9l.8 1.2c.4.6 1 .9 1.7.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-9.5",
            }
            path {
                d: "M11.378 13.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderPlus;
impl IconShape for LdFolderPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 10v6",
            }
            path {
                d: "M9 13h6",
            }
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderRoot;
impl IconShape for LdFolderRoot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z",
            }
            circle {
                cx: "12",
                cy: "13",
                r: "2",
            }
            path {
                d: "M12 15v5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderSearch2;
impl IconShape for LdFolderSearch2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "11.5",
                cy: "12.5",
                r: "2.5",
            }
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
            }
            path {
                d: "M13.3 14.3 15 16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderSearch;
impl IconShape for LdFolderSearch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.7 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v4.1",
            }
            path {
                d: "m21 21-1.9-1.9",
            }
            circle {
                cx: "17",
                cy: "17",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderSymlink;
impl IconShape for LdFolderSymlink {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9.35V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h7",
            }
            path {
                d: "m8 16 3-3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderSync;
impl IconShape for LdFolderSync {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v.5",
            }
            path {
                d: "M12 10v4h4",
            }
            path {
                d: "m12 14 1.535-1.605a5 5 0 0 1 8 1.5",
            }
            path {
                d: "M22 22v-4h-4",
            }
            path {
                d: "m22 18-1.535 1.605a5 5 0 0 1-8-1.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderTree;
impl IconShape for LdFolderTree {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 10a1 1 0 0 0 1-1V6a1 1 0 0 0-1-1h-2.5a1 1 0 0 1-.8-.4l-.9-1.2A1 1 0 0 0 15 3h-2a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1Z",
            }
            path {
                d: "M20 21a1 1 0 0 0 1-1v-3a1 1 0 0 0-1-1h-2.9a1 1 0 0 1-.88-.55l-.42-.85a1 1 0 0 0-.92-.6H13a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1Z",
            }
            path {
                d: "M3 5a2 2 0 0 0 2 2h3",
            }
            path {
                d: "M3 3v13a2 2 0 0 0 2 2h3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderUp;
impl IconShape for LdFolderUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
            }
            path {
                d: "M12 10v6",
            }
            path {
                d: "m9 13 3-3 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolderX;
impl IconShape for LdFolderX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
            }
            path {
                d: "m9.5 10.5 5 5",
            }
            path {
                d: "m14.5 10.5-5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolder;
impl IconShape for LdFolder {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFolders;
impl IconShape for LdFolders {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 5a2 2 0 0 1 2 2v7a2 2 0 0 1-2 2H9a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h2.5a1.5 1.5 0 0 1 1.2.6l.6.8a1.5 1.5 0 0 0 1.2.6z",
            }
            path {
                d: "M3 8.268a2 2 0 0 0-1 1.738V19a2 2 0 0 0 2 2h11a2 2 0 0 0 1.732-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFootprints;
impl IconShape for LdFootprints {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 16v-2.38C4 11.5 2.97 10.5 3 8c.03-2.72 1.49-6 4.5-6C9.37 2 10 3.8 10 5.5c0 3.11-2 5.66-2 8.68V16a2 2 0 1 1-4 0Z",
            }
            path {
                d: "M20 20v-2.38c0-2.12 1.03-3.12 1-5.62-.03-2.72-1.49-6-4.5-6C14.63 6 14 7.8 14 9.5c0 3.11 2 5.66 2 8.68V20a2 2 0 1 0 4 0Z",
            }
            path {
                d: "M16 17h4",
            }
            path {
                d: "M4 13h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdForklift;
impl IconShape for LdForklift {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 12H5a2 2 0 0 0-2 2v5",
            }
            circle {
                cx: "13",
                cy: "19",
                r: "2",
            }
            circle {
                cx: "5",
                cy: "19",
                r: "2",
            }
            path {
                d: "M8 19h3m5-17v17h6M6 12V7c0-1.1.9-2 2-2h3l5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdForm;
impl IconShape for LdForm {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 14h6",
            }
            path {
                d: "M4 2h10",
            }
            rect {
                height: "4",
                rx: "1",
                width: "16",
                x: "4",
                y: "18",
            }
            rect {
                height: "4",
                rx: "1",
                width: "16",
                x: "4",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdForward;
impl IconShape for LdForward {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 17 5-5-5-5",
            }
            path {
                d: "M4 18v-2a4 4 0 0 1 4-4h12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFrame;
impl IconShape for LdFrame {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "22",
                x2: "2",
                y1: "6",
                y2: "6",
            }
            line {
                x1: "22",
                x2: "2",
                y1: "18",
                y2: "18",
            }
            line {
                x1: "6",
                x2: "6",
                y1: "2",
                y2: "22",
            }
            line {
                x1: "18",
                x2: "18",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFramer;
impl IconShape for LdFramer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 16V9h14V2H5l14 14h-7m-7 0 7 7v-7m-7 0h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFrown;
impl IconShape for LdFrown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M16 16s-1.5-2-4-2-4 2-4 2",
            }
            line {
                x1: "9",
                x2: "9.01",
                y1: "9",
                y2: "9",
            }
            line {
                x1: "15",
                x2: "15.01",
                y1: "9",
                y2: "9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFuel;
impl IconShape for LdFuel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 13h2a2 2 0 0 1 2 2v2a2 2 0 0 0 4 0v-6.998a2 2 0 0 0-.59-1.42L18 5",
            }
            path {
                d: "M14 21V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v16",
            }
            path {
                d: "M2 21h13",
            }
            path {
                d: "M3 9h11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFullscreen;
impl IconShape for LdFullscreen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
            rect {
                height: "8",
                rx: "1",
                width: "10",
                x: "7",
                y: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFunnelPlus;
impl IconShape for LdFunnelPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.354 3H3a1 1 0 0 0-.742 1.67l7.225 7.989A2 2 0 0 1 10 14v6a1 1 0 0 0 .553.895l2 1A1 1 0 0 0 14 21v-7a2 2 0 0 1 .517-1.341l1.218-1.348",
            }
            path {
                d: "M16 6h6",
            }
            path {
                d: "M19 3v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFunnelX;
impl IconShape for LdFunnelX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.531 3H3a1 1 0 0 0-.742 1.67l7.225 7.989A2 2 0 0 1 10 14v6a1 1 0 0 0 .553.895l2 1A1 1 0 0 0 14 21v-7a2 2 0 0 1 .517-1.341l.427-.473",
            }
            path {
                d: "m16.5 3.5 5 5",
            }
            path {
                d: "m21.5 3.5-5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdFunnel;
impl IconShape for LdFunnel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 20a1 1 0 0 0 .553.895l2 1A1 1 0 0 0 14 21v-7a2 2 0 0 1 .517-1.341L21.74 4.67A1 1 0 0 0 21 3H3a1 1 0 0 0-.742 1.67l7.225 7.989A2 2 0 0 1 10 14z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGalleryHorizontalEnd;
impl IconShape for LdGalleryHorizontalEnd {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 7v10",
            }
            path {
                d: "M6 5v14",
            }
            rect {
                height: "18",
                rx: "2",
                width: "12",
                x: "10",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGalleryHorizontal;
impl IconShape for LdGalleryHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 3v18",
            }
            rect {
                height: "18",
                rx: "2",
                width: "12",
                x: "6",
                y: "3",
            }
            path {
                d: "M22 3v18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGalleryThumbnails;
impl IconShape for LdGalleryThumbnails {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M4 21h1",
            }
            path {
                d: "M9 21h1",
            }
            path {
                d: "M14 21h1",
            }
            path {
                d: "M19 21h1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGalleryVerticalEnd;
impl IconShape for LdGalleryVerticalEnd {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 2h10",
            }
            path {
                d: "M5 6h14",
            }
            rect {
                height: "12",
                rx: "2",
                width: "18",
                x: "3",
                y: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGalleryVertical;
impl IconShape for LdGalleryVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 2h18",
            }
            rect {
                height: "12",
                rx: "2",
                width: "18",
                x: "3",
                y: "6",
            }
            path {
                d: "M3 22h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGamepad2;
impl IconShape for LdGamepad2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "6",
                x2: "10",
                y1: "11",
                y2: "11",
            }
            line {
                x1: "8",
                x2: "8",
                y1: "9",
                y2: "13",
            }
            line {
                x1: "15",
                x2: "15.01",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "18",
                x2: "18.01",
                y1: "10",
                y2: "10",
            }
            path {
                d: "M17.32 5H6.68a4 4 0 0 0-3.978 3.59c-.006.052-.01.101-.017.152C2.604 9.416 2 14.456 2 16a3 3 0 0 0 3 3c1 0 1.5-.5 2-1l1.414-1.414A2 2 0 0 1 9.828 16h4.344a2 2 0 0 1 1.414.586L17 18c.5.5 1 1 2 1a3 3 0 0 0 3-3c0-1.545-.604-6.584-.685-7.258-.007-.05-.011-.1-.017-.151A4 4 0 0 0 17.32 5z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGamepadDirectional;
impl IconShape for LdGamepadDirectional {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.146 15.854a1.207 1.207 0 0 1 1.708 0l1.56 1.56A2 2 0 0 1 15 18.828V21a1 1 0 0 1-1 1h-4a1 1 0 0 1-1-1v-2.172a2 2 0 0 1 .586-1.414z",
            }
            path {
                d: "M18.828 15a2 2 0 0 1-1.414-.586l-1.56-1.56a1.207 1.207 0 0 1 0-1.708l1.56-1.56A2 2 0 0 1 18.828 9H21a1 1 0 0 1 1 1v4a1 1 0 0 1-1 1z",
            }
            path {
                d: "M6.586 14.414A2 2 0 0 1 5.172 15H3a1 1 0 0 1-1-1v-4a1 1 0 0 1 1-1h2.172a2 2 0 0 1 1.414.586l1.56 1.56a1.207 1.207 0 0 1 0 1.708z",
            }
            path {
                d: "M9 3a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2.172a2 2 0 0 1-.586 1.414l-1.56 1.56a1.207 1.207 0 0 1-1.708 0l-1.56-1.56A2 2 0 0 1 9 5.172z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGamepad;
impl IconShape for LdGamepad {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "6",
                x2: "10",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "8",
                x2: "8",
                y1: "10",
                y2: "14",
            }
            line {
                x1: "15",
                x2: "15.01",
                y1: "13",
                y2: "13",
            }
            line {
                x1: "18",
                x2: "18.01",
                y1: "11",
                y2: "11",
            }
            rect {
                height: "12",
                rx: "2",
                width: "20",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGauge;
impl IconShape for LdGauge {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12 14 4-4",
            }
            path {
                d: "M3.34 19a10 10 0 1 1 17.32 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGavel;
impl IconShape for LdGavel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14 13-8.381 8.38a1 1 0 0 1-3.001-3l8.384-8.381",
            }
            path {
                d: "m16 16 6-6",
            }
            path {
                d: "m21.5 10.5-8-8",
            }
            path {
                d: "m8 8 6-6",
            }
            path {
                d: "m8.5 7.5 8 8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGem;
impl IconShape for LdGem {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.5 3 8 9l4 13 4-13-2.5-6",
            }
            path {
                d: "M17 3a2 2 0 0 1 1.6.8l3 4a2 2 0 0 1 .013 2.382l-7.99 10.986a2 2 0 0 1-3.247 0l-7.99-10.986A2 2 0 0 1 2.4 7.8l2.998-3.997A2 2 0 0 1 7 3z",
            }
            path {
                d: "M2 9h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGeorgianLari;
impl IconShape for LdGeorgianLari {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.5 21a7.5 7.5 0 1 1 7.35-9",
            }
            path {
                d: "M13 12V3",
            }
            path {
                d: "M4 21h16",
            }
            path {
                d: "M9 12V3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGhost;
impl IconShape for LdGhost {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 10h.01",
            }
            path {
                d: "M15 10h.01",
            }
            path {
                d: "M12 2a8 8 0 0 0-8 8v12l3-3 2.5 2.5L12 19l2.5 2.5L17 19l3 3V10a8 8 0 0 0-8-8z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGift;
impl IconShape for LdGift {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "4",
                rx: "1",
                width: "18",
                x: "3",
                y: "8",
            }
            path {
                d: "M12 8v13",
            }
            path {
                d: "M19 12v7a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2v-7",
            }
            path {
                d: "M7.5 8a2.5 2.5 0 0 1 0-5A4.8 8 0 0 1 12 8a4.8 8 0 0 1 4.5-5 2.5 2.5 0 0 1 0 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitBranchMinus;
impl IconShape for LdGitBranchMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 6a9 9 0 0 0-9 9V3",
            }
            path {
                d: "M21 18h-6",
            }
            circle {
                cx: "18",
                cy: "6",
                r: "3",
            }
            circle {
                cx: "6",
                cy: "18",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitBranchPlus;
impl IconShape for LdGitBranchPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 3v12",
            }
            path {
                d: "M18 9a3 3 0 1 0 0-6 3 3 0 0 0 0 6z",
            }
            path {
                d: "M6 21a3 3 0 1 0 0-6 3 3 0 0 0 0 6z",
            }
            path {
                d: "M15 6a9 9 0 0 0-9 9",
            }
            path {
                d: "M18 15v6",
            }
            path {
                d: "M21 18h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitBranch;
impl IconShape for LdGitBranch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "6",
                x2: "6",
                y1: "3",
                y2: "15",
            }
            circle {
                cx: "18",
                cy: "6",
                r: "3",
            }
            circle {
                cx: "6",
                cy: "18",
                r: "3",
            }
            path {
                d: "M18 9a9 9 0 0 1-9 9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitCommitHorizontal;
impl IconShape for LdGitCommitHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
            line {
                x1: "3",
                x2: "9",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "15",
                x2: "21",
                y1: "12",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitCommitVertical;
impl IconShape for LdGitCommitVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v6",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
            path {
                d: "M12 15v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitCompareArrows;
impl IconShape for LdGitCompareArrows {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "5",
                cy: "6",
                r: "3",
            }
            path {
                d: "M12 6h5a2 2 0 0 1 2 2v7",
            }
            path {
                d: "m15 9-3-3 3-3",
            }
            circle {
                cx: "19",
                cy: "18",
                r: "3",
            }
            path {
                d: "M12 18H7a2 2 0 0 1-2-2V9",
            }
            path {
                d: "m9 15 3 3-3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitCompare;
impl IconShape for LdGitCompare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
            circle {
                cx: "6",
                cy: "6",
                r: "3",
            }
            path {
                d: "M13 6h3a2 2 0 0 1 2 2v7",
            }
            path {
                d: "M11 18H8a2 2 0 0 1-2-2V9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitFork;
impl IconShape for LdGitFork {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "18",
                r: "3",
            }
            circle {
                cx: "6",
                cy: "6",
                r: "3",
            }
            circle {
                cx: "18",
                cy: "6",
                r: "3",
            }
            path {
                d: "M18 9v2c0 .6-.4 1-1 1H7c-.6 0-1-.4-1-1V9",
            }
            path {
                d: "M12 12v3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitGraph;
impl IconShape for LdGitGraph {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "5",
                cy: "6",
                r: "3",
            }
            path {
                d: "M5 9v6",
            }
            circle {
                cx: "5",
                cy: "18",
                r: "3",
            }
            path {
                d: "M12 3v18",
            }
            circle {
                cx: "19",
                cy: "6",
                r: "3",
            }
            path {
                d: "M16 15.7A9 9 0 0 0 19 9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitMerge;
impl IconShape for LdGitMerge {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
            circle {
                cx: "6",
                cy: "6",
                r: "3",
            }
            path {
                d: "M6 21V9a9 9 0 0 0 9 9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitPullRequestArrow;
impl IconShape for LdGitPullRequestArrow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "5",
                cy: "6",
                r: "3",
            }
            path {
                d: "M5 9v12",
            }
            circle {
                cx: "19",
                cy: "18",
                r: "3",
            }
            path {
                d: "m15 9-3-3 3-3",
            }
            path {
                d: "M12 6h5a2 2 0 0 1 2 2v7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitPullRequestClosed;
impl IconShape for LdGitPullRequestClosed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "6",
                cy: "6",
                r: "3",
            }
            path {
                d: "M6 9v12",
            }
            path {
                d: "m21 3-6 6",
            }
            path {
                d: "m21 9-6-6",
            }
            path {
                d: "M18 11.5V15",
            }
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitPullRequestCreateArrow;
impl IconShape for LdGitPullRequestCreateArrow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "5",
                cy: "6",
                r: "3",
            }
            path {
                d: "M5 9v12",
            }
            path {
                d: "m15 9-3-3 3-3",
            }
            path {
                d: "M12 6h5a2 2 0 0 1 2 2v3",
            }
            path {
                d: "M19 15v6",
            }
            path {
                d: "M22 18h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitPullRequestCreate;
impl IconShape for LdGitPullRequestCreate {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "6",
                cy: "6",
                r: "3",
            }
            path {
                d: "M6 9v12",
            }
            path {
                d: "M13 6h3a2 2 0 0 1 2 2v3",
            }
            path {
                d: "M18 15v6",
            }
            path {
                d: "M21 18h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitPullRequestDraft;
impl IconShape for LdGitPullRequestDraft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
            circle {
                cx: "6",
                cy: "6",
                r: "3",
            }
            path {
                d: "M18 6V5",
            }
            path {
                d: "M18 11v-1",
            }
            line {
                x1: "6",
                x2: "6",
                y1: "9",
                y2: "21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitPullRequest;
impl IconShape for LdGitPullRequest {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
            circle {
                cx: "6",
                cy: "6",
                r: "3",
            }
            path {
                d: "M13 6h3a2 2 0 0 1 2 2v7",
            }
            line {
                x1: "6",
                x2: "6",
                y1: "9",
                y2: "21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGithub;
impl IconShape for LdGithub {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 22v-4a4.8 4.8 0 0 0-1-3.5c3 0 6-2 6-5.5.08-1.25-.27-2.48-1-3.5.28-1.15.28-2.35 0-3.5 0 0-1 0-3 1.5-2.64-.5-5.36-.5-8 0C6 2 5 2 5 2c-.3 1.15-.3 2.35 0 3.5A5.403 5.403 0 0 0 4 9c0 3.5 3 5.5 6 5.5-.39.49-.68 1.05-.85 1.65-.17.6-.22 1.23-.15 1.85v4",
            }
            path {
                d: "M9 18c-4.51 2-5-2-7-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGitlab;
impl IconShape for LdGitlab {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m22 13.29-3.33-10a.42.42 0 0 0-.14-.18.38.38 0 0 0-.22-.11.39.39 0 0 0-.23.07.42.42 0 0 0-.14.18l-2.26 6.67H8.32L6.1 3.26a.42.42 0 0 0-.1-.18.38.38 0 0 0-.26-.08.39.39 0 0 0-.23.07.42.42 0 0 0-.14.18L2 13.29a.74.74 0 0 0 .27.83L12 21l9.69-6.88a.71.71 0 0 0 .31-.83Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGlassWater;
impl IconShape for LdGlassWater {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5.116 4.104A1 1 0 0 1 6.11 3h11.78a1 1 0 0 1 .994 1.105L17.19 20.21A2 2 0 0 1 15.2 22H8.8a2 2 0 0 1-2-1.79z",
            }
            path {
                d: "M6 12a5 5 0 0 1 6 0 5 5 0 0 0 6 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGlasses;
impl IconShape for LdGlasses {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "6",
                cy: "15",
                r: "4",
            }
            circle {
                cx: "18",
                cy: "15",
                r: "4",
            }
            path {
                d: "M14 15a2 2 0 0 0-2-2 2 2 0 0 0-2 2",
            }
            path {
                d: "M2.5 13 5 7c.7-1.3 1.4-2 3-2",
            }
            path {
                d: "M21.5 13 19 7c-.7-1.3-1.5-2-3-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGlobeLock;
impl IconShape for LdGlobeLock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.686 15A14.5 14.5 0 0 1 12 22a14.5 14.5 0 0 1 0-20 10 10 0 1 0 9.542 13",
            }
            path {
                d: "M2 12h8.5",
            }
            path {
                d: "M20 6V4a2 2 0 1 0-4 0v2",
            }
            rect {
                height: "5",
                rx: "1",
                width: "8",
                x: "14",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGlobe;
impl IconShape for LdGlobe {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20",
            }
            path {
                d: "M2 12h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGoal;
impl IconShape for LdGoal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13V2l8 4-8 4",
            }
            path {
                d: "M20.561 10.222a9 9 0 1 1-12.55-5.29",
            }
            path {
                d: "M8.002 9.997a5 5 0 1 0 8.9 2.02",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGpu;
impl IconShape for LdGpu {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 21V3",
            }
            path {
                d: "M2 5h18a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H2.26",
            }
            path {
                d: "M7 17v3a1 1 0 0 0 1 1h5a1 1 0 0 0 1-1v-3",
            }
            circle {
                cx: "16",
                cy: "11",
                r: "2",
            }
            circle {
                cx: "8",
                cy: "11",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGraduationCap;
impl IconShape for LdGraduationCap {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21.42 10.922a1 1 0 0 0-.019-1.838L12.83 5.18a2 2 0 0 0-1.66 0L2.6 9.08a1 1 0 0 0 0 1.832l8.57 3.908a2 2 0 0 0 1.66 0z",
            }
            path {
                d: "M22 10v6",
            }
            path {
                d: "M6 12.5V16a6 3 0 0 0 12 0v-3.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGrape;
impl IconShape for LdGrape {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 5V2l-5.89 5.89",
            }
            circle {
                cx: "16.6",
                cy: "15.89",
                r: "3",
            }
            circle {
                cx: "8.11",
                cy: "7.4",
                r: "3",
            }
            circle {
                cx: "12.35",
                cy: "11.65",
                r: "3",
            }
            circle {
                cx: "13.91",
                cy: "5.85",
                r: "3",
            }
            circle {
                cx: "18.15",
                cy: "10.09",
                r: "3",
            }
            circle {
                cx: "6.56",
                cy: "13.2",
                r: "3",
            }
            circle {
                cx: "10.8",
                cy: "17.44",
                r: "3",
            }
            circle {
                cx: "5",
                cy: "19",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGrid2x2Check;
impl IconShape for LdGrid2x2Check {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3",
            }
            path {
                d: "m16 19 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGrid2x2Plus;
impl IconShape for LdGrid2x2Plus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3",
            }
            path {
                d: "M16 19h6",
            }
            path {
                d: "M19 22v-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGrid2x2X;
impl IconShape for LdGrid2x2X {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3",
            }
            path {
                d: "m16 16 5 5",
            }
            path {
                d: "m16 21 5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGrid2x2;
impl IconShape for LdGrid2x2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v18",
            }
            path {
                d: "M3 12h18",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGrid3x2;
impl IconShape for LdGrid3x2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 3v18",
            }
            path {
                d: "M3 12h18",
            }
            path {
                d: "M9 3v18",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGrid3x3;
impl IconShape for LdGrid3x3 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 9h18",
            }
            path {
                d: "M3 15h18",
            }
            path {
                d: "M9 3v18",
            }
            path {
                d: "M15 3v18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGripHorizontal;
impl IconShape for LdGripHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "9",
                r: "1",
            }
            circle {
                cx: "19",
                cy: "9",
                r: "1",
            }
            circle {
                cx: "5",
                cy: "9",
                r: "1",
            }
            circle {
                cx: "12",
                cy: "15",
                r: "1",
            }
            circle {
                cx: "19",
                cy: "15",
                r: "1",
            }
            circle {
                cx: "5",
                cy: "15",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGripVertical;
impl IconShape for LdGripVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "9",
                cy: "12",
                r: "1",
            }
            circle {
                cx: "9",
                cy: "5",
                r: "1",
            }
            circle {
                cx: "9",
                cy: "19",
                r: "1",
            }
            circle {
                cx: "15",
                cy: "12",
                r: "1",
            }
            circle {
                cx: "15",
                cy: "5",
                r: "1",
            }
            circle {
                cx: "15",
                cy: "19",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGrip;
impl IconShape for LdGrip {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "5",
                r: "1",
            }
            circle {
                cx: "19",
                cy: "5",
                r: "1",
            }
            circle {
                cx: "5",
                cy: "5",
                r: "1",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "1",
            }
            circle {
                cx: "19",
                cy: "12",
                r: "1",
            }
            circle {
                cx: "5",
                cy: "12",
                r: "1",
            }
            circle {
                cx: "12",
                cy: "19",
                r: "1",
            }
            circle {
                cx: "19",
                cy: "19",
                r: "1",
            }
            circle {
                cx: "5",
                cy: "19",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGroup;
impl IconShape for LdGroup {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 7V5c0-1.1.9-2 2-2h2",
            }
            path {
                d: "M17 3h2c1.1 0 2 .9 2 2v2",
            }
            path {
                d: "M21 17v2c0 1.1-.9 2-2 2h-2",
            }
            path {
                d: "M7 21H5c-1.1 0-2-.9-2-2v-2",
            }
            rect {
                height: "5",
                rx: "1",
                width: "7",
                x: "7",
                y: "7",
            }
            rect {
                height: "5",
                rx: "1",
                width: "7",
                x: "10",
                y: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdGuitar;
impl IconShape for LdGuitar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m11.9 12.1 4.514-4.514",
            }
            path {
                d: "M20.1 2.3a1 1 0 0 0-1.4 0l-1.114 1.114A2 2 0 0 0 17 4.828v1.344a2 2 0 0 1-.586 1.414A2 2 0 0 1 17.828 7h1.344a2 2 0 0 0 1.414-.586L21.7 5.3a1 1 0 0 0 0-1.4z",
            }
            path {
                d: "m6 16 2 2",
            }
            path {
                d: "M8.23 9.85A3 3 0 0 1 11 8a5 5 0 0 1 5 5 3 3 0 0 1-1.85 2.77l-.92.38A2 2 0 0 0 12 18a4 4 0 0 1-4 4 6 6 0 0 1-6-6 4 4 0 0 1 4-4 2 2 0 0 0 1.85-1.23z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHam;
impl IconShape for LdHam {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.144 21.144A7.274 10.445 45 1 0 2.856 10.856",
            }
            path {
                d: "M13.144 21.144A7.274 4.365 45 0 0 2.856 10.856a7.274 4.365 45 0 0 10.288 10.288",
            }
            path {
                d: "M16.565 10.435 18.6 8.4a2.501 2.501 0 1 0 1.65-4.65 2.5 2.5 0 1 0-4.66 1.66l-2.024 2.025",
            }
            path {
                d: "m8.5 16.5-1-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHamburger;
impl IconShape for LdHamburger {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 16H4a2 2 0 1 1 0-4h16a2 2 0 1 1 0 4h-4.25",
            }
            path {
                d: "M5 12a2 2 0 0 1-2-2 9 7 0 0 1 18 0 2 2 0 0 1-2 2",
            }
            path {
                d: "M5 16a2 2 0 0 0-2 2 3 3 0 0 0 3 3h12a3 3 0 0 0 3-3 2 2 0 0 0-2-2q0 0 0 0",
            }
            path {
                d: "m6.67 12 6.13 4.6a2 2 0 0 0 2.8-.4l3.15-4.2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHammer;
impl IconShape for LdHammer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 12-9.373 9.373a1 1 0 0 1-3.001-3L12 9",
            }
            path {
                d: "m18 15 4-4",
            }
            path {
                d: "m21.5 11.5-1.914-1.914A2 2 0 0 1 19 8.172v-.344a2 2 0 0 0-.586-1.414l-1.657-1.657A6 6 0 0 0 12.516 3H9l1.243 1.243A6 6 0 0 1 12 8.485V10l2 2h1.172a2 2 0 0 1 1.414.586L18.5 14.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHandCoins;
impl IconShape for LdHandCoins {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 15h2a2 2 0 1 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 17",
            }
            path {
                d: "m7 21 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a2 2 0 0 0-2.75-2.91l-4.2 3.9",
            }
            path {
                d: "m2 16 6 6",
            }
            circle {
                cx: "16",
                cy: "9",
                r: "2.9",
            }
            circle {
                cx: "6",
                cy: "5",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHandFist;
impl IconShape for LdHandFist {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.035 17.012a3 3 0 0 0-3-3l-.311-.002a.72.72 0 0 1-.505-1.229l1.195-1.195A2 2 0 0 1 10.828 11H12a2 2 0 0 0 0-4H9.243a3 3 0 0 0-2.122.879l-2.707 2.707A4.83 4.83 0 0 0 3 14a8 8 0 0 0 8 8h2a8 8 0 0 0 8-8V7a2 2 0 1 0-4 0v2a2 2 0 1 0 4 0",
            }
            path {
                d: "M13.888 9.662A2 2 0 0 0 17 8V5A2 2 0 1 0 13 5",
            }
            path {
                d: "M9 5A2 2 0 1 0 5 5V10",
            }
            path {
                d: "M9 7V4A2 2 0 1 1 13 4V7.268",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHandGrab;
impl IconShape for LdHandGrab {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 11.5V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1.4",
            }
            path {
                d: "M14 10V8a2 2 0 0 0-2-2a2 2 0 0 0-2 2v2",
            }
            path {
                d: "M10 9.9V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v5",
            }
            path {
                d: "M6 14a2 2 0 0 0-2-2a2 2 0 0 0-2 2",
            }
            path {
                d: "M18 11a2 2 0 1 1 4 0v3a8 8 0 0 1-8 8h-4a8 8 0 0 1-8-8 2 2 0 1 1 4 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHandHeart;
impl IconShape for LdHandHeart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 14h2a2 2 0 0 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 16",
            }
            path {
                d: "m14.45 13.39 5.05-4.694C20.196 8 21 6.85 21 5.75a2.75 2.75 0 0 0-4.797-1.837.276.276 0 0 1-.406 0A2.75 2.75 0 0 0 11 5.75c0 1.2.802 2.248 1.5 2.946L16 11.95",
            }
            path {
                d: "m2 15 6 6",
            }
            path {
                d: "m7 20 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a1 1 0 0 0-2.75-2.91",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHandHelping;
impl IconShape for LdHandHelping {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 12h2a2 2 0 1 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 14",
            }
            path {
                d: "m7 18 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a2 2 0 0 0-2.75-2.91l-4.2 3.9",
            }
            path {
                d: "m2 13 6 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHandMetal;
impl IconShape for LdHandMetal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 12.5V10a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1.4",
            }
            path {
                d: "M14 11V9a2 2 0 1 0-4 0v2",
            }
            path {
                d: "M10 10.5V5a2 2 0 1 0-4 0v9",
            }
            path {
                d: "m7 15-1.76-1.76a2 2 0 0 0-2.83 2.82l3.6 3.6C7.5 21.14 9.2 22 12 22h2a8 8 0 0 0 8-8V7a2 2 0 1 0-4 0v5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHandPlatter;
impl IconShape for LdHandPlatter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3V2",
            }
            path {
                d: "m15.4 17.4 3.2-2.8a2 2 0 1 1 2.8 2.9l-3.6 3.3c-.7.8-1.7 1.2-2.8 1.2h-4c-1.1 0-2.1-.4-2.8-1.2l-1.302-1.464A1 1 0 0 0 6.151 19H5",
            }
            path {
                d: "M2 14h12a2 2 0 0 1 0 4h-2",
            }
            path {
                d: "M4 10h16",
            }
            path {
                d: "M5 10a7 7 0 0 1 14 0",
            }
            path {
                d: "M5 14v6a1 1 0 0 1-1 1H2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHand;
impl IconShape for LdHand {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 11V6a2 2 0 0 0-2-2a2 2 0 0 0-2 2",
            }
            path {
                d: "M14 10V4a2 2 0 0 0-2-2a2 2 0 0 0-2 2v2",
            }
            path {
                d: "M10 10.5V6a2 2 0 0 0-2-2a2 2 0 0 0-2 2v8",
            }
            path {
                d: "M18 8a2 2 0 1 1 4 0v6a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHandbag;
impl IconShape for LdHandbag {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.048 18.566A2 2 0 0 0 4 21h16a2 2 0 0 0 1.952-2.434l-2-9A2 2 0 0 0 18 8H6a2 2 0 0 0-1.952 1.566z",
            }
            path {
                d: "M8 11V6a4 4 0 0 1 8 0v5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHandshake;
impl IconShape for LdHandshake {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m11 17 2 2a1 1 0 1 0 3-3",
            }
            path {
                d: "m14 14 2.5 2.5a1 1 0 1 0 3-3l-3.88-3.88a3 3 0 0 0-4.24 0l-.88.88a1 1 0 1 1-3-3l2.81-2.81a5.79 5.79 0 0 1 7.06-.87l.47.28a2 2 0 0 0 1.42.25L21 4",
            }
            path {
                d: "m21 3 1 11h-2",
            }
            path {
                d: "M3 3 2 14l6.5 6.5a1 1 0 1 0 3-3",
            }
            path {
                d: "M3 4h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHardDriveDownload;
impl IconShape for LdHardDriveDownload {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v8",
            }
            path {
                d: "m16 6-4 4-4-4",
            }
            rect {
                height: "8",
                rx: "2",
                width: "20",
                x: "2",
                y: "14",
            }
            path {
                d: "M6 18h.01",
            }
            path {
                d: "M10 18h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHardDriveUpload;
impl IconShape for LdHardDriveUpload {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 6-4-4-4 4",
            }
            path {
                d: "M12 2v8",
            }
            rect {
                height: "8",
                rx: "2",
                width: "20",
                x: "2",
                y: "14",
            }
            path {
                d: "M6 18h.01",
            }
            path {
                d: "M10 18h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHardDrive;
impl IconShape for LdHardDrive {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "22",
                x2: "2",
                y1: "12",
                y2: "12",
            }
            path {
                d: "M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z",
            }
            line {
                x1: "6",
                x2: "6.01",
                y1: "16",
                y2: "16",
            }
            line {
                x1: "10",
                x2: "10.01",
                y1: "16",
                y2: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHardHat;
impl IconShape for LdHardHat {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 10V5a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v5",
            }
            path {
                d: "M14 6a6 6 0 0 1 6 6v3",
            }
            path {
                d: "M4 15v-3a6 6 0 0 1 6-6",
            }
            rect {
                height: "4",
                rx: "1",
                width: "20",
                x: "2",
                y: "15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHash;
impl IconShape for LdHash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "4",
                x2: "20",
                y1: "9",
                y2: "9",
            }
            line {
                x1: "4",
                x2: "20",
                y1: "15",
                y2: "15",
            }
            line {
                x1: "10",
                x2: "8",
                y1: "3",
                y2: "21",
            }
            line {
                x1: "16",
                x2: "14",
                y1: "3",
                y2: "21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHatGlasses;
impl IconShape for LdHatGlasses {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 18a2 2 0 0 0-4 0",
            }
            path {
                d: "m19 11-2.11-6.657a2 2 0 0 0-2.752-1.148l-1.276.61A2 2 0 0 1 12 4H8.5a2 2 0 0 0-1.925 1.456L5 11",
            }
            path {
                d: "M2 11h20",
            }
            circle {
                cx: "17",
                cy: "18",
                r: "3",
            }
            circle {
                cx: "7",
                cy: "18",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHaze;
impl IconShape for LdHaze {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m5.2 6.2 1.4 1.4",
            }
            path {
                d: "M2 13h2",
            }
            path {
                d: "M20 13h2",
            }
            path {
                d: "m17.4 7.6 1.4-1.4",
            }
            path {
                d: "M22 17H2",
            }
            path {
                d: "M22 21H2",
            }
            path {
                d: "M16 13a4 4 0 0 0-8 0",
            }
            path {
                d: "M12 5V2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHdmiPort;
impl IconShape for LdHdmiPort {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 9a1 1 0 0 0-1-1H3a1 1 0 0 0-1 1v4a1 1 0 0 0 1 1h1l2 2h12l2-2h1a1 1 0 0 0 1-1Z",
            }
            path {
                d: "M7.5 12h9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeading1;
impl IconShape for LdHeading1 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 12h8",
            }
            path {
                d: "M4 18V6",
            }
            path {
                d: "M12 18V6",
            }
            path {
                d: "m17 12 3-2v8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeading2;
impl IconShape for LdHeading2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 12h8",
            }
            path {
                d: "M4 18V6",
            }
            path {
                d: "M12 18V6",
            }
            path {
                d: "M21 18h-4c0-4 4-3 4-6 0-1.5-2-2.5-4-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeading3;
impl IconShape for LdHeading3 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 12h8",
            }
            path {
                d: "M4 18V6",
            }
            path {
                d: "M12 18V6",
            }
            path {
                d: "M17.5 10.5c1.7-1 3.5 0 3.5 1.5a2 2 0 0 1-2 2",
            }
            path {
                d: "M17 17.5c2 1.5 4 .3 4-1.5a2 2 0 0 0-2-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeading4;
impl IconShape for LdHeading4 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 18V6",
            }
            path {
                d: "M17 10v3a1 1 0 0 0 1 1h3",
            }
            path {
                d: "M21 10v8",
            }
            path {
                d: "M4 12h8",
            }
            path {
                d: "M4 18V6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeading5;
impl IconShape for LdHeading5 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 12h8",
            }
            path {
                d: "M4 18V6",
            }
            path {
                d: "M12 18V6",
            }
            path {
                d: "M17 13v-3h4",
            }
            path {
                d: "M17 17.7c.4.2.8.3 1.3.3 1.5 0 2.7-1.1 2.7-2.5S19.8 13 18.3 13H17",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeading6;
impl IconShape for LdHeading6 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 12h8",
            }
            path {
                d: "M4 18V6",
            }
            path {
                d: "M12 18V6",
            }
            circle {
                cx: "19",
                cy: "16",
                r: "2",
            }
            path {
                d: "M20 10c-2 2-3 3.5-3 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeading;
impl IconShape for LdHeading {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 12h12",
            }
            path {
                d: "M6 20V4",
            }
            path {
                d: "M18 20V4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeadphoneOff;
impl IconShape for LdHeadphoneOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 14h-1.343",
            }
            path {
                d: "M9.128 3.47A9 9 0 0 1 21 12v3.343",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M20.414 20.414A2 2 0 0 1 19 21h-1a2 2 0 0 1-2-2v-3",
            }
            path {
                d: "M3 14h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-7a9 9 0 0 1 2.636-6.364",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeadphones;
impl IconShape for LdHeadphones {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 14h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-7a9 9 0 0 1 18 0v7a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeadset;
impl IconShape for LdHeadset {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 11h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-5Zm0 0a9 9 0 1 1 18 0m0 0v5a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3Z",
            }
            path {
                d: "M21 16v2a4 4 0 0 1-4 4h-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeartCrack;
impl IconShape for LdHeartCrack {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.409 5.824c-.702.792-1.15 1.496-1.415 2.166l2.153 2.156a.5.5 0 0 1 0 .707l-2.293 2.293a.5.5 0 0 0 0 .707L12 15",
            }
            path {
                d: "M13.508 20.313a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5a5.5 5.5 0 0 1 9.591-3.677.6.6 0 0 0 .818.001A5.5 5.5 0 0 1 22 9.5c0 2.29-1.5 4-3 5.5z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeartHandshake;
impl IconShape for LdHeartHandshake {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19.414 14.414C21 12.828 22 11.5 22 9.5a5.5 5.5 0 0 0-9.591-3.676.6.6 0 0 1-.818.001A5.5 5.5 0 0 0 2 9.5c0 2.3 1.5 4 3 5.5l5.535 5.362a2 2 0 0 0 2.879.052 2.12 2.12 0 0 0-.004-3 2.124 2.124 0 1 0 3-3 2.124 2.124 0 0 0 3.004 0 2 2 0 0 0 0-2.828l-1.881-1.882a2.41 2.41 0 0 0-3.409 0l-1.71 1.71a2 2 0 0 1-2.828 0 2 2 0 0 1 0-2.828l2.823-2.762",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeartMinus;
impl IconShape for LdHeartMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14.876 18.99-1.368 1.323a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5a5.5 5.5 0 0 1 9.591-3.676.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5a5.2 5.2 0 0 1-.244 1.572",
            }
            path {
                d: "M15 15h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeartOff;
impl IconShape for LdHeartOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.5 4.893a5.5 5.5 0 0 1 1.091.931.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5c0 1.872-1.002 3.356-2.187 4.655",
            }
            path {
                d: "m16.967 16.967-3.459 3.346a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5a5.5 5.5 0 0 1 2.747-4.761",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeartPlus;
impl IconShape for LdHeartPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14.479 19.374-.971.939a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5a5.5 5.5 0 0 1 9.591-3.676.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5a5.2 5.2 0 0 1-.219 1.49",
            }
            path {
                d: "M15 15h6",
            }
            path {
                d: "M18 12v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeartPulse;
impl IconShape for LdHeartPulse {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9.5a5.5 5.5 0 0 1 9.591-3.676.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5c0 2.29-1.5 4-3 5.5l-5.492 5.313a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5",
            }
            path {
                d: "M3.22 13H9.5l.5-1 2 4.5 2-7 1.5 3.5h5.27",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeart;
impl IconShape for LdHeart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9.5a5.5 5.5 0 0 1 9.591-3.676.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5c0 2.29-1.5 4-3 5.5l-5.492 5.313a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHeater;
impl IconShape for LdHeater {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 8c2-3-2-3 0-6",
            }
            path {
                d: "M15.5 8c2-3-2-3 0-6",
            }
            path {
                d: "M6 10h.01",
            }
            path {
                d: "M6 14h.01",
            }
            path {
                d: "M10 16v-4",
            }
            path {
                d: "M14 16v-4",
            }
            path {
                d: "M18 16v-4",
            }
            path {
                d: "M20 6a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3",
            }
            path {
                d: "M5 20v2",
            }
            path {
                d: "M19 20v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHelicopter;
impl IconShape for LdHelicopter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 17v4",
            }
            path {
                d: "M14 3v8a2 2 0 0 0 2 2h5.865",
            }
            path {
                d: "M17 17v4",
            }
            path {
                d: "M18 17a4 4 0 0 0 4-4 8 6 0 0 0-8-6 6 5 0 0 0-6 5v3a2 2 0 0 0 2 2z",
            }
            path {
                d: "M2 10v5",
            }
            path {
                d: "M6 3h16",
            }
            path {
                d: "M7 21h14",
            }
            path {
                d: "M8 13H2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHexagon;
impl IconShape for LdHexagon {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHighlighter;
impl IconShape for LdHighlighter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m9 11-6 6v3h9l3-3",
            }
            path {
                d: "m22 12-4.6 4.6a2 2 0 0 1-2.8 0l-5.2-5.2a2 2 0 0 1 0-2.8L14 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHistory;
impl IconShape for LdHistory {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8",
            }
            path {
                d: "M3 3v5h5",
            }
            path {
                d: "M12 7v5l4 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHopOff;
impl IconShape for LdHopOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.82 16.12c1.69.6 3.91.79 5.18.85.28.01.53-.09.7-.27",
            }
            path {
                d: "M11.14 20.57c.52.24 2.44 1.12 4.08 1.37.46.06.86-.25.9-.71.12-1.52-.3-3.43-.5-4.28",
            }
            path {
                d: "M16.13 21.05c1.65.63 3.68.84 4.87.91a.9.9 0 0 0 .7-.26",
            }
            path {
                d: "M17.99 5.52a20.83 20.83 0 0 1 3.15 4.5.8.8 0 0 1-.68 1.13c-1.17.1-2.5.02-3.9-.25",
            }
            path {
                d: "M20.57 11.14c.24.52 1.12 2.44 1.37 4.08.04.3-.08.59-.31.75",
            }
            path {
                d: "M4.93 4.93a10 10 0 0 0-.67 13.4c.35.43.96.4 1.17-.12.69-1.71 1.07-5.07 1.07-6.71 1.34.45 3.1.9 4.88.62a.85.85 0 0 0 .48-.24",
            }
            path {
                d: "M5.52 17.99c1.05.95 2.91 2.42 4.5 3.15a.8.8 0 0 0 1.13-.68c.2-2.34-.33-5.3-1.57-8.28",
            }
            path {
                d: "M8.35 2.68a10 10 0 0 1 9.98 1.58c.43.35.4.96-.12 1.17-1.5.6-4.3.98-6.07 1.05",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHop;
impl IconShape for LdHop {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.82 16.12c1.69.6 3.91.79 5.18.85.55.03 1-.42.97-.97-.06-1.27-.26-3.5-.85-5.18",
            }
            path {
                d: "M11.5 6.5c1.64 0 5-.38 6.71-1.07.52-.2.55-.82.12-1.17A10 10 0 0 0 4.26 18.33c.35.43.96.4 1.17-.12.69-1.71 1.07-5.07 1.07-6.71 1.34.45 3.1.9 4.88.62a.88.88 0 0 0 .73-.74c.3-2.14-.15-3.5-.61-4.88",
            }
            path {
                d: "M15.62 16.95c.2.85.62 2.76.5 4.28a.77.77 0 0 1-.9.7 16.64 16.64 0 0 1-4.08-1.36",
            }
            path {
                d: "M16.13 21.05c1.65.63 3.68.84 4.87.91a.9.9 0 0 0 .96-.96 17.68 17.68 0 0 0-.9-4.87",
            }
            path {
                d: "M16.94 15.62c.86.2 2.77.62 4.29.5a.77.77 0 0 0 .7-.9 16.64 16.64 0 0 0-1.36-4.08",
            }
            path {
                d: "M17.99 5.52a20.82 20.82 0 0 1 3.15 4.5.8.8 0 0 1-.68 1.13c-2.33.2-5.3-.32-8.27-1.57",
            }
            path {
                d: "M4.93 4.93 3 3a.7.7 0 0 1 0-1",
            }
            path {
                d: "M9.58 12.18c1.24 2.98 1.77 5.95 1.57 8.28a.8.8 0 0 1-1.13.68 20.82 20.82 0 0 1-4.5-3.15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHospital;
impl IconShape for LdHospital {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 7v4",
            }
            path {
                d: "M14 21v-3a2 2 0 0 0-4 0v3",
            }
            path {
                d: "M14 9h-4",
            }
            path {
                d: "M18 11h2a2 2 0 0 1 2 2v6a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-9a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M18 21V5a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHotel;
impl IconShape for LdHotel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 22v-6.57",
            }
            path {
                d: "M12 11h.01",
            }
            path {
                d: "M12 7h.01",
            }
            path {
                d: "M14 15.43V22",
            }
            path {
                d: "M15 16a5 5 0 0 0-6 0",
            }
            path {
                d: "M16 11h.01",
            }
            path {
                d: "M16 7h.01",
            }
            path {
                d: "M8 11h.01",
            }
            path {
                d: "M8 7h.01",
            }
            rect {
                height: "20",
                rx: "2",
                width: "16",
                x: "4",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHourglass;
impl IconShape for LdHourglass {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 22h14",
            }
            path {
                d: "M5 2h14",
            }
            path {
                d: "M17 22v-4.172a2 2 0 0 0-.586-1.414L12 12l-4.414 4.414A2 2 0 0 0 7 17.828V22",
            }
            path {
                d: "M7 2v4.172a2 2 0 0 0 .586 1.414L12 12l4.414-4.414A2 2 0 0 0 17 6.172V2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHouseHeart;
impl IconShape for LdHouseHeart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8.62 13.8A2.25 2.25 0 1 1 12 10.836a2.25 2.25 0 1 1 3.38 2.966l-2.626 2.856a.998.998 0 0 1-1.507 0z",
            }
            path {
                d: "M3 10a2 2 0 0 1 .709-1.528l7-6a2 2 0 0 1 2.582 0l7 6A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHousePlug;
impl IconShape for LdHousePlug {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 12V8.964",
            }
            path {
                d: "M14 12V8.964",
            }
            path {
                d: "M15 12a1 1 0 0 1 1 1v2a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2v-2a1 1 0 0 1 1-1z",
            }
            path {
                d: "M8.5 21H5a2 2 0 0 1-2-2v-9a2 2 0 0 1 .709-1.528l7-6a2 2 0 0 1 2.582 0l7 6A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2h-5a2 2 0 0 1-2-2v-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHousePlus;
impl IconShape for LdHousePlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.35 21H5a2 2 0 0 1-2-2v-9a2 2 0 0 1 .71-1.53l7-6a2 2 0 0 1 2.58 0l7 6A2 2 0 0 1 21 10v2.35",
            }
            path {
                d: "M14.8 12.4A1 1 0 0 0 14 12h-4a1 1 0 0 0-1 1v8",
            }
            path {
                d: "M15 18h6",
            }
            path {
                d: "M18 15v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHouseWifi;
impl IconShape for LdHouseWifi {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9.5 13.866a4 4 0 0 1 5 .01",
            }
            path {
                d: "M12 17h.01",
            }
            path {
                d: "M3 10a2 2 0 0 1 .709-1.528l7-6a2 2 0 0 1 2.582 0l7 6A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z",
            }
            path {
                d: "M7 10.754a8 8 0 0 1 10 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdHouse;
impl IconShape for LdHouse {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 21v-8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v8",
            }
            path {
                d: "M3 10a2 2 0 0 1 .709-1.528l7-6a2 2 0 0 1 2.582 0l7 6A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdIceCreamBowl;
impl IconShape for LdIceCreamBowl {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 17c5 0 8-2.69 8-6H4c0 3.31 3 6 8 6m-4 4h8m-4-3v3M5.14 11a3.5 3.5 0 1 1 6.71 0",
            }
            path {
                d: "M12.14 11a3.5 3.5 0 1 1 6.71 0",
            }
            path {
                d: "M15.5 6.5a3.5 3.5 0 1 0-7 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdIceCreamCone;
impl IconShape for LdIceCreamCone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m7 11 4.08 10.35a1 1 0 0 0 1.84 0L17 11",
            }
            path {
                d: "M17 7A5 5 0 0 0 7 7",
            }
            path {
                d: "M17 7a2 2 0 0 1 0 4H7a2 2 0 0 1 0-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdIdCardLanyard;
impl IconShape for LdIdCardLanyard {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.5 8h-3",
            }
            path {
                d: "m15 2-1 2h3a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h3",
            }
            path {
                d: "M16.899 22A5 5 0 0 0 7.1 22",
            }
            path {
                d: "m9 2 3 6",
            }
            circle {
                cx: "12",
                cy: "15",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdIdCard;
impl IconShape for LdIdCard {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 10h2",
            }
            path {
                d: "M16 14h2",
            }
            path {
                d: "M6.17 15a3 3 0 0 1 5.66 0",
            }
            circle {
                cx: "9",
                cy: "11",
                r: "2",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdImageDown;
impl IconShape for LdImageDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.3 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v10l-3.1-3.1a2 2 0 0 0-2.814.014L6 21",
            }
            path {
                d: "m14 19 3 3v-5.5",
            }
            path {
                d: "m17 22 3-3",
            }
            circle {
                cx: "9",
                cy: "9",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdImageMinus;
impl IconShape for LdImageMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 9v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7",
            }
            line {
                x1: "16",
                x2: "22",
                y1: "5",
                y2: "5",
            }
            circle {
                cx: "9",
                cy: "9",
                r: "2",
            }
            path {
                d: "m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdImageOff;
impl IconShape for LdImageOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
            path {
                d: "M10.41 10.41a2 2 0 1 1-2.83-2.83",
            }
            line {
                x1: "13.5",
                x2: "6",
                y1: "13.5",
                y2: "21",
            }
            line {
                x1: "18",
                x2: "21",
                y1: "12",
                y2: "15",
            }
            path {
                d: "M3.59 3.59A1.99 1.99 0 0 0 3 5v14a2 2 0 0 0 2 2h14c.55 0 1.052-.22 1.41-.59",
            }
            path {
                d: "M21 15V5a2 2 0 0 0-2-2H9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdImagePlay;
impl IconShape for LdImagePlay {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 15.003a1 1 0 0 1 1.517-.859l4.997 2.997a1 1 0 0 1 0 1.718l-4.997 2.997a1 1 0 0 1-1.517-.86z",
            }
            path {
                d: "M21 12.17V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6",
            }
            path {
                d: "m6 21 5-5",
            }
            circle {
                cx: "9",
                cy: "9",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdImagePlus;
impl IconShape for LdImagePlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 5h6",
            }
            path {
                d: "M19 2v6",
            }
            path {
                d: "M21 11.5V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7.5",
            }
            path {
                d: "m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21",
            }
            circle {
                cx: "9",
                cy: "9",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdImageUp;
impl IconShape for LdImageUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.3 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v10l-3.1-3.1a2 2 0 0 0-2.814.014L6 21",
            }
            path {
                d: "m14 19.5 3-3 3 3",
            }
            path {
                d: "M17 22v-5.5",
            }
            circle {
                cx: "9",
                cy: "9",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdImageUpscale;
impl IconShape for LdImageUpscale {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 3h5v5",
            }
            path {
                d: "M17 21h2a2 2 0 0 0 2-2",
            }
            path {
                d: "M21 12v3",
            }
            path {
                d: "m21 3-5 5",
            }
            path {
                d: "M3 7V5a2 2 0 0 1 2-2",
            }
            path {
                d: "m5 21 4.144-4.144a1.21 1.21 0 0 1 1.712 0L13 19",
            }
            path {
                d: "M9 3h3",
            }
            rect {
                height: "10",
                rx: "1",
                width: "10",
                x: "3",
                y: "11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdImage;
impl IconShape for LdImage {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            circle {
                cx: "9",
                cy: "9",
                r: "2",
            }
            path {
                d: "m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdImages;
impl IconShape for LdImages {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m22 11-1.296-1.296a2.4 2.4 0 0 0-3.408 0L11 16",
            }
            path {
                d: "M4 8a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2",
            }
            circle {
                cx: "13",
                cy: "7",
                r: "1",
            }
            rect {
                height: "14",
                rx: "2",
                width: "14",
                x: "8",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdImport;
impl IconShape for LdImport {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v12",
            }
            path {
                d: "m8 11 4 4 4-4",
            }
            path {
                d: "M8 5H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdInbox;
impl IconShape for LdInbox {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            polyline {
                points: "22 12 16 12 14 15 10 15 8 12 2 12",
            }
            path {
                d: "M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdIndianRupee;
impl IconShape for LdIndianRupee {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 3h12",
            }
            path {
                d: "M6 8h12",
            }
            path {
                d: "m6 13 8.5 8",
            }
            path {
                d: "M6 13h3",
            }
            path {
                d: "M9 13c6.667 0 6.667-10 0-10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdInfinity;
impl IconShape for LdInfinity {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 16c5 0 7-8 12-8a4 4 0 0 1 0 8c-5 0-7-8-12-8a4 4 0 1 0 0 8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdInfo;
impl IconShape for LdInfo {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M12 16v-4",
            }
            path {
                d: "M12 8h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdInspectionPanel;
impl IconShape for LdInspectionPanel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M7 7h.01",
            }
            path {
                d: "M17 7h.01",
            }
            path {
                d: "M7 17h.01",
            }
            path {
                d: "M17 17h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdInstagram;
impl IconShape for LdInstagram {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "5",
                ry: "5",
                width: "20",
                x: "2",
                y: "2",
            }
            path {
                d: "M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z",
            }
            line {
                x1: "17.5",
                x2: "17.51",
                y1: "6.5",
                y2: "6.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdItalic;
impl IconShape for LdItalic {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "19",
                x2: "10",
                y1: "4",
                y2: "4",
            }
            line {
                x1: "14",
                x2: "5",
                y1: "20",
                y2: "20",
            }
            line {
                x1: "15",
                x2: "9",
                y1: "4",
                y2: "20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdIterationCcw;
impl IconShape for LdIterationCcw {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 14 4 4-4 4",
            }
            path {
                d: "M20 10a8 8 0 1 0-8 8h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdIterationCw;
impl IconShape for LdIterationCw {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 10a8 8 0 1 1 8 8H4",
            }
            path {
                d: "m8 22-4-4 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdJapaneseYen;
impl IconShape for LdJapaneseYen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 9.5V21m0-11.5L6 3m6 6.5L18 3",
            }
            path {
                d: "M6 15h12",
            }
            path {
                d: "M6 11h12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdJoystick;
impl IconShape for LdJoystick {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 17a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-2Z",
            }
            path {
                d: "M6 15v-2",
            }
            path {
                d: "M12 15V9",
            }
            circle {
                cx: "12",
                cy: "6",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdKanban;
impl IconShape for LdKanban {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 3v14",
            }
            path {
                d: "M12 3v8",
            }
            path {
                d: "M19 3v18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdKayak;
impl IconShape for LdKayak {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 17a1 1 0 0 0-1 1v1a2 2 0 1 0 2-2z",
            }
            path {
                d: "M20.97 3.61a.45.45 0 0 0-.58-.58C10.2 6.6 6.6 10.2 3.03 20.39a.45.45 0 0 0 .58.58C13.8 17.4 17.4 13.8 20.97 3.61",
            }
            path {
                d: "m6.707 6.707 10.586 10.586",
            }
            path {
                d: "M7 5a2 2 0 1 0-2 2h1a1 1 0 0 0 1-1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdKeyRound;
impl IconShape for LdKeyRound {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.586 17.414A2 2 0 0 0 2 18.828V21a1 1 0 0 0 1 1h3a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h1a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h.172a2 2 0 0 0 1.414-.586l.814-.814a6.5 6.5 0 1 0-4-4z",
            }
            circle {
                cx: "16.5",
                cy: "7.5",
                r: ".5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdKeySquare;
impl IconShape for LdKeySquare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.4 2.7a2.5 2.5 0 0 1 3.4 0l5.5 5.5a2.5 2.5 0 0 1 0 3.4l-3.7 3.7a2.5 2.5 0 0 1-3.4 0L8.7 9.8a2.5 2.5 0 0 1 0-3.4z",
            }
            path {
                d: "m14 7 3 3",
            }
            path {
                d: "m9.4 10.6-6.814 6.814A2 2 0 0 0 2 18.828V21a1 1 0 0 0 1 1h3a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h1a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h.172a2 2 0 0 0 1.414-.586l.814-.814",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdKey;
impl IconShape for LdKey {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15.5 7.5 2.3 2.3a1 1 0 0 0 1.4 0l2.1-2.1a1 1 0 0 0 0-1.4L19 4",
            }
            path {
                d: "m21 2-9.6 9.6",
            }
            circle {
                cx: "7.5",
                cy: "15.5",
                r: "5.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdKeyboardMusic;
impl IconShape for LdKeyboardMusic {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
            path {
                d: "M6 8h4",
            }
            path {
                d: "M14 8h.01",
            }
            path {
                d: "M18 8h.01",
            }
            path {
                d: "M2 12h20",
            }
            path {
                d: "M6 12v4",
            }
            path {
                d: "M10 12v4",
            }
            path {
                d: "M14 12v4",
            }
            path {
                d: "M18 12v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdKeyboardOff;
impl IconShape for LdKeyboardOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M 20 4 A2 2 0 0 1 22 6",
            }
            path {
                d: "M 22 6 L 22 16.41",
            }
            path {
                d: "M 7 16 L 16 16",
            }
            path {
                d: "M 9.69 4 L 20 4",
            }
            path {
                d: "M14 8h.01",
            }
            path {
                d: "M18 8h.01",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M20 20H4a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2",
            }
            path {
                d: "M6 8h.01",
            }
            path {
                d: "M8 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdKeyboard;
impl IconShape for LdKeyboard {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 8h.01",
            }
            path {
                d: "M12 12h.01",
            }
            path {
                d: "M14 8h.01",
            }
            path {
                d: "M16 12h.01",
            }
            path {
                d: "M18 8h.01",
            }
            path {
                d: "M6 8h.01",
            }
            path {
                d: "M7 16h10",
            }
            path {
                d: "M8 12h.01",
            }
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLampCeiling;
impl IconShape for LdLampCeiling {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v5",
            }
            path {
                d: "M14.829 15.998a3 3 0 1 1-5.658 0",
            }
            path {
                d: "M20.92 14.606A1 1 0 0 1 20 16H4a1 1 0 0 1-.92-1.394l3-7A1 1 0 0 1 7 7h10a1 1 0 0 1 .92.606z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLampDesk;
impl IconShape for LdLampDesk {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.293 2.293a1 1 0 0 1 1.414 0l2.5 2.5 5.994 1.227a1 1 0 0 1 .506 1.687l-7 7a1 1 0 0 1-1.687-.506l-1.227-5.994-2.5-2.5a1 1 0 0 1 0-1.414z",
            }
            path {
                d: "m14.207 4.793-3.414 3.414",
            }
            path {
                d: "M3 20a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1z",
            }
            path {
                d: "m9.086 6.5-4.793 4.793a1 1 0 0 0-.18 1.17L7 18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLampFloor;
impl IconShape for LdLampFloor {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 10v12",
            }
            path {
                d: "M17.929 7.629A1 1 0 0 1 17 9H7a1 1 0 0 1-.928-1.371l2-5A1 1 0 0 1 9 2h6a1 1 0 0 1 .928.629z",
            }
            path {
                d: "M9 22h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLampWallDown;
impl IconShape for LdLampWallDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19.929 18.629A1 1 0 0 1 19 20H9a1 1 0 0 1-.928-1.371l2-5A1 1 0 0 1 11 13h6a1 1 0 0 1 .928.629z",
            }
            path {
                d: "M6 3a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2H5a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1z",
            }
            path {
                d: "M8 6h4a2 2 0 0 1 2 2v5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLampWallUp;
impl IconShape for LdLampWallUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19.929 9.629A1 1 0 0 1 19 11H9a1 1 0 0 1-.928-1.371l2-5A1 1 0 0 1 11 4h6a1 1 0 0 1 .928.629z",
            }
            path {
                d: "M6 15a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2H5a1 1 0 0 1-1-1v-4a1 1 0 0 1 1-1z",
            }
            path {
                d: "M8 18h4a2 2 0 0 0 2-2v-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLamp;
impl IconShape for LdLamp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 12v6",
            }
            path {
                d: "M4.077 10.615A1 1 0 0 0 5 12h14a1 1 0 0 0 .923-1.385l-3.077-7.384A2 2 0 0 0 15 2H9a2 2 0 0 0-1.846 1.23Z",
            }
            path {
                d: "M8 20a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1H9a1 1 0 0 1-1-1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLandPlot;
impl IconShape for LdLandPlot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12 8 6-3-6-3v10",
            }
            path {
                d: "m8 11.99-5.5 3.14a1 1 0 0 0 0 1.74l8.5 4.86a2 2 0 0 0 2 0l8.5-4.86a1 1 0 0 0 0-1.74L16 12",
            }
            path {
                d: "m6.49 12.85 11.02 6.3",
            }
            path {
                d: "M17.51 12.85 6.5 19.15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLandmark;
impl IconShape for LdLandmark {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 18v-7",
            }
            path {
                d: "M11.12 2.198a2 2 0 0 1 1.76.006l7.866 3.847c.476.233.31.949-.22.949H3.474c-.53 0-.695-.716-.22-.949z",
            }
            path {
                d: "M14 18v-7",
            }
            path {
                d: "M18 18v-7",
            }
            path {
                d: "M3 22h18",
            }
            path {
                d: "M6 18v-7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLanguages;
impl IconShape for LdLanguages {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m5 8 6 6",
            }
            path {
                d: "m4 14 6-6 2-3",
            }
            path {
                d: "M2 5h12",
            }
            path {
                d: "M7 2h1",
            }
            path {
                d: "m22 22-5-10-5 10",
            }
            path {
                d: "M14 18h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLaptopMinimalCheck;
impl IconShape for LdLaptopMinimalCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 20h20",
            }
            path {
                d: "m9 10 2 2 4-4",
            }
            rect {
                height: "12",
                rx: "2",
                width: "18",
                x: "3",
                y: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLaptopMinimal;
impl IconShape for LdLaptopMinimal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "12",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "4",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "20",
                y2: "20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLaptop;
impl IconShape for LdLaptop {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 5a2 2 0 0 1 2 2v8.526a2 2 0 0 0 .212.897l1.068 2.127a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45l1.068-2.127A2 2 0 0 0 4 15.526V7a2 2 0 0 1 2-2z",
            }
            path {
                d: "M20.054 15.987H3.946",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLassoSelect;
impl IconShape for LdLassoSelect {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 22a5 5 0 0 1-2-4",
            }
            path {
                d: "M7 16.93c.96.43 1.96.74 2.99.91",
            }
            path {
                d: "M3.34 14A6.8 6.8 0 0 1 2 10c0-4.42 4.48-8 10-8s10 3.58 10 8a7.19 7.19 0 0 1-.33 2",
            }
            path {
                d: "M5 18a2 2 0 1 0 0-4 2 2 0 0 0 0 4z",
            }
            path {
                d: "M14.33 22h-.09a.35.35 0 0 1-.24-.32v-10a.34.34 0 0 1 .33-.34c.08 0 .15.03.21.08l7.34 6a.33.33 0 0 1-.21.59h-4.49l-2.57 3.85a.35.35 0 0 1-.28.14z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLasso;
impl IconShape for LdLasso {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.704 14.467A10 8 0 0 1 2 10a10 8 0 0 1 20 0 10 8 0 0 1-10 8 10 8 0 0 1-5.181-1.158",
            }
            path {
                d: "M7 22a5 5 0 0 1-2-3.994",
            }
            circle {
                cx: "5",
                cy: "16",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLaugh;
impl IconShape for LdLaugh {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M18 13a6 6 0 0 1-6 5 6 6 0 0 1-6-5h12Z",
            }
            line {
                x1: "9",
                x2: "9.01",
                y1: "9",
                y2: "9",
            }
            line {
                x1: "15",
                x2: "15.01",
                y1: "9",
                y2: "9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLayers2;
impl IconShape for LdLayers2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 13.74a2 2 0 0 1-2 0L2.5 8.87a1 1 0 0 1 0-1.74L11 2.26a2 2 0 0 1 2 0l8.5 4.87a1 1 0 0 1 0 1.74z",
            }
            path {
                d: "m20 14.285 1.5.845a1 1 0 0 1 0 1.74L13 21.74a2 2 0 0 1-2 0l-8.5-4.87a1 1 0 0 1 0-1.74l1.5-.845",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLayers;
impl IconShape for LdLayers {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83z",
            }
            path {
                d: "M2 12a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 12",
            }
            path {
                d: "M2 17a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 17",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLayoutDashboard;
impl IconShape for LdLayoutDashboard {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "9",
                rx: "1",
                width: "7",
                x: "3",
                y: "3",
            }
            rect {
                height: "5",
                rx: "1",
                width: "7",
                x: "14",
                y: "3",
            }
            rect {
                height: "9",
                rx: "1",
                width: "7",
                x: "14",
                y: "12",
            }
            rect {
                height: "5",
                rx: "1",
                width: "7",
                x: "3",
                y: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLayoutGrid;
impl IconShape for LdLayoutGrid {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "3",
                y: "3",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "14",
                y: "3",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "14",
                y: "14",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "3",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLayoutList;
impl IconShape for LdLayoutList {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "3",
                y: "3",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "3",
                y: "14",
            }
            path {
                d: "M14 4h7",
            }
            path {
                d: "M14 9h7",
            }
            path {
                d: "M14 15h7",
            }
            path {
                d: "M14 20h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLayoutPanelLeft;
impl IconShape for LdLayoutPanelLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "1",
                width: "7",
                x: "3",
                y: "3",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "14",
                y: "3",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "14",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLayoutPanelTop;
impl IconShape for LdLayoutPanelTop {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "7",
                rx: "1",
                width: "18",
                x: "3",
                y: "3",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "3",
                y: "14",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "14",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLayoutTemplate;
impl IconShape for LdLayoutTemplate {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "7",
                rx: "1",
                width: "18",
                x: "3",
                y: "3",
            }
            rect {
                height: "7",
                rx: "1",
                width: "9",
                x: "3",
                y: "14",
            }
            rect {
                height: "7",
                rx: "1",
                width: "5",
                x: "16",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLeaf;
impl IconShape for LdLeaf {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 20A7 7 0 0 1 9.8 6.1C15.5 5 17 4.48 19 2c1 2 2 4.18 2 8 0 5.5-4.78 10-10 10Z",
            }
            path {
                d: "M2 21c0-3 1.85-5.36 5.08-6C9.5 14.52 12 13 13 12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLeafyGreen;
impl IconShape for LdLeafyGreen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 22c1.25-.987 2.27-1.975 3.9-2.2a5.56 5.56 0 0 1 3.8 1.5 4 4 0 0 0 6.187-2.353 3.5 3.5 0 0 0 3.69-5.116A3.5 3.5 0 0 0 20.95 8 3.5 3.5 0 1 0 16 3.05a3.5 3.5 0 0 0-5.831 1.373 3.5 3.5 0 0 0-5.116 3.69 4 4 0 0 0-2.348 6.155C3.499 15.42 4.409 16.712 4.2 18.1 3.926 19.743 3.014 20.732 2 22",
            }
            path {
                d: "M2 22 17 7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLectern;
impl IconShape for LdLectern {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 12h3a2 2 0 0 0 1.902-1.38l1.056-3.333A1 1 0 0 0 21 6H3a1 1 0 0 0-.958 1.287l1.056 3.334A2 2 0 0 0 5 12h3",
            }
            path {
                d: "M18 6V3a1 1 0 0 0-1-1h-3",
            }
            rect {
                height: "12",
                rx: "1",
                width: "8",
                x: "8",
                y: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLibraryBig;
impl IconShape for LdLibraryBig {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "1",
                width: "8",
                x: "3",
                y: "3",
            }
            path {
                d: "M7 3v18",
            }
            path {
                d: "M20.4 18.9c.2.5-.1 1.1-.6 1.3l-1.9.7c-.5.2-1.1-.1-1.3-.6L11.1 5.1c-.2-.5.1-1.1.6-1.3l1.9-.7c.5-.2 1.1.1 1.3.6Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLibrary;
impl IconShape for LdLibrary {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 6 4 14",
            }
            path {
                d: "M12 6v14",
            }
            path {
                d: "M8 8v12",
            }
            path {
                d: "M4 4v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLifeBuoy;
impl IconShape for LdLifeBuoy {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "m4.93 4.93 4.24 4.24",
            }
            path {
                d: "m14.83 9.17 4.24-4.24",
            }
            path {
                d: "m14.83 14.83 4.24 4.24",
            }
            path {
                d: "m9.17 14.83-4.24 4.24",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLigature;
impl IconShape for LdLigature {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 12h2v8",
            }
            path {
                d: "M14 20h4",
            }
            path {
                d: "M6 12h4",
            }
            path {
                d: "M6 20h4",
            }
            path {
                d: "M8 20V8a4 4 0 0 1 7.464-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLightbulbOff;
impl IconShape for LdLightbulbOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16.8 11.2c.8-.9 1.2-2 1.2-3.2a6 6 0 0 0-9.3-5",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M6.3 6.3a4.67 4.67 0 0 0 1.2 5.2c.7.7 1.3 1.5 1.5 2.5",
            }
            path {
                d: "M9 18h6",
            }
            path {
                d: "M10 22h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLightbulb;
impl IconShape for LdLightbulb {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 14c.2-1 .7-1.7 1.5-2.5 1-.9 1.5-2.2 1.5-3.5A6 6 0 0 0 6 8c0 1 .2 2.2 1.5 3.5.7.7 1.3 1.5 1.5 2.5",
            }
            path {
                d: "M9 18h6",
            }
            path {
                d: "M10 22h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLineSquiggle;
impl IconShape for LdLineSquiggle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 3.5c5-2 7 2.5 3 4C1.5 10 2 15 5 16c5 2 9-10 14-7s.5 13.5-4 12c-5-2.5.5-11 6-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLink2Off;
impl IconShape for LdLink2Off {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 17H7A5 5 0 0 1 7 7",
            }
            path {
                d: "M15 7h2a5 5 0 0 1 4 8",
            }
            line {
                x1: "8",
                x2: "12",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLink2;
impl IconShape for LdLink2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 17H7A5 5 0 0 1 7 7h2",
            }
            path {
                d: "M15 7h2a5 5 0 1 1 0 10h-2",
            }
            line {
                x1: "8",
                x2: "16",
                y1: "12",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLink;
impl IconShape for LdLink {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71",
            }
            path {
                d: "M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLinkedin;
impl IconShape for LdLinkedin {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 8a6 6 0 0 1 6 6v7h-4v-7a2 2 0 0 0-2-2 2 2 0 0 0-2 2v7h-4v-7a6 6 0 0 1 6-6z",
            }
            rect {
                height: "12",
                width: "4",
                x: "2",
                y: "9",
            }
            circle {
                cx: "4",
                cy: "4",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListCheck;
impl IconShape for LdListCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 5H3",
            }
            path {
                d: "M16 12H3",
            }
            path {
                d: "M11 19H3",
            }
            path {
                d: "m15 18 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListChecks;
impl IconShape for LdListChecks {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 5h8",
            }
            path {
                d: "M13 12h8",
            }
            path {
                d: "M13 19h8",
            }
            path {
                d: "m3 17 2 2 4-4",
            }
            path {
                d: "m3 7 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListChevronsDownUp;
impl IconShape for LdListChevronsDownUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 5h8",
            }
            path {
                d: "M3 12h8",
            }
            path {
                d: "M3 19h8",
            }
            path {
                d: "m15 5 3 3 3-3",
            }
            path {
                d: "m15 19 3-3 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListChevronsUpDown;
impl IconShape for LdListChevronsUpDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 5h8",
            }
            path {
                d: "M3 12h8",
            }
            path {
                d: "M3 19h8",
            }
            path {
                d: "m15 8 3-3 3 3",
            }
            path {
                d: "m15 16 3 3 3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListCollapse;
impl IconShape for LdListCollapse {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 5h11",
            }
            path {
                d: "M10 12h11",
            }
            path {
                d: "M10 19h11",
            }
            path {
                d: "m3 10 3-3-3-3",
            }
            path {
                d: "m3 20 3-3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListEnd;
impl IconShape for LdListEnd {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 5H3",
            }
            path {
                d: "M16 12H3",
            }
            path {
                d: "M9 19H3",
            }
            path {
                d: "m16 16-3 3 3 3",
            }
            path {
                d: "M21 5v12a2 2 0 0 1-2 2h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListFilterPlus;
impl IconShape for LdListFilterPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 5H2",
            }
            path {
                d: "M6 12h12",
            }
            path {
                d: "M9 19h6",
            }
            path {
                d: "M16 5h6",
            }
            path {
                d: "M19 8V2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListFilter;
impl IconShape for LdListFilter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 5h20",
            }
            path {
                d: "M6 12h12",
            }
            path {
                d: "M9 19h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListIndentDecrease;
impl IconShape for LdListIndentDecrease {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 5H11",
            }
            path {
                d: "M21 12H11",
            }
            path {
                d: "M21 19H11",
            }
            path {
                d: "m7 8-4 4 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListIndentIncrease;
impl IconShape for LdListIndentIncrease {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 5H11",
            }
            path {
                d: "M21 12H11",
            }
            path {
                d: "M21 19H11",
            }
            path {
                d: "m3 8 4 4-4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListMinus;
impl IconShape for LdListMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 5H3",
            }
            path {
                d: "M11 12H3",
            }
            path {
                d: "M16 19H3",
            }
            path {
                d: "M21 12h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListMusic;
impl IconShape for LdListMusic {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 5H3",
            }
            path {
                d: "M11 12H3",
            }
            path {
                d: "M11 19H3",
            }
            path {
                d: "M21 16V5",
            }
            circle {
                cx: "18",
                cy: "16",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListOrdered;
impl IconShape for LdListOrdered {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 5h10",
            }
            path {
                d: "M11 12h10",
            }
            path {
                d: "M11 19h10",
            }
            path {
                d: "M4 4h1v5",
            }
            path {
                d: "M4 9h2",
            }
            path {
                d: "M6.5 20H3.4c0-1 2.6-1.925 2.6-3.5a1.5 1.5 0 0 0-2.6-1.02",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListPlus;
impl IconShape for LdListPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 5H3",
            }
            path {
                d: "M11 12H3",
            }
            path {
                d: "M16 19H3",
            }
            path {
                d: "M18 9v6",
            }
            path {
                d: "M21 12h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListRestart;
impl IconShape for LdListRestart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 5H3",
            }
            path {
                d: "M7 12H3",
            }
            path {
                d: "M7 19H3",
            }
            path {
                d: "M12 18a5 5 0 0 0 9-3 4.5 4.5 0 0 0-4.5-4.5c-1.33 0-2.54.54-3.41 1.41L11 14",
            }
            path {
                d: "M11 10v4h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListStart;
impl IconShape for LdListStart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 5h6",
            }
            path {
                d: "M3 12h13",
            }
            path {
                d: "M3 19h13",
            }
            path {
                d: "m16 8-3-3 3-3",
            }
            path {
                d: "M21 19V7a2 2 0 0 0-2-2h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListTodo;
impl IconShape for LdListTodo {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 5h8",
            }
            path {
                d: "M13 12h8",
            }
            path {
                d: "M13 19h8",
            }
            path {
                d: "m3 17 2 2 4-4",
            }
            rect {
                height: "6",
                rx: "1",
                width: "6",
                x: "3",
                y: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListTree;
impl IconShape for LdListTree {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 5h13",
            }
            path {
                d: "M13 12h8",
            }
            path {
                d: "M13 19h8",
            }
            path {
                d: "M3 10a2 2 0 0 0 2 2h3",
            }
            path {
                d: "M3 5v12a2 2 0 0 0 2 2h3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListVideo;
impl IconShape for LdListVideo {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 5H3",
            }
            path {
                d: "M10 12H3",
            }
            path {
                d: "M10 19H3",
            }
            path {
                d: "M15 12.003a1 1 0 0 1 1.517-.859l4.997 2.997a1 1 0 0 1 0 1.718l-4.997 2.997a1 1 0 0 1-1.517-.86z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdListX;
impl IconShape for LdListX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 5H3",
            }
            path {
                d: "M11 12H3",
            }
            path {
                d: "M16 19H3",
            }
            path {
                d: "m15.5 9.5 5 5",
            }
            path {
                d: "m20.5 9.5-5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdList;
impl IconShape for LdList {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 5h.01",
            }
            path {
                d: "M3 12h.01",
            }
            path {
                d: "M3 19h.01",
            }
            path {
                d: "M8 5h13",
            }
            path {
                d: "M8 12h13",
            }
            path {
                d: "M8 19h13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLoaderCircle;
impl IconShape for LdLoaderCircle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 12a9 9 0 1 1-6.219-8.56",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLoaderPinwheel;
impl IconShape for LdLoaderPinwheel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 12a1 1 0 0 1-10 0 1 1 0 0 0-10 0",
            }
            path {
                d: "M7 20.7a1 1 0 1 1 5-8.7 1 1 0 1 0 5-8.6",
            }
            path {
                d: "M7 3.3a1 1 0 1 1 5 8.6 1 1 0 1 0 5 8.6",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLoader;
impl IconShape for LdLoader {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v4",
            }
            path {
                d: "m16.2 7.8 2.9-2.9",
            }
            path {
                d: "M18 12h4",
            }
            path {
                d: "m16.2 16.2 2.9 2.9",
            }
            path {
                d: "M12 18v4",
            }
            path {
                d: "m4.9 19.1 2.9-2.9",
            }
            path {
                d: "M2 12h4",
            }
            path {
                d: "m4.9 4.9 2.9 2.9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLocateFixed;
impl IconShape for LdLocateFixed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "2",
                x2: "5",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "19",
                x2: "22",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "2",
                y2: "5",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "19",
                y2: "22",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "7",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLocateOff;
impl IconShape for LdLocateOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 19v3",
            }
            path {
                d: "M12 2v3",
            }
            path {
                d: "M18.89 13.24a7 7 0 0 0-8.13-8.13",
            }
            path {
                d: "M19 12h3",
            }
            path {
                d: "M2 12h3",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M7.05 7.05a7 7 0 0 0 9.9 9.9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLocate;
impl IconShape for LdLocate {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "2",
                x2: "5",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "19",
                x2: "22",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "2",
                y2: "5",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "19",
                y2: "22",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLockKeyholeOpen;
impl IconShape for LdLockKeyholeOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "16",
                r: "1",
            }
            rect {
                height: "12",
                rx: "2",
                width: "18",
                x: "3",
                y: "10",
            }
            path {
                d: "M7 10V7a5 5 0 0 1 9.33-2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLockKeyhole;
impl IconShape for LdLockKeyhole {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "16",
                r: "1",
            }
            rect {
                height: "12",
                rx: "2",
                width: "18",
                x: "3",
                y: "10",
            }
            path {
                d: "M7 10V7a5 5 0 0 1 10 0v3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLockOpen;
impl IconShape for LdLockOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "11",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "11",
            }
            path {
                d: "M7 11V7a5 5 0 0 1 9.9-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLock;
impl IconShape for LdLock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "11",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "11",
            }
            path {
                d: "M7 11V7a5 5 0 0 1 10 0v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLogIn;
impl IconShape for LdLogIn {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 17 5-5-5-5",
            }
            path {
                d: "M15 12H3",
            }
            path {
                d: "M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLogOut;
impl IconShape for LdLogOut {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 17 5-5-5-5",
            }
            path {
                d: "M21 12H9",
            }
            path {
                d: "M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLogs;
impl IconShape for LdLogs {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 5h1",
            }
            path {
                d: "M3 12h1",
            }
            path {
                d: "M3 19h1",
            }
            path {
                d: "M8 5h1",
            }
            path {
                d: "M8 12h1",
            }
            path {
                d: "M8 19h1",
            }
            path {
                d: "M13 5h8",
            }
            path {
                d: "M13 12h8",
            }
            path {
                d: "M13 19h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLollipop;
impl IconShape for LdLollipop {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "11",
                cy: "11",
                r: "8",
            }
            path {
                d: "m21 21-4.3-4.3",
            }
            path {
                d: "M11 11a2 2 0 0 0 4 0 4 4 0 0 0-8 0 6 6 0 0 0 12 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdLuggage;
impl IconShape for LdLuggage {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 20a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2",
            }
            path {
                d: "M8 18V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v14",
            }
            path {
                d: "M10 20h4",
            }
            circle {
                cx: "16",
                cy: "20",
                r: "2",
            }
            circle {
                cx: "8",
                cy: "20",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMagnet;
impl IconShape for LdMagnet {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12 15 4 4",
            }
            path {
                d: "M2.352 10.648a1.205 1.205 0 0 0 0 1.704l2.296 2.296a1.205 1.205 0 0 0 1.704 0l6.029-6.029a1 1 0 1 1 3 3l-6.029 6.029a1.205 1.205 0 0 0 0 1.704l2.296 2.296a1.205 1.205 0 0 0 1.704 0l6.365-6.367A1 1 0 0 0 8.716 4.282z",
            }
            path {
                d: "m5 8 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMailCheck;
impl IconShape for LdMailCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8",
            }
            path {
                d: "m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7",
            }
            path {
                d: "m16 19 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMailMinus;
impl IconShape for LdMailMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 15V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8",
            }
            path {
                d: "m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7",
            }
            path {
                d: "M16 19h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMailOpen;
impl IconShape for LdMailOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21.2 8.4c.5.38.8.97.8 1.6v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V10a2 2 0 0 1 .8-1.6l8-6a2 2 0 0 1 2.4 0l8 6Z",
            }
            path {
                d: "m22 10-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMailPlus;
impl IconShape for LdMailPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8",
            }
            path {
                d: "m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7",
            }
            path {
                d: "M19 16v6",
            }
            path {
                d: "M16 19h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMailQuestionMark;
impl IconShape for LdMailQuestionMark {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 10.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h12.5",
            }
            path {
                d: "m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7",
            }
            path {
                d: "M18 15.28c.2-.4.5-.8.9-1a2.1 2.1 0 0 1 2.6.4c.3.4.5.8.5 1.3 0 1.3-2 2-2 2",
            }
            path {
                d: "M20 22v.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMailSearch;
impl IconShape for LdMailSearch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 12.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h7.5",
            }
            path {
                d: "m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7",
            }
            path {
                d: "M18 21a3 3 0 1 0 0-6 3 3 0 0 0 0 6Z",
            }
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
            path {
                d: "m22 22-1.5-1.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMailWarning;
impl IconShape for LdMailWarning {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 10.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h12.5",
            }
            path {
                d: "m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7",
            }
            path {
                d: "M20 14v4",
            }
            path {
                d: "M20 22v.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMailX;
impl IconShape for LdMailX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h9",
            }
            path {
                d: "m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7",
            }
            path {
                d: "m17 17 4 4",
            }
            path {
                d: "m21 17-4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMail;
impl IconShape for LdMail {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m22 7-8.991 5.727a2 2 0 0 1-2.009 0L2 7",
            }
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMailbox;
impl IconShape for LdMailbox {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9.5C2 7 4 5 6.5 5H18c2.2 0 4 1.8 4 4v8Z",
            }
            polyline {
                points: "15,9 18,9 18,11",
            }
            path {
                d: "M6.5 5C9 5 11 7 11 9.5V17a2 2 0 0 1-2 2",
            }
            line {
                x1: "6",
                x2: "7",
                y1: "10",
                y2: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMails;
impl IconShape for LdMails {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 1-1.732",
            }
            path {
                d: "m22 5.5-6.419 4.179a2 2 0 0 1-2.162 0L7 5.5",
            }
            rect {
                height: "12",
                rx: "2",
                width: "15",
                x: "7",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapMinus;
impl IconShape for LdMapMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m11 19-1.106-.552a2 2 0 0 0-1.788 0l-3.659 1.83A1 1 0 0 1 3 19.381V6.618a1 1 0 0 1 .553-.894l4.553-2.277a2 2 0 0 1 1.788 0l4.212 2.106a2 2 0 0 0 1.788 0l3.659-1.83A1 1 0 0 1 21 4.619V14",
            }
            path {
                d: "M15 5.764V14",
            }
            path {
                d: "M21 18h-6",
            }
            path {
                d: "M9 3.236v15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinCheckInside;
impl IconShape for LdMapPinCheckInside {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0",
            }
            path {
                d: "m9 10 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinCheck;
impl IconShape for LdMapPinCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19.43 12.935c.357-.967.57-1.955.57-2.935a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32.197 32.197 0 0 0 .813-.728",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "3",
            }
            path {
                d: "m16 18 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinHouse;
impl IconShape for LdMapPinHouse {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 22a1 1 0 0 1-1-1v-4a1 1 0 0 1 .445-.832l3-2a1 1 0 0 1 1.11 0l3 2A1 1 0 0 1 22 17v4a1 1 0 0 1-1 1z",
            }
            path {
                d: "M18 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 .601.2",
            }
            path {
                d: "M18 22v-3",
            }
            circle {
                cx: "10",
                cy: "10",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinMinusInside;
impl IconShape for LdMapPinMinusInside {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0",
            }
            path {
                d: "M9 10h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinMinus;
impl IconShape for LdMapPinMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18.977 14C19.6 12.701 20 11.343 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32 32 0 0 0 .824-.738",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "3",
            }
            path {
                d: "M16 18h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinOff;
impl IconShape for LdMapPinOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.75 7.09a3 3 0 0 1 2.16 2.16",
            }
            path {
                d: "M17.072 17.072c-1.634 2.17-3.527 3.912-4.471 4.727a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 1.432-4.568",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M8.475 2.818A8 8 0 0 1 20 10c0 1.183-.31 2.377-.81 3.533",
            }
            path {
                d: "M9.13 9.13a3 3 0 0 0 3.74 3.74",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinPen;
impl IconShape for LdMapPinPen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17.97 9.304A8 8 0 0 0 2 10c0 4.69 4.887 9.562 7.022 11.468",
            }
            path {
                d: "M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z",
            }
            circle {
                cx: "10",
                cy: "10",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinPlusInside;
impl IconShape for LdMapPinPlusInside {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0",
            }
            path {
                d: "M12 7v6",
            }
            path {
                d: "M9 10h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinPlus;
impl IconShape for LdMapPinPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19.914 11.105A7.298 7.298 0 0 0 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32 32 0 0 0 .824-.738",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "3",
            }
            path {
                d: "M16 18h6",
            }
            path {
                d: "M19 15v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinXInside;
impl IconShape for LdMapPinXInside {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0",
            }
            path {
                d: "m14.5 7.5-5 5",
            }
            path {
                d: "m9.5 7.5 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinX;
impl IconShape for LdMapPinX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19.752 11.901A7.78 7.78 0 0 0 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 19 19 0 0 0 .09-.077",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "3",
            }
            path {
                d: "m21.5 15.5-5 5",
            }
            path {
                d: "m21.5 20.5-5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPin;
impl IconShape for LdMapPin {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPinned;
impl IconShape for LdMapPinned {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 8c0 3.613-3.869 7.429-5.393 8.795a1 1 0 0 1-1.214 0C9.87 15.429 6 11.613 6 8a6 6 0 0 1 12 0",
            }
            circle {
                cx: "12",
                cy: "8",
                r: "2",
            }
            path {
                d: "M8.714 14h-3.71a1 1 0 0 0-.948.683l-2.004 6A1 1 0 0 0 3 22h18a1 1 0 0 0 .948-1.316l-2-6a1 1 0 0 0-.949-.684h-3.712",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMapPlus;
impl IconShape for LdMapPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m11 19-1.106-.552a2 2 0 0 0-1.788 0l-3.659 1.83A1 1 0 0 1 3 19.381V6.618a1 1 0 0 1 .553-.894l4.553-2.277a2 2 0 0 1 1.788 0l4.212 2.106a2 2 0 0 0 1.788 0l3.659-1.83A1 1 0 0 1 21 4.619V12",
            }
            path {
                d: "M15 5.764V12",
            }
            path {
                d: "M18 15v6",
            }
            path {
                d: "M21 18h-6",
            }
            path {
                d: "M9 3.236v15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMap;
impl IconShape for LdMap {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14.106 5.553a2 2 0 0 0 1.788 0l3.659-1.83A1 1 0 0 1 21 4.619v12.764a1 1 0 0 1-.553.894l-4.553 2.277a2 2 0 0 1-1.788 0l-4.212-2.106a2 2 0 0 0-1.788 0l-3.659 1.83A1 1 0 0 1 3 19.381V6.618a1 1 0 0 1 .553-.894l4.553-2.277a2 2 0 0 1 1.788 0z",
            }
            path {
                d: "M15 5.764v15",
            }
            path {
                d: "M9 3.236v15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMarsStroke;
impl IconShape for LdMarsStroke {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14 6 4 4",
            }
            path {
                d: "M17 3h4v4",
            }
            path {
                d: "m21 3-7.75 7.75",
            }
            circle {
                cx: "9",
                cy: "15",
                r: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMars;
impl IconShape for LdMars {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 3h5v5",
            }
            path {
                d: "m21 3-6.75 6.75",
            }
            circle {
                cx: "10",
                cy: "14",
                r: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMartini;
impl IconShape for LdMartini {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 22h8",
            }
            path {
                d: "M12 11v11",
            }
            path {
                d: "m19 3-7 8-7-8Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMaximize2;
impl IconShape for LdMaximize2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 3h6v6",
            }
            path {
                d: "m21 3-7 7",
            }
            path {
                d: "m3 21 7-7",
            }
            path {
                d: "M9 21H3v-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMaximize;
impl IconShape for LdMaximize {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 3H5a2 2 0 0 0-2 2v3",
            }
            path {
                d: "M21 8V5a2 2 0 0 0-2-2h-3",
            }
            path {
                d: "M3 16v3a2 2 0 0 0 2 2h3",
            }
            path {
                d: "M16 21h3a2 2 0 0 0 2-2v-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMedal;
impl IconShape for LdMedal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7.21 15 2.66 7.14a2 2 0 0 1 .13-2.2L4.4 2.8A2 2 0 0 1 6 2h12a2 2 0 0 1 1.6.8l1.6 2.14a2 2 0 0 1 .14 2.2L16.79 15",
            }
            path {
                d: "M11 12 5.12 2.2",
            }
            path {
                d: "m13 12 5.88-9.8",
            }
            path {
                d: "M8 7h8",
            }
            circle {
                cx: "12",
                cy: "17",
                r: "5",
            }
            path {
                d: "M12 18v-2h-.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMegaphoneOff;
impl IconShape for LdMegaphoneOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.636 6A13 13 0 0 0 19.4 3.2 1 1 0 0 1 21 4v11.344",
            }
            path {
                d: "M14.378 14.357A13 13 0 0 0 11 14H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h1",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M6 14a12 12 0 0 0 2.4 7.2 2 2 0 0 0 3.2-2.4A8 8 0 0 1 10 14",
            }
            path {
                d: "M8 8v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMegaphone;
impl IconShape for LdMegaphone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 6a13 13 0 0 0 8.4-2.8A1 1 0 0 1 21 4v12a1 1 0 0 1-1.6.8A13 13 0 0 0 11 14H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2z",
            }
            path {
                d: "M6 14a12 12 0 0 0 2.4 7.2 2 2 0 0 0 3.2-2.4A8 8 0 0 1 10 14",
            }
            path {
                d: "M8 6v8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMeh;
impl IconShape for LdMeh {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            line {
                x1: "8",
                x2: "16",
                y1: "15",
                y2: "15",
            }
            line {
                x1: "9",
                x2: "9.01",
                y1: "9",
                y2: "9",
            }
            line {
                x1: "15",
                x2: "15.01",
                y1: "9",
                y2: "9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMemoryStick;
impl IconShape for LdMemoryStick {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 19v-3",
            }
            path {
                d: "M10 19v-3",
            }
            path {
                d: "M14 19v-3",
            }
            path {
                d: "M18 19v-3",
            }
            path {
                d: "M8 11V9",
            }
            path {
                d: "M16 11V9",
            }
            path {
                d: "M12 11V9",
            }
            path {
                d: "M2 15h20",
            }
            path {
                d: "M2 7a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v1.1a2 2 0 0 0 0 3.837V17a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-5.1a2 2 0 0 0 0-3.837Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMenu;
impl IconShape for LdMenu {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 5h16",
            }
            path {
                d: "M4 12h16",
            }
            path {
                d: "M4 19h16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMerge;
impl IconShape for LdMerge {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m8 6 4-4 4 4",
            }
            path {
                d: "M12 2v10.3a4 4 0 0 1-1.172 2.872L4 22",
            }
            path {
                d: "m20 22-5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCircleCode;
impl IconShape for LdMessageCircleCode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 9-3 3 3 3",
            }
            path {
                d: "m14 15 3-3-3-3",
            }
            path {
                d: "M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCircleDashed;
impl IconShape for LdMessageCircleDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.1 2.182a10 10 0 0 1 3.8 0",
            }
            path {
                d: "M13.9 21.818a10 10 0 0 1-3.8 0",
            }
            path {
                d: "M17.609 3.72a10 10 0 0 1 2.69 2.7",
            }
            path {
                d: "M2.182 13.9a10 10 0 0 1 0-3.8",
            }
            path {
                d: "M20.28 17.61a10 10 0 0 1-2.7 2.69",
            }
            path {
                d: "M21.818 10.1a10 10 0 0 1 0 3.8",
            }
            path {
                d: "M3.721 6.391a10 10 0 0 1 2.7-2.69",
            }
            path {
                d: "m6.163 21.117-2.906.85a1 1 0 0 1-1.236-1.169l.965-2.98",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCircleHeart;
impl IconShape for LdMessageCircleHeart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719",
            }
            path {
                d: "M7.828 13.07A3 3 0 0 1 12 8.764a3 3 0 0 1 5.004 2.224 3 3 0 0 1-.832 2.083l-3.447 3.62a1 1 0 0 1-1.45-.001z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCircleMore;
impl IconShape for LdMessageCircleMore {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719",
            }
            path {
                d: "M8 12h.01",
            }
            path {
                d: "M12 12h.01",
            }
            path {
                d: "M16 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCircleOff;
impl IconShape for LdMessageCircleOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M4.93 4.929a10 10 0 0 0-1.938 11.412 2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 0 0 11.302-1.989",
            }
            path {
                d: "M8.35 2.69A10 10 0 0 1 21.3 15.65",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCirclePlus;
impl IconShape for LdMessageCirclePlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719",
            }
            path {
                d: "M8 12h8",
            }
            path {
                d: "M12 8v8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCircleQuestionMark;
impl IconShape for LdMessageCircleQuestionMark {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719",
            }
            path {
                d: "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3",
            }
            path {
                d: "M12 17h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCircleReply;
impl IconShape for LdMessageCircleReply {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719",
            }
            path {
                d: "m10 15-3-3 3-3",
            }
            path {
                d: "M7 12h8a2 2 0 0 1 2 2v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCircleWarning;
impl IconShape for LdMessageCircleWarning {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719",
            }
            path {
                d: "M12 8v4",
            }
            path {
                d: "M12 16h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCircleX;
impl IconShape for LdMessageCircleX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719",
            }
            path {
                d: "m15 9-6 6",
            }
            path {
                d: "m9 9 6 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageCircle;
impl IconShape for LdMessageCircle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareCode;
impl IconShape for LdMessageSquareCode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
            path {
                d: "m10 8-3 3 3 3",
            }
            path {
                d: "m14 14 3-3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareDashed;
impl IconShape for LdMessageSquareDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 19h.01",
            }
            path {
                d: "M12 3h.01",
            }
            path {
                d: "M16 19h.01",
            }
            path {
                d: "M16 3h.01",
            }
            path {
                d: "M2 13h.01",
            }
            path {
                d: "M2 17v4.286a.71.71 0 0 0 1.212.502l2.202-2.202A2 2 0 0 1 6.828 19H8",
            }
            path {
                d: "M2 5a2 2 0 0 1 2-2",
            }
            path {
                d: "M2 9h.01",
            }
            path {
                d: "M20 3a2 2 0 0 1 2 2",
            }
            path {
                d: "M22 13h.01",
            }
            path {
                d: "M22 17a2 2 0 0 1-2 2",
            }
            path {
                d: "M22 9h.01",
            }
            path {
                d: "M8 3h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareDiff;
impl IconShape for LdMessageSquareDiff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
            path {
                d: "M10 15h4",
            }
            path {
                d: "M10 9h4",
            }
            path {
                d: "M12 7v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareDot;
impl IconShape for LdMessageSquareDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.7 3H4a2 2 0 0 0-2 2v16.286a.71.71 0 0 0 1.212.502l2.202-2.202A2 2 0 0 1 6.828 19H20a2 2 0 0 0 2-2v-4.7",
            }
            circle {
                cx: "19",
                cy: "6",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareHeart;
impl IconShape for LdMessageSquareHeart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
            path {
                d: "M7.5 9.5c0 .687.265 1.383.697 1.844l3.009 3.264a1.14 1.14 0 0 0 .407.314 1 1 0 0 0 .783-.004 1.14 1.14 0 0 0 .398-.31l3.008-3.264A2.77 2.77 0 0 0 16.5 9.5 2.5 2.5 0 0 0 12 8a2.5 2.5 0 0 0-4.5 1.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareLock;
impl IconShape for LdMessageSquareLock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 8.5V5a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v16.286a.71.71 0 0 0 1.212.502l2.202-2.202A2 2 0 0 1 6.828 19H10",
            }
            path {
                d: "M20 15v-2a2 2 0 0 0-4 0v2",
            }
            rect {
                height: "5",
                rx: "1",
                width: "8",
                x: "14",
                y: "15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareMore;
impl IconShape for LdMessageSquareMore {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
            path {
                d: "M12 11h.01",
            }
            path {
                d: "M16 11h.01",
            }
            path {
                d: "M8 11h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareOff;
impl IconShape for LdMessageSquareOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 19H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.7.7 0 0 1 2 21.286V5a2 2 0 0 1 1.184-1.826",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M8.656 3H20a2 2 0 0 1 2 2v11.344",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquarePlus;
impl IconShape for LdMessageSquarePlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
            path {
                d: "M12 8v6",
            }
            path {
                d: "M9 11h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareQuote;
impl IconShape for LdMessageSquareQuote {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 14a2 2 0 0 0 2-2V8h-2",
            }
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
            path {
                d: "M8 14a2 2 0 0 0 2-2V8H8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareReply;
impl IconShape for LdMessageSquareReply {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
            path {
                d: "m10 8-3 3 3 3",
            }
            path {
                d: "M17 14v-1a2 2 0 0 0-2-2H7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareShare;
impl IconShape for LdMessageSquareShare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3H4a2 2 0 0 0-2 2v16.286a.71.71 0 0 0 1.212.502l2.202-2.202A2 2 0 0 1 6.828 19H20a2 2 0 0 0 2-2v-4",
            }
            path {
                d: "M16 3h6v6",
            }
            path {
                d: "m16 9 6-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareText;
impl IconShape for LdMessageSquareText {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
            path {
                d: "M7 11h10",
            }
            path {
                d: "M7 15h6",
            }
            path {
                d: "M7 7h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareWarning;
impl IconShape for LdMessageSquareWarning {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
            path {
                d: "M12 15h.01",
            }
            path {
                d: "M12 7v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquareX;
impl IconShape for LdMessageSquareX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
            path {
                d: "m14.5 8.5-5 5",
            }
            path {
                d: "m9.5 8.5 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessageSquare;
impl IconShape for LdMessageSquare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMessagesSquare;
impl IconShape for LdMessagesSquare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 10a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 14.286V4a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z",
            }
            path {
                d: "M20 9a2 2 0 0 1 2 2v10.286a.71.71 0 0 1-1.212.502l-2.202-2.202A2 2 0 0 0 17.172 19H10a2 2 0 0 1-2-2v-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMicOff;
impl IconShape for LdMicOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 19v3",
            }
            path {
                d: "M15 9.34V5a3 3 0 0 0-5.68-1.33",
            }
            path {
                d: "M16.95 16.95A7 7 0 0 1 5 12v-2",
            }
            path {
                d: "M18.89 13.23A7 7 0 0 0 19 12v-2",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M9 9v3a3 3 0 0 0 5.12 2.12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMicVocal;
impl IconShape for LdMicVocal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m11 7.601-5.994 8.19a1 1 0 0 0 .1 1.298l.817.818a1 1 0 0 0 1.314.087L15.09 12",
            }
            path {
                d: "M16.5 21.174C15.5 20.5 14.372 20 13 20c-2.058 0-3.928 2.356-6 2-2.072-.356-2.775-3.369-1.5-4.5",
            }
            circle {
                cx: "16",
                cy: "7",
                r: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMic;
impl IconShape for LdMic {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 19v3",
            }
            path {
                d: "M19 10v2a7 7 0 0 1-14 0v-2",
            }
            rect {
                height: "13",
                rx: "3",
                width: "6",
                x: "9",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMicrochip;
impl IconShape for LdMicrochip {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 12h2",
            }
            path {
                d: "M18 16h2",
            }
            path {
                d: "M18 20h2",
            }
            path {
                d: "M18 4h2",
            }
            path {
                d: "M18 8h2",
            }
            path {
                d: "M4 12h2",
            }
            path {
                d: "M4 16h2",
            }
            path {
                d: "M4 20h2",
            }
            path {
                d: "M4 4h2",
            }
            path {
                d: "M4 8h2",
            }
            path {
                d: "M8 2a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V4a2 2 0 0 0-2-2h-1.5c-.276 0-.494.227-.562.495a2 2 0 0 1-3.876 0C9.994 2.227 9.776 2 9.5 2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMicroscope;
impl IconShape for LdMicroscope {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 18h8",
            }
            path {
                d: "M3 22h18",
            }
            path {
                d: "M14 22a7 7 0 1 0 0-14h-1",
            }
            path {
                d: "M9 14h2",
            }
            path {
                d: "M9 12a2 2 0 0 1-2-2V6h6v4a2 2 0 0 1-2 2Z",
            }
            path {
                d: "M12 6V3a1 1 0 0 0-1-1H9a1 1 0 0 0-1 1v3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMicrowave;
impl IconShape for LdMicrowave {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "15",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
            rect {
                height: "7",
                rx: "1",
                width: "8",
                x: "6",
                y: "8",
            }
            path {
                d: "M18 8v7",
            }
            path {
                d: "M6 19v2",
            }
            path {
                d: "M18 19v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMilestone;
impl IconShape for LdMilestone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13v8",
            }
            path {
                d: "M12 3v3",
            }
            path {
                d: "M4 6a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1h13a2 2 0 0 0 1.152-.365l3.424-2.317a1 1 0 0 0 0-1.635l-3.424-2.318A2 2 0 0 0 17 6z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMilkOff;
impl IconShape for LdMilkOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2h8",
            }
            path {
                d: "M9 2v1.343M15 2v2.789a4 4 0 0 0 .672 2.219l.656.984a4 4 0 0 1 .672 2.22v1.131M7.8 7.8l-.128.192A4 4 0 0 0 7 10.212V20a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2v-3",
            }
            path {
                d: "M7 15a6.47 6.47 0 0 1 5 0 6.472 6.472 0 0 0 3.435.435",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMilk;
impl IconShape for LdMilk {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2h8",
            }
            path {
                d: "M9 2v2.789a4 4 0 0 1-.672 2.219l-.656.984A4 4 0 0 0 7 10.212V20a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2v-9.789a4 4 0 0 0-.672-2.219l-.656-.984A4 4 0 0 1 15 4.788V2",
            }
            path {
                d: "M7 15a6.472 6.472 0 0 1 5 0 6.47 6.47 0 0 0 5 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMinimize2;
impl IconShape for LdMinimize2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14 10 7-7",
            }
            path {
                d: "M20 10h-6V4",
            }
            path {
                d: "m3 21 7-7",
            }
            path {
                d: "M4 14h6v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMinimize;
impl IconShape for LdMinimize {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 3v3a2 2 0 0 1-2 2H3",
            }
            path {
                d: "M21 8h-3a2 2 0 0 1-2-2V3",
            }
            path {
                d: "M3 16h3a2 2 0 0 1 2 2v3",
            }
            path {
                d: "M16 21v-3a2 2 0 0 1 2-2h3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMinus;
impl IconShape for LdMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 12h14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorCheck;
impl IconShape for LdMonitorCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m9 10 2 2 4-4",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
            path {
                d: "M12 17v4",
            }
            path {
                d: "M8 21h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorCloud;
impl IconShape for LdMonitorCloud {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 13a3 3 0 1 1 2.83-4H14a2 2 0 0 1 0 4z",
            }
            path {
                d: "M12 17v4",
            }
            path {
                d: "M8 21h8",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorCog;
impl IconShape for LdMonitorCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 17v4",
            }
            path {
                d: "m14.305 7.53.923-.382",
            }
            path {
                d: "m15.228 4.852-.923-.383",
            }
            path {
                d: "m16.852 3.228-.383-.924",
            }
            path {
                d: "m16.852 8.772-.383.923",
            }
            path {
                d: "m19.148 3.228.383-.924",
            }
            path {
                d: "m19.53 9.696-.382-.924",
            }
            path {
                d: "m20.772 4.852.924-.383",
            }
            path {
                d: "m20.772 7.148.924.383",
            }
            path {
                d: "M22 13v2a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7",
            }
            path {
                d: "M8 21h8",
            }
            circle {
                cx: "18",
                cy: "6",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorDot;
impl IconShape for LdMonitorDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 17v4",
            }
            path {
                d: "M22 12.307V15a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h8.693",
            }
            path {
                d: "M8 21h8",
            }
            circle {
                cx: "19",
                cy: "6",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorDown;
impl IconShape for LdMonitorDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13V7",
            }
            path {
                d: "m15 10-3 3-3-3",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
            path {
                d: "M12 17v4",
            }
            path {
                d: "M8 21h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorOff;
impl IconShape for LdMonitorOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 17H4a2 2 0 0 1-2-2V5c0-1.5 1-2 1-2",
            }
            path {
                d: "M22 15V5a2 2 0 0 0-2-2H9",
            }
            path {
                d: "M8 21h8",
            }
            path {
                d: "M12 17v4",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorPause;
impl IconShape for LdMonitorPause {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 13V7",
            }
            path {
                d: "M14 13V7",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
            path {
                d: "M12 17v4",
            }
            path {
                d: "M8 21h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorPlay;
impl IconShape for LdMonitorPlay {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.033 9.44a.647.647 0 0 1 0 1.12l-4.065 2.352a.645.645 0 0 1-.968-.56V7.648a.645.645 0 0 1 .967-.56z",
            }
            path {
                d: "M12 17v4",
            }
            path {
                d: "M8 21h8",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorSmartphone;
impl IconShape for LdMonitorSmartphone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 8V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v7a2 2 0 0 0 2 2h8",
            }
            path {
                d: "M10 19v-3.96 3.15",
            }
            path {
                d: "M7 19h5",
            }
            rect {
                height: "10",
                rx: "2",
                width: "6",
                x: "16",
                y: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorSpeaker;
impl IconShape for LdMonitorSpeaker {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5.5 20H8",
            }
            path {
                d: "M17 9h.01",
            }
            rect {
                height: "16",
                rx: "2",
                width: "10",
                x: "12",
                y: "4",
            }
            path {
                d: "M8 6H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h4",
            }
            circle {
                cx: "17",
                cy: "15",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorStop;
impl IconShape for LdMonitorStop {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 17v4",
            }
            path {
                d: "M8 21h8",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
            rect {
                height: "6",
                rx: "1",
                width: "6",
                x: "9",
                y: "7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorUp;
impl IconShape for LdMonitorUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m9 10 3-3 3 3",
            }
            path {
                d: "M12 13V7",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
            path {
                d: "M12 17v4",
            }
            path {
                d: "M8 21h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitorX;
impl IconShape for LdMonitorX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14.5 12.5-5-5",
            }
            path {
                d: "m9.5 12.5 5-5",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
            path {
                d: "M12 17v4",
            }
            path {
                d: "M8 21h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMonitor;
impl IconShape for LdMonitor {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
            line {
                x1: "8",
                x2: "16",
                y1: "21",
                y2: "21",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "17",
                y2: "21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoonStar;
impl IconShape for LdMoonStar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 5h4",
            }
            path {
                d: "M20 3v4",
            }
            path {
                d: "M20.985 12.486a9 9 0 1 1-9.473-9.472c.405-.022.617.46.402.803a6 6 0 0 0 8.268 8.268c.344-.215.825-.004.803.401",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoon;
impl IconShape for LdMoon {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20.985 12.486a9 9 0 1 1-9.473-9.472c.405-.022.617.46.402.803a6 6 0 0 0 8.268 8.268c.344-.215.825-.004.803.401",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMotorbike;
impl IconShape for LdMotorbike {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m18 14-1-3",
            }
            path {
                d: "m3 9 6 2a2 2 0 0 1 2-2h2a2 2 0 0 1 1.99 1.81",
            }
            path {
                d: "M8 17h3a1 1 0 0 0 1-1 6 6 0 0 1 6-6 1 1 0 0 0 1-1v-.75A5 5 0 0 0 17 5",
            }
            circle {
                cx: "19",
                cy: "17",
                r: "3",
            }
            circle {
                cx: "5",
                cy: "17",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMountainSnow;
impl IconShape for LdMountainSnow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m8 3 4 8 5-5 5 15H2L8 3z",
            }
            path {
                d: "M4.14 15.08c2.62-1.57 5.24-1.43 7.86.42 2.74 1.94 5.49 2 8.23.19",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMountain;
impl IconShape for LdMountain {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m8 3 4 8 5-5 5 15H2L8 3z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMouseOff;
impl IconShape for LdMouseOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6v.343",
            }
            path {
                d: "M18.218 18.218A7 7 0 0 1 5 15V9a7 7 0 0 1 .782-3.218",
            }
            path {
                d: "M19 13.343V9A7 7 0 0 0 8.56 2.902",
            }
            path {
                d: "M22 22 2 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMousePointer2Off;
impl IconShape for LdMousePointer2Off {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15.55 8.45 5.138 2.087a.5.5 0 0 1-.063.947l-6.124 1.58a2 2 0 0 0-1.438 1.435l-1.579 6.126a.5.5 0 0 1-.947.063L8.45 15.551",
            }
            path {
                d: "M22 2 2 22",
            }
            path {
                d: "m6.816 11.528-2.779-6.84a.495.495 0 0 1 .651-.651l6.84 2.779",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMousePointer2;
impl IconShape for LdMousePointer2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4.037 4.688a.495.495 0 0 1 .651-.651l16 6.5a.5.5 0 0 1-.063.947l-6.124 1.58a2 2 0 0 0-1.438 1.435l-1.579 6.126a.5.5 0 0 1-.947.063z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMousePointerBan;
impl IconShape for LdMousePointerBan {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.034 2.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.944L8.204 7.545a1 1 0 0 0-.66.66l-1.066 3.443a.5.5 0 0 1-.944.033z",
            }
            circle {
                cx: "16",
                cy: "16",
                r: "6",
            }
            path {
                d: "m11.8 11.8 8.4 8.4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMousePointerClick;
impl IconShape for LdMousePointerClick {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 4.1 12 6",
            }
            path {
                d: "m5.1 8-2.9-.8",
            }
            path {
                d: "m6 12-1.9 2",
            }
            path {
                d: "M7.2 2.2 8 5.1",
            }
            path {
                d: "M9.037 9.69a.498.498 0 0 1 .653-.653l11 4.5a.5.5 0 0 1-.074.949l-4.349 1.041a1 1 0 0 0-.74.739l-1.04 4.35a.5.5 0 0 1-.95.074z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMousePointer;
impl IconShape for LdMousePointer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.586 12.586 19 19",
            }
            path {
                d: "M3.688 3.037a.497.497 0 0 0-.651.651l6.5 15.999a.501.501 0 0 0 .947-.062l1.569-6.083a2 2 0 0 1 1.448-1.479l6.124-1.579a.5.5 0 0 0 .063-.947z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMouse;
impl IconShape for LdMouse {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "7",
                width: "14",
                x: "5",
                y: "2",
            }
            path {
                d: "M12 6v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMove3d;
impl IconShape for LdMove3d {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 3v16h16",
            }
            path {
                d: "m5 19 6-6",
            }
            path {
                d: "m2 6 3-3 3 3",
            }
            path {
                d: "m18 16 3 3-3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveDiagonal2;
impl IconShape for LdMoveDiagonal2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 13v6h-6",
            }
            path {
                d: "M5 11V5h6",
            }
            path {
                d: "m5 5 14 14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveDiagonal;
impl IconShape for LdMoveDiagonal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 19H5v-6",
            }
            path {
                d: "M13 5h6v6",
            }
            path {
                d: "M19 5 5 19",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveDownLeft;
impl IconShape for LdMoveDownLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 19H5V13",
            }
            path {
                d: "M19 5L5 19",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveDownRight;
impl IconShape for LdMoveDownRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 13V19H13",
            }
            path {
                d: "M5 5L19 19",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveDown;
impl IconShape for LdMoveDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 18L12 22L16 18",
            }
            path {
                d: "M12 2V22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveHorizontal;
impl IconShape for LdMoveHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m18 8 4 4-4 4",
            }
            path {
                d: "M2 12h20",
            }
            path {
                d: "m6 8-4 4 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveLeft;
impl IconShape for LdMoveLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 8L2 12L6 16",
            }
            path {
                d: "M2 12H22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveRight;
impl IconShape for LdMoveRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 8L22 12L18 16",
            }
            path {
                d: "M2 12H22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveUpLeft;
impl IconShape for LdMoveUpLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 11V5H11",
            }
            path {
                d: "M5 5L19 19",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveUpRight;
impl IconShape for LdMoveUpRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 5H19V11",
            }
            path {
                d: "M19 5L5 19",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveUp;
impl IconShape for LdMoveUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 6L12 2L16 6",
            }
            path {
                d: "M12 2V22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMoveVertical;
impl IconShape for LdMoveVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v20",
            }
            path {
                d: "m8 18 4 4 4-4",
            }
            path {
                d: "m8 6 4-4 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMove;
impl IconShape for LdMove {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v20",
            }
            path {
                d: "m15 19-3 3-3-3",
            }
            path {
                d: "m19 9 3 3-3 3",
            }
            path {
                d: "M2 12h20",
            }
            path {
                d: "m5 9-3 3 3 3",
            }
            path {
                d: "m9 5 3-3 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMusic2;
impl IconShape for LdMusic2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "8",
                cy: "18",
                r: "4",
            }
            path {
                d: "M12 18V2l7 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMusic3;
impl IconShape for LdMusic3 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "18",
                r: "4",
            }
            path {
                d: "M16 18V2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMusic4;
impl IconShape for LdMusic4 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 18V5l12-2v13",
            }
            path {
                d: "m9 9 12-2",
            }
            circle {
                cx: "6",
                cy: "18",
                r: "3",
            }
            circle {
                cx: "18",
                cy: "16",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdMusic;
impl IconShape for LdMusic {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 18V5l12-2v13",
            }
            circle {
                cx: "6",
                cy: "18",
                r: "3",
            }
            circle {
                cx: "18",
                cy: "16",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNavigation2Off;
impl IconShape for LdNavigation2Off {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9.31 9.31 5 21l7-4 7 4-1.17-3.17",
            }
            path {
                d: "M14.53 8.88 12 2l-1.17 3.17",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNavigation2;
impl IconShape for LdNavigation2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            polygon {
                points: "12 2 19 21 12 17 5 21 12 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNavigationOff;
impl IconShape for LdNavigationOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8.43 8.43 3 11l8 2 2 8 2.57-5.43",
            }
            path {
                d: "M17.39 11.73 22 2l-9.73 4.61",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNavigation;
impl IconShape for LdNavigation {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            polygon {
                points: "3 11 22 2 13 21 11 13 3 11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNetwork;
impl IconShape for LdNetwork {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "1",
                width: "6",
                x: "16",
                y: "16",
            }
            rect {
                height: "6",
                rx: "1",
                width: "6",
                x: "2",
                y: "16",
            }
            rect {
                height: "6",
                rx: "1",
                width: "6",
                x: "9",
                y: "2",
            }
            path {
                d: "M5 16v-3a1 1 0 0 1 1-1h12a1 1 0 0 1 1 1v3",
            }
            path {
                d: "M12 12V8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNewspaper;
impl IconShape for LdNewspaper {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 18h-5",
            }
            path {
                d: "M18 14h-8",
            }
            path {
                d: "M4 22h16a2 2 0 0 0 2-2V4a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v16a2 2 0 0 1-4 0v-9a2 2 0 0 1 2-2h2",
            }
            rect {
                height: "4",
                rx: "1",
                width: "8",
                x: "10",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNfc;
impl IconShape for LdNfc {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 8.32a7.43 7.43 0 0 1 0 7.36",
            }
            path {
                d: "M9.46 6.21a11.76 11.76 0 0 1 0 11.58",
            }
            path {
                d: "M12.91 4.1a15.91 15.91 0 0 1 .01 15.8",
            }
            path {
                d: "M16.37 2a20.16 20.16 0 0 1 0 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNonBinary;
impl IconShape for LdNonBinary {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v10",
            }
            path {
                d: "m8.5 4 7 4",
            }
            path {
                d: "m8.5 8 7-4",
            }
            circle {
                cx: "12",
                cy: "17",
                r: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNotebookPen;
impl IconShape for LdNotebookPen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.4 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-7.4",
            }
            path {
                d: "M2 6h4",
            }
            path {
                d: "M2 10h4",
            }
            path {
                d: "M2 14h4",
            }
            path {
                d: "M2 18h4",
            }
            path {
                d: "M21.378 5.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNotebookTabs;
impl IconShape for LdNotebookTabs {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 6h4",
            }
            path {
                d: "M2 10h4",
            }
            path {
                d: "M2 14h4",
            }
            path {
                d: "M2 18h4",
            }
            rect {
                height: "20",
                rx: "2",
                width: "16",
                x: "4",
                y: "2",
            }
            path {
                d: "M15 2v20",
            }
            path {
                d: "M15 7h5",
            }
            path {
                d: "M15 12h5",
            }
            path {
                d: "M15 17h5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNotebookText;
impl IconShape for LdNotebookText {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 6h4",
            }
            path {
                d: "M2 10h4",
            }
            path {
                d: "M2 14h4",
            }
            path {
                d: "M2 18h4",
            }
            rect {
                height: "20",
                rx: "2",
                width: "16",
                x: "4",
                y: "2",
            }
            path {
                d: "M9.5 8h5",
            }
            path {
                d: "M9.5 12H16",
            }
            path {
                d: "M9.5 16H14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNotebook;
impl IconShape for LdNotebook {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 6h4",
            }
            path {
                d: "M2 10h4",
            }
            path {
                d: "M2 14h4",
            }
            path {
                d: "M2 18h4",
            }
            rect {
                height: "20",
                rx: "2",
                width: "16",
                x: "4",
                y: "2",
            }
            path {
                d: "M16 2v20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNotepadTextDashed;
impl IconShape for LdNotepadTextDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2v4",
            }
            path {
                d: "M12 2v4",
            }
            path {
                d: "M16 2v4",
            }
            path {
                d: "M16 4h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M20 12v2",
            }
            path {
                d: "M20 18v2a2 2 0 0 1-2 2h-1",
            }
            path {
                d: "M13 22h-2",
            }
            path {
                d: "M7 22H6a2 2 0 0 1-2-2v-2",
            }
            path {
                d: "M4 14v-2",
            }
            path {
                d: "M4 8V6a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M8 10h6",
            }
            path {
                d: "M8 14h8",
            }
            path {
                d: "M8 18h5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNotepadText;
impl IconShape for LdNotepadText {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 2v4",
            }
            path {
                d: "M12 2v4",
            }
            path {
                d: "M16 2v4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "16",
                x: "4",
                y: "4",
            }
            path {
                d: "M8 10h6",
            }
            path {
                d: "M8 14h8",
            }
            path {
                d: "M8 18h5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNutOff;
impl IconShape for LdNutOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 4V2",
            }
            path {
                d: "M5 10v4a7.004 7.004 0 0 0 5.277 6.787c.412.104.802.292 1.102.592L12 22l.621-.621c.3-.3.69-.488 1.102-.592a7.01 7.01 0 0 0 4.125-2.939",
            }
            path {
                d: "M19 10v3.343",
            }
            path {
                d: "M12 12c-1.349-.573-1.905-1.005-2.5-2-.546.902-1.048 1.353-2.5 2-1.018-.644-1.46-1.08-2-2-1.028.71-1.69.918-3 1 1.081-1.048 1.757-2.03 2-3 .194-.776.84-1.551 1.79-2.21m11.654 5.997c.887-.457 1.28-.891 1.556-1.787 1.032.916 1.683 1.157 3 1-1.297-1.036-1.758-2.03-2-3-.5-2-4-4-8-4-.74 0-1.461.068-2.15.192",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdNut;
impl IconShape for LdNut {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 4V2",
            }
            path {
                d: "M5 10v4a7.004 7.004 0 0 0 5.277 6.787c.412.104.802.292 1.102.592L12 22l.621-.621c.3-.3.69-.488 1.102-.592A7.003 7.003 0 0 0 19 14v-4",
            }
            path {
                d: "M12 4C8 4 4.5 6 4 8c-.243.97-.919 1.952-2 3 1.31-.082 1.972-.29 3-1 .54.92.982 1.356 2 2 1.452-.647 1.954-1.098 2.5-2 .595.995 1.151 1.427 2.5 2 1.31-.621 1.862-1.058 2.5-2 .629.977 1.162 1.423 2.5 2 1.209-.548 1.68-.967 2-2 1.032.916 1.683 1.157 3 1-1.297-1.036-1.758-2.03-2-3-.5-2-4-4-8-4Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdOctagonAlert;
impl IconShape for LdOctagonAlert {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 16h.01",
            }
            path {
                d: "M12 8v4",
            }
            path {
                d: "M15.312 2a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586l-4.688-4.688A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdOctagonMinus;
impl IconShape for LdOctagonMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z",
            }
            path {
                d: "M8 12h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdOctagonPause;
impl IconShape for LdOctagonPause {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 15V9",
            }
            path {
                d: "M14 15V9",
            }
            path {
                d: "M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdOctagonX;
impl IconShape for LdOctagonX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 9-6 6",
            }
            path {
                d: "M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z",
            }
            path {
                d: "m9 9 6 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdOctagon;
impl IconShape for LdOctagon {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdOmega;
impl IconShape for LdOmega {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 20h4.5a.5.5 0 0 0 .5-.5v-.282a.52.52 0 0 0-.247-.437 8 8 0 1 1 8.494-.001.52.52 0 0 0-.247.438v.282a.5.5 0 0 0 .5.5H21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdOption;
impl IconShape for LdOption {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3h6l6 18h6",
            }
            path {
                d: "M14 3h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdOrbit;
impl IconShape for LdOrbit {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20.341 6.484A10 10 0 0 1 10.266 21.85",
            }
            path {
                d: "M3.659 17.516A10 10 0 0 1 13.74 2.152",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
            circle {
                cx: "19",
                cy: "5",
                r: "2",
            }
            circle {
                cx: "5",
                cy: "19",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdOrigami;
impl IconShape for LdOrigami {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 12V4a1 1 0 0 1 1-1h6.297a1 1 0 0 1 .651 1.759l-4.696 4.025",
            }
            path {
                d: "m12 21-7.414-7.414A2 2 0 0 1 4 12.172V6.415a1.002 1.002 0 0 1 1.707-.707L20 20.009",
            }
            path {
                d: "m12.214 3.381 8.414 14.966a1 1 0 0 1-.167 1.199l-1.168 1.163a1 1 0 0 1-.706.291H6.351a1 1 0 0 1-.625-.219L3.25 18.8a1 1 0 0 1 .631-1.781l4.165.027",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPackage2;
impl IconShape for LdPackage2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v6",
            }
            path {
                d: "M16.76 3a2 2 0 0 1 1.8 1.1l2.23 4.479a2 2 0 0 1 .21.891V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V9.472a2 2 0 0 1 .211-.894L5.45 4.1A2 2 0 0 1 7.24 3z",
            }
            path {
                d: "M3.054 9.013h17.893",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPackageCheck;
impl IconShape for LdPackageCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 16 2 2 4-4",
            }
            path {
                d: "M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14",
            }
            path {
                d: "m7.5 4.27 9 5.15",
            }
            polyline {
                points: "3.29 7 12 12 20.71 7",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "22",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPackageMinus;
impl IconShape for LdPackageMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 16h6",
            }
            path {
                d: "M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14",
            }
            path {
                d: "m7.5 4.27 9 5.15",
            }
            polyline {
                points: "3.29 7 12 12 20.71 7",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "22",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPackageOpen;
impl IconShape for LdPackageOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 22v-9",
            }
            path {
                d: "M15.17 2.21a1.67 1.67 0 0 1 1.63 0L21 4.57a1.93 1.93 0 0 1 0 3.36L8.82 14.79a1.655 1.655 0 0 1-1.64 0L3 12.43a1.93 1.93 0 0 1 0-3.36z",
            }
            path {
                d: "M20 13v3.87a2.06 2.06 0 0 1-1.11 1.83l-6 3.08a1.93 1.93 0 0 1-1.78 0l-6-3.08A2.06 2.06 0 0 1 4 16.87V13",
            }
            path {
                d: "M21 12.43a1.93 1.93 0 0 0 0-3.36L8.83 2.2a1.64 1.64 0 0 0-1.63 0L3 4.57a1.93 1.93 0 0 0 0 3.36l12.18 6.86a1.636 1.636 0 0 0 1.63 0z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPackagePlus;
impl IconShape for LdPackagePlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 16h6",
            }
            path {
                d: "M19 13v6",
            }
            path {
                d: "M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14",
            }
            path {
                d: "m7.5 4.27 9 5.15",
            }
            polyline {
                points: "3.29 7 12 12 20.71 7",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "22",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPackageSearch;
impl IconShape for LdPackageSearch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14",
            }
            path {
                d: "m7.5 4.27 9 5.15",
            }
            polyline {
                points: "3.29 7 12 12 20.71 7",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "22",
                y2: "12",
            }
            circle {
                cx: "18.5",
                cy: "15.5",
                r: "2.5",
            }
            path {
                d: "M20.27 17.27 22 19",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPackageX;
impl IconShape for LdPackageX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14",
            }
            path {
                d: "m7.5 4.27 9 5.15",
            }
            polyline {
                points: "3.29 7 12 12 20.71 7",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "22",
                y2: "12",
            }
            path {
                d: "m17 13 5 5m-5 0 5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPackage;
impl IconShape for LdPackage {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 21.73a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73z",
            }
            path {
                d: "M12 22V12",
            }
            polyline {
                points: "3.29 7 12 12 20.71 7",
            }
            path {
                d: "m7.5 4.27 9 5.15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPaintBucket;
impl IconShape for LdPaintBucket {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m19 11-8-8-8.6 8.6a2 2 0 0 0 0 2.8l5.2 5.2c.8.8 2 .8 2.8 0L19 11Z",
            }
            path {
                d: "m5 2 5 5",
            }
            path {
                d: "M2 13h15",
            }
            path {
                d: "M22 20a2 2 0 1 1-4 0c0-1.6 1.7-2.4 2-4 .3 1.6 2 2.4 2 4Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPaintRoller;
impl IconShape for LdPaintRoller {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "16",
                x: "2",
                y: "2",
            }
            path {
                d: "M10 16v-2a2 2 0 0 1 2-2h8a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2",
            }
            rect {
                height: "6",
                rx: "1",
                width: "4",
                x: "8",
                y: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPaintbrushVertical;
impl IconShape for LdPaintbrushVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2v2",
            }
            path {
                d: "M14 2v4",
            }
            path {
                d: "M17 2a1 1 0 0 1 1 1v9H6V3a1 1 0 0 1 1-1z",
            }
            path {
                d: "M6 12a1 1 0 0 0-1 1v1a2 2 0 0 0 2 2h2a1 1 0 0 1 1 1v2.9a2 2 0 1 0 4 0V17a1 1 0 0 1 1-1h2a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPaintbrush;
impl IconShape for LdPaintbrush {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14.622 17.897-10.68-2.913",
            }
            path {
                d: "M18.376 2.622a1 1 0 1 1 3.002 3.002L17.36 9.643a.5.5 0 0 0 0 .707l.944.944a2.41 2.41 0 0 1 0 3.408l-.944.944a.5.5 0 0 1-.707 0L8.354 7.348a.5.5 0 0 1 0-.707l.944-.944a2.41 2.41 0 0 1 3.408 0l.944.944a.5.5 0 0 0 .707 0z",
            }
            path {
                d: "M9 8c-1.804 2.71-3.97 3.46-6.583 3.948a.507.507 0 0 0-.302.819l7.32 8.883a1 1 0 0 0 1.185.204C12.735 20.405 16 16.792 16 15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPalette;
impl IconShape for LdPalette {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 22a1 1 0 0 1 0-20 10 9 0 0 1 10 9 5 5 0 0 1-5 5h-2.25a1.75 1.75 0 0 0-1.4 2.8l.3.4a1.75 1.75 0 0 1-1.4 2.8z",
            }
            circle {
                cx: "13.5",
                cy: "6.5",
                r: ".5",
            }
            circle {
                cx: "17.5",
                cy: "10.5",
                r: ".5",
            }
            circle {
                cx: "6.5",
                cy: "12.5",
                r: ".5",
            }
            circle {
                cx: "8.5",
                cy: "7.5",
                r: ".5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanda;
impl IconShape for LdPanda {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.25 17.25h1.5L12 18z",
            }
            path {
                d: "m15 12 2 2",
            }
            path {
                d: "M18 6.5a.5.5 0 0 0-.5-.5",
            }
            path {
                d: "M20.69 9.67a4.5 4.5 0 1 0-7.04-5.5 8.35 8.35 0 0 0-3.3 0 4.5 4.5 0 1 0-7.04 5.5C2.49 11.2 2 12.88 2 14.5 2 19.47 6.48 22 12 22s10-2.53 10-7.5c0-1.62-.48-3.3-1.3-4.83",
            }
            path {
                d: "M6 6.5a.495.495 0 0 1 .5-.5",
            }
            path {
                d: "m9 12-2 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelBottomClose;
impl IconShape for LdPanelBottomClose {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 15h18",
            }
            path {
                d: "m15 8-3 3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelBottomDashed;
impl IconShape for LdPanelBottomDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M14 15h1",
            }
            path {
                d: "M19 15h2",
            }
            path {
                d: "M3 15h2",
            }
            path {
                d: "M9 15h1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelBottomOpen;
impl IconShape for LdPanelBottomOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 15h18",
            }
            path {
                d: "m9 10 3-3 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelBottom;
impl IconShape for LdPanelBottom {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 15h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelLeftClose;
impl IconShape for LdPanelLeftClose {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M9 3v18",
            }
            path {
                d: "m16 15-3-3 3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelLeftDashed;
impl IconShape for LdPanelLeftDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M9 14v1",
            }
            path {
                d: "M9 19v2",
            }
            path {
                d: "M9 3v2",
            }
            path {
                d: "M9 9v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelLeftOpen;
impl IconShape for LdPanelLeftOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M9 3v18",
            }
            path {
                d: "m14 9 3 3-3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelLeftRightDashed;
impl IconShape for LdPanelLeftRightDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 10V9",
            }
            path {
                d: "M15 15v-1",
            }
            path {
                d: "M15 21v-2",
            }
            path {
                d: "M15 5V3",
            }
            path {
                d: "M9 10V9",
            }
            path {
                d: "M9 15v-1",
            }
            path {
                d: "M9 21v-2",
            }
            path {
                d: "M9 5V3",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelLeft;
impl IconShape for LdPanelLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M9 3v18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelRightClose;
impl IconShape for LdPanelRightClose {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M15 3v18",
            }
            path {
                d: "m8 9 3 3-3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelRightDashed;
impl IconShape for LdPanelRightDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M15 14v1",
            }
            path {
                d: "M15 19v2",
            }
            path {
                d: "M15 3v2",
            }
            path {
                d: "M15 9v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelRightOpen;
impl IconShape for LdPanelRightOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M15 3v18",
            }
            path {
                d: "m10 15-3-3 3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelRight;
impl IconShape for LdPanelRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M15 3v18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelTopBottomDashed;
impl IconShape for LdPanelTopBottomDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 15h1",
            }
            path {
                d: "M14 9h1",
            }
            path {
                d: "M19 15h2",
            }
            path {
                d: "M19 9h2",
            }
            path {
                d: "M3 15h2",
            }
            path {
                d: "M3 9h2",
            }
            path {
                d: "M9 15h1",
            }
            path {
                d: "M9 9h1",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelTopClose;
impl IconShape for LdPanelTopClose {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 9h18",
            }
            path {
                d: "m9 16 3-3 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelTopDashed;
impl IconShape for LdPanelTopDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M14 9h1",
            }
            path {
                d: "M19 9h2",
            }
            path {
                d: "M3 9h2",
            }
            path {
                d: "M9 9h1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelTopOpen;
impl IconShape for LdPanelTopOpen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 9h18",
            }
            path {
                d: "m15 14-3 3-3-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelTop;
impl IconShape for LdPanelTop {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 9h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelsLeftBottom;
impl IconShape for LdPanelsLeftBottom {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M9 3v18",
            }
            path {
                d: "M9 15h12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelsRightBottom;
impl IconShape for LdPanelsRightBottom {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 15h12",
            }
            path {
                d: "M15 3v18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPanelsTopLeft;
impl IconShape for LdPanelsTopLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 9h18",
            }
            path {
                d: "M9 21V9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPaperclip;
impl IconShape for LdPaperclip {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 6-8.414 8.586a2 2 0 0 0 2.829 2.829l8.414-8.586a4 4 0 1 0-5.657-5.657l-8.379 8.551a6 6 0 1 0 8.485 8.485l8.379-8.551",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdParentheses;
impl IconShape for LdParentheses {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 21s-4-3-4-9 4-9 4-9",
            }
            path {
                d: "M16 3s4 3 4 9-4 9-4 9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdParkingMeter;
impl IconShape for LdParkingMeter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 15h2",
            }
            path {
                d: "M12 12v3",
            }
            path {
                d: "M12 19v3",
            }
            path {
                d: "M15.282 19a1 1 0 0 0 .948-.68l2.37-6.988a7 7 0 1 0-13.2 0l2.37 6.988a1 1 0 0 0 .948.68z",
            }
            path {
                d: "M9 9a3 3 0 1 1 6 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPartyPopper;
impl IconShape for LdPartyPopper {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5.8 11.3 2 22l10.7-3.79",
            }
            path {
                d: "M4 3h.01",
            }
            path {
                d: "M22 8h.01",
            }
            path {
                d: "M15 2h.01",
            }
            path {
                d: "M22 20h.01",
            }
            path {
                d: "m22 2-2.24.75a2.9 2.9 0 0 0-1.96 3.12c.1.86-.57 1.63-1.45 1.63h-.38c-.86 0-1.6.6-1.76 1.44L14 10",
            }
            path {
                d: "m22 13-.82-.33c-.86-.34-1.82.2-1.98 1.11c-.11.7-.72 1.22-1.43 1.22H17",
            }
            path {
                d: "m11 2 .33.82c.34.86-.2 1.82-1.11 1.98C9.52 4.9 9 5.52 9 6.23V7",
            }
            path {
                d: "M11 13c1.93 1.93 2.83 4.17 2 5-.83.83-3.07-.07-5-2-1.93-1.93-2.83-4.17-2-5 .83-.83 3.07.07 5 2Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPause;
impl IconShape for LdPause {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "1",
                width: "5",
                x: "14",
                y: "3",
            }
            rect {
                height: "18",
                rx: "1",
                width: "5",
                x: "5",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPawPrint;
impl IconShape for LdPawPrint {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "11",
                cy: "4",
                r: "2",
            }
            circle {
                cx: "18",
                cy: "8",
                r: "2",
            }
            circle {
                cx: "20",
                cy: "16",
                r: "2",
            }
            path {
                d: "M9 10a5 5 0 0 1 5 5v3.5a3.5 3.5 0 0 1-6.84 1.045Q6.52 17.48 4.46 16.84A3.5 3.5 0 0 1 5.5 10Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPcCase;
impl IconShape for LdPcCase {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "2",
                width: "14",
                x: "5",
                y: "2",
            }
            path {
                d: "M15 14h.01",
            }
            path {
                d: "M9 6h6",
            }
            path {
                d: "M9 10h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPenLine;
impl IconShape for LdPenLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 21h8",
            }
            path {
                d: "M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPenOff;
impl IconShape for LdPenOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 10-6.157 6.162a2 2 0 0 0-.5.833l-1.322 4.36a.5.5 0 0 0 .622.624l4.358-1.323a2 2 0 0 0 .83-.5L14 13.982",
            }
            path {
                d: "m12.829 7.172 4.359-4.346a1 1 0 1 1 3.986 3.986l-4.353 4.353",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPenTool;
impl IconShape for LdPenTool {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.707 21.293a1 1 0 0 1-1.414 0l-1.586-1.586a1 1 0 0 1 0-1.414l5.586-5.586a1 1 0 0 1 1.414 0l1.586 1.586a1 1 0 0 1 0 1.414z",
            }
            path {
                d: "m18 13-1.375-6.874a1 1 0 0 0-.746-.776L3.235 2.028a1 1 0 0 0-1.207 1.207L5.35 15.879a1 1 0 0 0 .776.746L13 18",
            }
            path {
                d: "m2.3 2.3 7.286 7.286",
            }
            circle {
                cx: "11",
                cy: "11",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPen;
impl IconShape for LdPen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPencilLine;
impl IconShape for LdPencilLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 21h8",
            }
            path {
                d: "m15 5 4 4",
            }
            path {
                d: "M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPencilOff;
impl IconShape for LdPencilOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 10-6.157 6.162a2 2 0 0 0-.5.833l-1.322 4.36a.5.5 0 0 0 .622.624l4.358-1.323a2 2 0 0 0 .83-.5L14 13.982",
            }
            path {
                d: "m12.829 7.172 4.359-4.346a1 1 0 1 1 3.986 3.986l-4.353 4.353",
            }
            path {
                d: "m15 5 4 4",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPencilRuler;
impl IconShape for LdPencilRuler {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 7 8.7 2.7a2.41 2.41 0 0 0-3.4 0L2.7 5.3a2.41 2.41 0 0 0 0 3.4L7 13",
            }
            path {
                d: "m8 6 2-2",
            }
            path {
                d: "m18 16 2-2",
            }
            path {
                d: "m17 11 4.3 4.3c.94.94.94 2.46 0 3.4l-2.6 2.6c-.94.94-2.46.94-3.4 0L11 17",
            }
            path {
                d: "M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z",
            }
            path {
                d: "m15 5 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPencil;
impl IconShape for LdPencil {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z",
            }
            path {
                d: "m15 5 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPentagon;
impl IconShape for LdPentagon {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.83 2.38a2 2 0 0 1 2.34 0l8 5.74a2 2 0 0 1 .73 2.25l-3.04 9.26a2 2 0 0 1-1.9 1.37H7.04a2 2 0 0 1-1.9-1.37L2.1 10.37a2 2 0 0 1 .73-2.25z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPercent;
impl IconShape for LdPercent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "19",
                x2: "5",
                y1: "5",
                y2: "19",
            }
            circle {
                cx: "6.5",
                cy: "6.5",
                r: "2.5",
            }
            circle {
                cx: "17.5",
                cy: "17.5",
                r: "2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPersonStanding;
impl IconShape for LdPersonStanding {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "5",
                r: "1",
            }
            path {
                d: "m9 20 3-6 3 6",
            }
            path {
                d: "m6 8 6 2 6-2",
            }
            path {
                d: "M12 10v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPhilippinePeso;
impl IconShape for LdPhilippinePeso {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 11H4",
            }
            path {
                d: "M20 7H4",
            }
            path {
                d: "M7 21V4a1 1 0 0 1 1-1h4a1 1 0 0 1 0 12H7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPhoneCall;
impl IconShape for LdPhoneCall {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 2a9 9 0 0 1 9 9",
            }
            path {
                d: "M13 6a5 5 0 0 1 5 5",
            }
            path {
                d: "M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPhoneForwarded;
impl IconShape for LdPhoneForwarded {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 6h8",
            }
            path {
                d: "m18 2 4 4-4 4",
            }
            path {
                d: "M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPhoneIncoming;
impl IconShape for LdPhoneIncoming {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 2v6h6",
            }
            path {
                d: "m22 2-6 6",
            }
            path {
                d: "M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPhoneMissed;
impl IconShape for LdPhoneMissed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 2 6 6",
            }
            path {
                d: "m22 2-6 6",
            }
            path {
                d: "M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPhoneOff;
impl IconShape for LdPhoneOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.1 13.9a14 14 0 0 0 3.732 2.668 1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2 18 18 0 0 1-12.728-5.272",
            }
            path {
                d: "M22 2 2 22",
            }
            path {
                d: "M4.76 13.582A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 .244.473",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPhoneOutgoing;
impl IconShape for LdPhoneOutgoing {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 8 6-6",
            }
            path {
                d: "M22 8V2h-6",
            }
            path {
                d: "M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPhone;
impl IconShape for LdPhone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPi;
impl IconShape for LdPi {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "9",
                x2: "9",
                y1: "4",
                y2: "20",
            }
            path {
                d: "M4 7c0-1.7 1.3-3 3-3h13",
            }
            path {
                d: "M18 20c-1.7 0-3-1.3-3-3V4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPiano;
impl IconShape for LdPiano {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18.5 8c-1.4 0-2.6-.8-3.2-2A6.87 6.87 0 0 0 2 9v11a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-8.5C22 9.6 20.4 8 18.5 8",
            }
            path {
                d: "M2 14h20",
            }
            path {
                d: "M6 14v4",
            }
            path {
                d: "M10 14v4",
            }
            path {
                d: "M14 14v4",
            }
            path {
                d: "M18 14v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPickaxe;
impl IconShape for LdPickaxe {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14 13-8.381 8.38a1 1 0 0 1-3.001-3L11 9.999",
            }
            path {
                d: "M15.973 4.027A13 13 0 0 0 5.902 2.373c-1.398.342-1.092 2.158.277 2.601a19.9 19.9 0 0 1 5.822 3.024",
            }
            path {
                d: "M16.001 11.999a19.9 19.9 0 0 1 3.024 5.824c.444 1.369 2.26 1.676 2.603.278A13 13 0 0 0 20 8.069",
            }
            path {
                d: "M18.352 3.352a1.205 1.205 0 0 0-1.704 0l-5.296 5.296a1.205 1.205 0 0 0 0 1.704l2.296 2.296a1.205 1.205 0 0 0 1.704 0l5.296-5.296a1.205 1.205 0 0 0 0-1.704z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPictureInPicture2;
impl IconShape for LdPictureInPicture2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 9V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v10c0 1.1.9 2 2 2h4",
            }
            rect {
                height: "7",
                rx: "2",
                width: "10",
                x: "12",
                y: "13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPictureInPicture;
impl IconShape for LdPictureInPicture {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 10h6V4",
            }
            path {
                d: "m2 4 6 6",
            }
            path {
                d: "M21 10V7a2 2 0 0 0-2-2h-7",
            }
            path {
                d: "M3 14v2a2 2 0 0 0 2 2h3",
            }
            rect {
                height: "7",
                rx: "1",
                width: "10",
                x: "12",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPiggyBank;
impl IconShape for LdPiggyBank {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 17h3v2a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-3a3.16 3.16 0 0 0 2-2h1a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1h-1a5 5 0 0 0-2-4V3a4 4 0 0 0-3.2 1.6l-.3.4H11a6 6 0 0 0-6 6v1a5 5 0 0 0 2 4v3a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1z",
            }
            path {
                d: "M16 10h.01",
            }
            path {
                d: "M2 8v1a2 2 0 0 0 2 2h1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPilcrowLeft;
impl IconShape for LdPilcrowLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 3v11",
            }
            path {
                d: "M14 9h-3a3 3 0 0 1 0-6h9",
            }
            path {
                d: "M18 3v11",
            }
            path {
                d: "M22 18H2l4-4",
            }
            path {
                d: "m6 22-4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPilcrowRight;
impl IconShape for LdPilcrowRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 3v11",
            }
            path {
                d: "M10 9H7a1 1 0 0 1 0-6h8",
            }
            path {
                d: "M14 3v11",
            }
            path {
                d: "m18 14 4 4H2",
            }
            path {
                d: "m22 18-4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPilcrow;
impl IconShape for LdPilcrow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 4v16",
            }
            path {
                d: "M17 4v16",
            }
            path {
                d: "M19 4H9.5a4.5 4.5 0 0 0 0 9H13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPillBottle;
impl IconShape for LdPillBottle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 11h-4a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1h4",
            }
            path {
                d: "M6 7v13a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V7",
            }
            rect {
                height: "5",
                rx: "1",
                width: "16",
                x: "4",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPill;
impl IconShape for LdPill {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10.5 20.5 10-10a4.95 4.95 0 1 0-7-7l-10 10a4.95 4.95 0 1 0 7 7Z",
            }
            path {
                d: "m8.5 8.5 7 7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPinOff;
impl IconShape for LdPinOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 17v5",
            }
            path {
                d: "M15 9.34V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H7.89",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M9 9v1.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPin;
impl IconShape for LdPin {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 17v5",
            }
            path {
                d: "M9 10.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-.76a2 2 0 0 0-1.11-1.79l-1.78-.9A2 2 0 0 1 15 10.76V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H8a2 2 0 0 0 0 4 1 1 0 0 1 1 1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPipette;
impl IconShape for LdPipette {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12 9-8.414 8.414A2 2 0 0 0 3 18.828v1.344a2 2 0 0 1-.586 1.414A2 2 0 0 1 3.828 21h1.344a2 2 0 0 0 1.414-.586L15 12",
            }
            path {
                d: "m18 9 .4.4a1 1 0 1 1-3 3l-3.8-3.8a1 1 0 1 1 3-3l.4.4 3.4-3.4a1 1 0 1 1 3 3z",
            }
            path {
                d: "m2 22 .414-.414",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPizza;
impl IconShape for LdPizza {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12 14-1 1",
            }
            path {
                d: "m13.75 18.25-1.25 1.42",
            }
            path {
                d: "M17.775 5.654a15.68 15.68 0 0 0-12.121 12.12",
            }
            path {
                d: "M18.8 9.3a1 1 0 0 0 2.1 7.7",
            }
            path {
                d: "M21.964 20.732a1 1 0 0 1-1.232 1.232l-18-5a1 1 0 0 1-.695-1.232A19.68 19.68 0 0 1 15.732 2.037a1 1 0 0 1 1.232.695z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPlaneLanding;
impl IconShape for LdPlaneLanding {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 22h20",
            }
            path {
                d: "M3.77 10.77 2 9l2-4.5 1.1.55c.55.28.9.84.9 1.45s.35 1.17.9 1.45L8 8.5l3-6 1.05.53a2 2 0 0 1 1.09 1.52l.72 5.4a2 2 0 0 0 1.09 1.52l4.4 2.2c.42.22.78.55 1.01.96l.6 1.03c.49.88-.06 1.98-1.06 2.1l-1.18.15c-.47.06-.95-.02-1.37-.24L4.29 11.15a2 2 0 0 1-.52-.38Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPlaneTakeoff;
impl IconShape for LdPlaneTakeoff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 22h20",
            }
            path {
                d: "M6.36 17.4 4 17l-2-4 1.1-.55a2 2 0 0 1 1.8 0l.17.1a2 2 0 0 0 1.8 0L8 12 5 6l.9-.45a2 2 0 0 1 2.09.2l4.02 3a2 2 0 0 0 2.1.2l4.19-2.06a2.41 2.41 0 0 1 1.73-.17L21 7a1.4 1.4 0 0 1 .87 1.99l-.38.76c-.23.46-.6.84-1.07 1.08L7.58 17.2a2 2 0 0 1-1.22.18Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPlane;
impl IconShape for LdPlane {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17.8 19.2 16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPlay;
impl IconShape for LdPlay {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 5a2 2 0 0 1 3.008-1.728l11.997 6.998a2 2 0 0 1 .003 3.458l-12 7A2 2 0 0 1 5 19z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPlug2;
impl IconShape for LdPlug2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 2v6",
            }
            path {
                d: "M15 2v6",
            }
            path {
                d: "M12 17v5",
            }
            path {
                d: "M5 8h14",
            }
            path {
                d: "M6 11V8h12v3a6 6 0 1 1-12 0Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPlugZap;
impl IconShape for LdPlugZap {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6.3 20.3a2.4 2.4 0 0 0 3.4 0L12 18l-6-6-2.3 2.3a2.4 2.4 0 0 0 0 3.4Z",
            }
            path {
                d: "m2 22 3-3",
            }
            path {
                d: "M7.5 13.5 10 11",
            }
            path {
                d: "M10.5 16.5 13 14",
            }
            path {
                d: "m18 3-4 4h6l-4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPlug;
impl IconShape for LdPlug {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 22v-5",
            }
            path {
                d: "M9 8V2",
            }
            path {
                d: "M15 8V2",
            }
            path {
                d: "M18 8v5a4 4 0 0 1-4 4h-4a4 4 0 0 1-4-4V8Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPlus;
impl IconShape for LdPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 12h14",
            }
            path {
                d: "M12 5v14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPocketKnife;
impl IconShape for LdPocketKnife {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 2v1c0 1 2 1 2 2S3 6 3 7s2 1 2 2-2 1-2 2 2 1 2 2",
            }
            path {
                d: "M18 6h.01",
            }
            path {
                d: "M6 18h.01",
            }
            path {
                d: "M20.83 8.83a4 4 0 0 0-5.66-5.66l-12 12a4 4 0 1 0 5.66 5.66Z",
            }
            path {
                d: "M18 11.66V22a4 4 0 0 0 4-4V6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPocket;
impl IconShape for LdPocket {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 3a2 2 0 0 1 2 2v6a1 1 0 0 1-20 0V5a2 2 0 0 1 2-2z",
            }
            path {
                d: "m8 10 4 4 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPodcast;
impl IconShape for LdPodcast {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 17a1 1 0 1 0-2 0l.5 4.5a0.5 0.5 0 0 0 1 0z",
            }
            path {
                d: "M16.85 18.58a9 9 0 1 0-9.7 0",
            }
            path {
                d: "M8 14a5 5 0 1 1 8 0",
            }
            circle {
                cx: "12",
                cy: "11",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPointerOff;
impl IconShape for LdPointerOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 4.5V4a2 2 0 0 0-2.41-1.957",
            }
            path {
                d: "M13.9 8.4a2 2 0 0 0-1.26-1.295",
            }
            path {
                d: "M21.7 16.2A8 8 0 0 0 22 14v-3a2 2 0 1 0-4 0v-1a2 2 0 0 0-3.63-1.158",
            }
            path {
                d: "m7 15-1.8-1.8a2 2 0 0 0-2.79 2.86L6 19.7a7.74 7.74 0 0 0 6 2.3h2a8 8 0 0 0 5.657-2.343",
            }
            path {
                d: "M6 6v8",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPointer;
impl IconShape for LdPointer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 14a8 8 0 0 1-8 8",
            }
            path {
                d: "M18 11v-1a2 2 0 0 0-2-2a2 2 0 0 0-2 2",
            }
            path {
                d: "M14 10V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1",
            }
            path {
                d: "M10 9.5V4a2 2 0 0 0-2-2a2 2 0 0 0-2 2v10",
            }
            path {
                d: "M18 11a2 2 0 1 1 4 0v3a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPopcorn;
impl IconShape for LdPopcorn {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 8a2 2 0 0 0 0-4 2 2 0 0 0-4 0 2 2 0 0 0-4 0 2 2 0 0 0-4 0 2 2 0 0 0 0 4",
            }
            path {
                d: "M10 22 9 8",
            }
            path {
                d: "m14 22 1-14",
            }
            path {
                d: "M20 8c.5 0 .9.4.8 1l-2.6 12c-.1.5-.7 1-1.2 1H7c-.6 0-1.1-.4-1.2-1L3.2 9c-.1-.6.3-1 .8-1Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPopsicle;
impl IconShape for LdPopsicle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18.6 14.4c.8-.8.8-2 0-2.8l-8.1-8.1a4.95 4.95 0 1 0-7.1 7.1l8.1 8.1c.9.7 2.1.7 2.9-.1Z",
            }
            path {
                d: "m22 22-5.5-5.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPoundSterling;
impl IconShape for LdPoundSterling {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 7c0-5.333-8-5.333-8 0",
            }
            path {
                d: "M10 7v14",
            }
            path {
                d: "M6 21h12",
            }
            path {
                d: "M6 13h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPowerOff;
impl IconShape for LdPowerOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18.36 6.64A9 9 0 0 1 20.77 15",
            }
            path {
                d: "M6.16 6.16a9 9 0 1 0 12.68 12.68",
            }
            path {
                d: "M12 2v4",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPower;
impl IconShape for LdPower {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v10",
            }
            path {
                d: "M18.4 6.6a9 9 0 1 1-12.77.04",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPresentation;
impl IconShape for LdPresentation {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 3h20",
            }
            path {
                d: "M21 3v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V3",
            }
            path {
                d: "m7 21 5-5 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPrinterCheck;
impl IconShape for LdPrinterCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.5 22H7a1 1 0 0 1-1-1v-6a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v.5",
            }
            path {
                d: "m16 19 2 2 4-4",
            }
            path {
                d: "M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M6 9V3a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPrinter;
impl IconShape for LdPrinter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M6 9V3a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v6",
            }
            rect {
                height: "8",
                rx: "1",
                width: "12",
                x: "6",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdProjector;
impl IconShape for LdProjector {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 7 3 5",
            }
            path {
                d: "M9 6V3",
            }
            path {
                d: "m13 7 2-2",
            }
            circle {
                cx: "9",
                cy: "13",
                r: "3",
            }
            path {
                d: "M11.83 12H20a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-4a2 2 0 0 1 2-2h2.17",
            }
            path {
                d: "M16 16h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdProportions;
impl IconShape for LdProportions {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
            path {
                d: "M12 9v11",
            }
            path {
                d: "M2 9h13a2 2 0 0 1 2 2v9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPuzzle;
impl IconShape for LdPuzzle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.39 4.39a1 1 0 0 0 1.68-.474 2.5 2.5 0 1 1 3.014 3.015 1 1 0 0 0-.474 1.68l1.683 1.682a2.414 2.414 0 0 1 0 3.414L19.61 15.39a1 1 0 0 1-1.68-.474 2.5 2.5 0 1 0-3.014 3.015 1 1 0 0 1 .474 1.68l-1.683 1.682a2.414 2.414 0 0 1-3.414 0L8.61 19.61a1 1 0 0 0-1.68.474 2.5 2.5 0 1 1-3.014-3.015 1 1 0 0 0 .474-1.68l-1.683-1.682a2.414 2.414 0 0 1 0-3.414L4.39 8.61a1 1 0 0 1 1.68.474 2.5 2.5 0 1 0 3.014-3.015 1 1 0 0 1-.474-1.68l1.683-1.682a2.414 2.414 0 0 1 3.414 0z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdPyramid;
impl IconShape for LdPyramid {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.5 16.88a1 1 0 0 1-.32-1.43l9-13.02a1 1 0 0 1 1.64 0l9 13.01a1 1 0 0 1-.32 1.44l-8.51 4.86a2 2 0 0 1-1.98 0Z",
            }
            path {
                d: "M12 2v20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdQrCode;
impl IconShape for LdQrCode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "5",
                rx: "1",
                width: "5",
                x: "3",
                y: "3",
            }
            rect {
                height: "5",
                rx: "1",
                width: "5",
                x: "16",
                y: "3",
            }
            rect {
                height: "5",
                rx: "1",
                width: "5",
                x: "3",
                y: "16",
            }
            path {
                d: "M21 16h-3a2 2 0 0 0-2 2v3",
            }
            path {
                d: "M21 21v.01",
            }
            path {
                d: "M12 7v3a2 2 0 0 1-2 2H7",
            }
            path {
                d: "M3 12h.01",
            }
            path {
                d: "M12 3h.01",
            }
            path {
                d: "M12 16v.01",
            }
            path {
                d: "M16 12h1",
            }
            path {
                d: "M21 12v.01",
            }
            path {
                d: "M12 21v-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdQuote;
impl IconShape for LdQuote {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z",
            }
            path {
                d: "M5 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRabbit;
impl IconShape for LdRabbit {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 16a3 3 0 0 1 2.24 5",
            }
            path {
                d: "M18 12h.01",
            }
            path {
                d: "M18 21h-8a4 4 0 0 1-4-4 7 7 0 0 1 7-7h.2L9.6 6.4a1 1 0 1 1 2.8-2.8L15.8 7h.2c3.3 0 6 2.7 6 6v1a2 2 0 0 1-2 2h-1a3 3 0 0 0-3 3",
            }
            path {
                d: "M20 8.54V4a2 2 0 1 0-4 0v3",
            }
            path {
                d: "M7.612 12.524a3 3 0 1 0-1.6 4.3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRadar;
impl IconShape for LdRadar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19.07 4.93A10 10 0 0 0 6.99 3.34",
            }
            path {
                d: "M4 6h.01",
            }
            path {
                d: "M2.29 9.62A10 10 0 1 0 21.31 8.35",
            }
            path {
                d: "M16.24 7.76A6 6 0 1 0 8.23 16.67",
            }
            path {
                d: "M12 18h.01",
            }
            path {
                d: "M17.99 11.66A6 6 0 0 1 15.77 16.67",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
            path {
                d: "m13.41 10.59 5.66-5.66",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRadiation;
impl IconShape for LdRadiation {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 12h.01",
            }
            path {
                d: "M14 15.4641a4 4 0 0 1-4 0L7.52786 19.74597 A 1 1 0 0 0 7.99303 21.16211 10 10 0 0 0 16.00697 21.16211 1 1 0 0 0 16.47214 19.74597z",
            }
            path {
                d: "M16 12a4 4 0 0 0-2-3.464l2.472-4.282a1 1 0 0 1 1.46-.305 10 10 0 0 1 4.006 6.94A1 1 0 0 1 21 12z",
            }
            path {
                d: "M8 12a4 4 0 0 1 2-3.464L7.528 4.254a1 1 0 0 0-1.46-.305 10 10 0 0 0-4.006 6.94A1 1 0 0 0 3 12z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRadical;
impl IconShape for LdRadical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 12h3.28a1 1 0 0 1 .948.684l2.298 7.934a.5.5 0 0 0 .96-.044L13.82 4.771A1 1 0 0 1 14.792 4H21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRadioReceiver;
impl IconShape for LdRadioReceiver {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 16v2",
            }
            path {
                d: "M19 16v2",
            }
            rect {
                height: "8",
                rx: "2",
                width: "20",
                x: "2",
                y: "8",
            }
            path {
                d: "M18 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRadioTower;
impl IconShape for LdRadioTower {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4.9 16.1C1 12.2 1 5.8 4.9 1.9",
            }
            path {
                d: "M7.8 4.7a6.14 6.14 0 0 0-.8 7.5",
            }
            circle {
                cx: "12",
                cy: "9",
                r: "2",
            }
            path {
                d: "M16.2 4.8c2 2 2.26 5.11.8 7.47",
            }
            path {
                d: "M19.1 1.9a9.96 9.96 0 0 1 0 14.1",
            }
            path {
                d: "M9.5 18h5",
            }
            path {
                d: "m8 22 4-11 4 11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRadio;
impl IconShape for LdRadio {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16.247 7.761a6 6 0 0 1 0 8.478",
            }
            path {
                d: "M19.075 4.933a10 10 0 0 1 0 14.134",
            }
            path {
                d: "M4.925 19.067a10 10 0 0 1 0-14.134",
            }
            path {
                d: "M7.753 16.239a6 6 0 0 1 0-8.478",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRadius;
impl IconShape for LdRadius {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20.34 17.52a10 10 0 1 0-2.82 2.82",
            }
            circle {
                cx: "19",
                cy: "19",
                r: "2",
            }
            path {
                d: "m13.41 13.41 4.18 4.18",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRailSymbol;
impl IconShape for LdRailSymbol {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 15h14",
            }
            path {
                d: "M5 9h14",
            }
            path {
                d: "m14 20-5-5 6-6-5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRainbow;
impl IconShape for LdRainbow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17a10 10 0 0 0-20 0",
            }
            path {
                d: "M6 17a6 6 0 0 1 12 0",
            }
            path {
                d: "M10 17a2 2 0 0 1 4 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRat;
impl IconShape for LdRat {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 22H4a2 2 0 0 1 0-4h12",
            }
            path {
                d: "M13.236 18a3 3 0 0 0-2.2-5",
            }
            path {
                d: "M16 9h.01",
            }
            path {
                d: "M16.82 3.94a3 3 0 1 1 3.237 4.868l1.815 2.587a1.5 1.5 0 0 1-1.5 2.1l-2.872-.453a3 3 0 0 0-3.5 3",
            }
            path {
                d: "M17 4.988a3 3 0 1 0-5.2 2.052A7 7 0 0 0 4 14.015 4 4 0 0 0 8 18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRatio;
impl IconShape for LdRatio {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "2",
                width: "12",
                x: "6",
                y: "2",
            }
            rect {
                height: "12",
                rx: "2",
                width: "20",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReceiptCent;
impl IconShape for LdReceiptCent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z",
            }
            path {
                d: "M12 6.5v11",
            }
            path {
                d: "M15 9.4a4 4 0 1 0 0 5.2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReceiptEuro;
impl IconShape for LdReceiptEuro {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z",
            }
            path {
                d: "M8 12h5",
            }
            path {
                d: "M16 9.5a4 4 0 1 0 0 5.2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReceiptIndianRupee;
impl IconShape for LdReceiptIndianRupee {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z",
            }
            path {
                d: "M8 7h8",
            }
            path {
                d: "M12 17.5 8 15h1a4 4 0 0 0 0-8",
            }
            path {
                d: "M8 11h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReceiptJapaneseYen;
impl IconShape for LdReceiptJapaneseYen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z",
            }
            path {
                d: "m12 10 3-3",
            }
            path {
                d: "m9 7 3 3v7.5",
            }
            path {
                d: "M9 11h6",
            }
            path {
                d: "M9 15h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReceiptPoundSterling;
impl IconShape for LdReceiptPoundSterling {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z",
            }
            path {
                d: "M8 13h5",
            }
            path {
                d: "M10 17V9.5a2.5 2.5 0 0 1 5 0",
            }
            path {
                d: "M8 17h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReceiptRussianRuble;
impl IconShape for LdReceiptRussianRuble {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z",
            }
            path {
                d: "M8 15h5",
            }
            path {
                d: "M8 11h5a2 2 0 1 0 0-4h-3v10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReceiptSwissFranc;
impl IconShape for LdReceiptSwissFranc {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z",
            }
            path {
                d: "M10 17V7h5",
            }
            path {
                d: "M10 11h4",
            }
            path {
                d: "M8 15h5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReceiptText;
impl IconShape for LdReceiptText {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 16H8",
            }
            path {
                d: "M14 8H8",
            }
            path {
                d: "M16 12H8",
            }
            path {
                d: "M4 3a1 1 0 0 1 1-1 1.3 1.3 0 0 1 .7.2l.933.6a1.3 1.3 0 0 0 1.4 0l.934-.6a1.3 1.3 0 0 1 1.4 0l.933.6a1.3 1.3 0 0 0 1.4 0l.933-.6a1.3 1.3 0 0 1 1.4 0l.934.6a1.3 1.3 0 0 0 1.4 0l.933-.6A1.3 1.3 0 0 1 19 2a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1 1.3 1.3 0 0 1-.7-.2l-.933-.6a1.3 1.3 0 0 0-1.4 0l-.934.6a1.3 1.3 0 0 1-1.4 0l-.933-.6a1.3 1.3 0 0 0-1.4 0l-.933.6a1.3 1.3 0 0 1-1.4 0l-.934-.6a1.3 1.3 0 0 0-1.4 0l-.933.6a1.3 1.3 0 0 1-.7.2 1 1 0 0 1-1-1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReceiptTurkishLira;
impl IconShape for LdReceiptTurkishLira {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 6.5v11a5.5 5.5 0 0 0 5.5-5.5",
            }
            path {
                d: "m14 8-6 3",
            }
            path {
                d: "M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReceipt;
impl IconShape for LdReceipt {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z",
            }
            path {
                d: "M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8",
            }
            path {
                d: "M12 17.5v-11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRectangleCircle;
impl IconShape for LdRectangleCircle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 4v16H3a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1z",
            }
            circle {
                cx: "14",
                cy: "12",
                r: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRectangleEllipsis;
impl IconShape for LdRectangleEllipsis {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "12",
                rx: "2",
                width: "20",
                x: "2",
                y: "6",
            }
            path {
                d: "M12 12h.01",
            }
            path {
                d: "M17 12h.01",
            }
            path {
                d: "M7 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRectangleGoggles;
impl IconShape for LdRectangleGoggles {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 6a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-4a2 2 0 0 1-1.6-.8l-1.6-2.13a1 1 0 0 0-1.6 0L9.6 17.2A2 2 0 0 1 8 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRectangleHorizontal;
impl IconShape for LdRectangleHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "12",
                rx: "2",
                width: "20",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRectangleVertical;
impl IconShape for LdRectangleVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "2",
                width: "12",
                x: "6",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRecycle;
impl IconShape for LdRecycle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 19H4.815a1.83 1.83 0 0 1-1.57-.881 1.785 1.785 0 0 1-.004-1.784L7.196 9.5",
            }
            path {
                d: "M11 19h8.203a1.83 1.83 0 0 0 1.556-.89 1.784 1.784 0 0 0 0-1.775l-1.226-2.12",
            }
            path {
                d: "m14 16-3 3 3 3",
            }
            path {
                d: "M8.293 13.596 7.196 9.5 3.1 10.598",
            }
            path {
                d: "m9.344 5.811 1.093-1.892A1.83 1.83 0 0 1 11.985 3a1.784 1.784 0 0 1 1.546.888l3.943 6.843",
            }
            path {
                d: "m13.378 9.633 4.096 1.098 1.097-4.096",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRedo2;
impl IconShape for LdRedo2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 14 5-5-5-5",
            }
            path {
                d: "M20 9H9.5A5.5 5.5 0 0 0 4 14.5A5.5 5.5 0 0 0 9.5 20H13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRedoDot;
impl IconShape for LdRedoDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "17",
                r: "1",
            }
            path {
                d: "M21 7v6h-6",
            }
            path {
                d: "M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRedo;
impl IconShape for LdRedo {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 7v6h-6",
            }
            path {
                d: "M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRefreshCcwDot;
impl IconShape for LdRefreshCcwDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8",
            }
            path {
                d: "M3 3v5h5",
            }
            path {
                d: "M3 12a9 9 0 0 0 9 9 9.75 9.75 0 0 0 6.74-2.74L21 16",
            }
            path {
                d: "M16 16h5v5",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRefreshCcw;
impl IconShape for LdRefreshCcw {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8",
            }
            path {
                d: "M3 3v5h5",
            }
            path {
                d: "M3 12a9 9 0 0 0 9 9 9.75 9.75 0 0 0 6.74-2.74L21 16",
            }
            path {
                d: "M16 16h5v5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRefreshCwOff;
impl IconShape for LdRefreshCwOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 8L18.74 5.74A9.75 9.75 0 0 0 12 3C11 3 10.03 3.16 9.13 3.47",
            }
            path {
                d: "M8 16H3v5",
            }
            path {
                d: "M3 12C3 9.51 4 7.26 5.64 5.64",
            }
            path {
                d: "m3 16 2.26 2.26A9.75 9.75 0 0 0 12 21c2.49 0 4.74-1 6.36-2.64",
            }
            path {
                d: "M21 12c0 1-.16 1.97-.47 2.87",
            }
            path {
                d: "M21 3v5h-5",
            }
            path {
                d: "M22 22 2 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRefreshCw;
impl IconShape for LdRefreshCw {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8",
            }
            path {
                d: "M21 3v5h-5",
            }
            path {
                d: "M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16",
            }
            path {
                d: "M8 16H3v5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRefrigerator;
impl IconShape for LdRefrigerator {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 6a4 4 0 0 1 4-4h6a4 4 0 0 1 4 4v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6Z",
            }
            path {
                d: "M5 10h14",
            }
            path {
                d: "M15 7v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRegex;
impl IconShape for LdRegex {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 3v10",
            }
            path {
                d: "m12.67 5.5 8.66 5",
            }
            path {
                d: "m12.67 10.5 8.66-5",
            }
            path {
                d: "M9 17a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRemoveFormatting;
impl IconShape for LdRemoveFormatting {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 7V4h16v3",
            }
            path {
                d: "M5 20h6",
            }
            path {
                d: "M13 4 8 20",
            }
            path {
                d: "m15 15 5 5",
            }
            path {
                d: "m20 15-5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRepeat1;
impl IconShape for LdRepeat1 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m17 2 4 4-4 4",
            }
            path {
                d: "M3 11v-1a4 4 0 0 1 4-4h14",
            }
            path {
                d: "m7 22-4-4 4-4",
            }
            path {
                d: "M21 13v1a4 4 0 0 1-4 4H3",
            }
            path {
                d: "M11 10h1v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRepeat2;
impl IconShape for LdRepeat2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 9 3-3 3 3",
            }
            path {
                d: "M13 18H7a2 2 0 0 1-2-2V6",
            }
            path {
                d: "m22 15-3 3-3-3",
            }
            path {
                d: "M11 6h6a2 2 0 0 1 2 2v10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRepeat;
impl IconShape for LdRepeat {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m17 2 4 4-4 4",
            }
            path {
                d: "M3 11v-1a4 4 0 0 1 4-4h14",
            }
            path {
                d: "m7 22-4-4 4-4",
            }
            path {
                d: "M21 13v1a4 4 0 0 1-4 4H3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReplaceAll;
impl IconShape for LdReplaceAll {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 14a1 1 0 0 1 1 1v5a1 1 0 0 1-1 1",
            }
            path {
                d: "M14 4a1 1 0 0 1 1-1",
            }
            path {
                d: "M15 10a1 1 0 0 1-1-1",
            }
            path {
                d: "M19 14a1 1 0 0 1 1 1v5a1 1 0 0 1-1 1",
            }
            path {
                d: "M21 4a1 1 0 0 0-1-1",
            }
            path {
                d: "M21 9a1 1 0 0 1-1 1",
            }
            path {
                d: "m3 7 3 3 3-3",
            }
            path {
                d: "M6 10V5a2 2 0 0 1 2-2h2",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "3",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReplace;
impl IconShape for LdReplace {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 4a1 1 0 0 1 1-1",
            }
            path {
                d: "M15 10a1 1 0 0 1-1-1",
            }
            path {
                d: "M21 4a1 1 0 0 0-1-1",
            }
            path {
                d: "M21 9a1 1 0 0 1-1 1",
            }
            path {
                d: "m3 7 3 3 3-3",
            }
            path {
                d: "M6 10V5a2 2 0 0 1 2-2h2",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "3",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReplyAll;
impl IconShape for LdReplyAll {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12 17-5-5 5-5",
            }
            path {
                d: "M22 18v-2a4 4 0 0 0-4-4H7",
            }
            path {
                d: "m7 17-5-5 5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdReply;
impl IconShape for LdReply {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 18v-2a4 4 0 0 0-4-4H4",
            }
            path {
                d: "m9 17-5-5 5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRewind;
impl IconShape for LdRewind {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 6a2 2 0 0 0-3.414-1.414l-6 6a2 2 0 0 0 0 2.828l6 6A2 2 0 0 0 12 18z",
            }
            path {
                d: "M22 6a2 2 0 0 0-3.414-1.414l-6 6a2 2 0 0 0 0 2.828l6 6A2 2 0 0 0 22 18z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRibbon;
impl IconShape for LdRibbon {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 11.22C11 9.997 10 9 10 8a2 2 0 0 1 4 0c0 1-.998 2.002-2.01 3.22",
            }
            path {
                d: "m12 18 2.57-3.5",
            }
            path {
                d: "M6.243 9.016a7 7 0 0 1 11.507-.009",
            }
            path {
                d: "M9.35 14.53 12 11.22",
            }
            path {
                d: "M9.35 14.53C7.728 12.246 6 10.221 6 7a6 5 0 0 1 12 0c-.005 3.22-1.778 5.235-3.43 7.5l3.557 4.527a1 1 0 0 1-.203 1.43l-1.894 1.36a1 1 0 0 1-1.384-.215L12 18l-2.679 3.593a1 1 0 0 1-1.39.213l-1.865-1.353a1 1 0 0 1-.203-1.422z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRocket;
impl IconShape for LdRocket {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4.5 16.5c-1.5 1.26-2 5-2 5s3.74-.5 5-2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z",
            }
            path {
                d: "m12 15-3-3a22 22 0 0 1 2-3.95A12.88 12.88 0 0 1 22 2c0 2.72-.78 7.5-6 11a22.35 22.35 0 0 1-4 2z",
            }
            path {
                d: "M9 12H4s.55-3.03 2-4c1.62-1.08 5 0 5 0",
            }
            path {
                d: "M12 15v5s3.03-.55 4-2c1.08-1.62 0-5 0-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRockingChair;
impl IconShape for LdRockingChair {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            polyline {
                points: "3.5 2 6.5 12.5 18 12.5",
            }
            line {
                x1: "9.5",
                x2: "5.5",
                y1: "12.5",
                y2: "20",
            }
            line {
                x1: "15",
                x2: "18.5",
                y1: "12.5",
                y2: "20",
            }
            path {
                d: "M2.75 18a13 13 0 0 0 18.5 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRollerCoaster;
impl IconShape for LdRollerCoaster {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 19V5",
            }
            path {
                d: "M10 19V6.8",
            }
            path {
                d: "M14 19v-7.8",
            }
            path {
                d: "M18 5v4",
            }
            path {
                d: "M18 19v-6",
            }
            path {
                d: "M22 19V9",
            }
            path {
                d: "M2 19V9a4 4 0 0 1 4-4c2 0 4 1.33 6 4s4 4 6 4a4 4 0 1 0-3-6.65",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRose;
impl IconShape for LdRose {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 10h-1a4 4 0 1 1 4-4v.534",
            }
            path {
                d: "M17 6h1a4 4 0 0 1 1.42 7.74l-2.29.87a6 6 0 0 1-5.339-10.68l2.069-1.31",
            }
            path {
                d: "M4.5 17c2.8-.5 4.4 0 5.5.8s1.8 2.2 2.3 3.7c-2 .4-3.5.4-4.8-.3-1.2-.6-2.3-1.9-3-4.2",
            }
            path {
                d: "M9.77 12C4 15 2 22 2 22",
            }
            circle {
                cx: "17",
                cy: "8",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRotate3d;
impl IconShape for LdRotate3d {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16.466 7.5C15.643 4.237 13.952 2 12 2 9.239 2 7 6.477 7 12s2.239 10 5 10c.342 0 .677-.069 1-.2",
            }
            path {
                d: "m15.194 13.707 3.814 1.86-1.86 3.814",
            }
            path {
                d: "M19 15.57c-1.804.885-4.274 1.43-7 1.43-5.523 0-10-2.239-10-5s4.477-5 10-5c4.838 0 8.873 1.718 9.8 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRotateCcwKey;
impl IconShape for LdRotateCcwKey {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14.5 9.5 1 1",
            }
            path {
                d: "m15.5 8.5-4 4",
            }
            path {
                d: "M3 12a9 9 0 1 0 9-9 9.74 9.74 0 0 0-6.74 2.74L3 8",
            }
            path {
                d: "M3 3v5h5",
            }
            circle {
                cx: "10",
                cy: "14",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRotateCcwSquare;
impl IconShape for LdRotateCcwSquare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 9V7a2 2 0 0 0-2-2h-6",
            }
            path {
                d: "m15 2-3 3 3 3",
            }
            path {
                d: "M20 13v5a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRotateCcw;
impl IconShape for LdRotateCcw {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8",
            }
            path {
                d: "M3 3v5h5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRotateCwSquare;
impl IconShape for LdRotateCwSquare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 5H6a2 2 0 0 0-2 2v3",
            }
            path {
                d: "m9 8 3-3-3-3",
            }
            path {
                d: "M4 14v4a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRotateCw;
impl IconShape for LdRotateCw {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8",
            }
            path {
                d: "M21 3v5h-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRouteOff;
impl IconShape for LdRouteOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "6",
                cy: "19",
                r: "3",
            }
            path {
                d: "M9 19h8.5c.4 0 .9-.1 1.3-.2",
            }
            path {
                d: "M5.2 5.2A3.5 3.53 0 0 0 6.5 12H12",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M21 15.3a3.5 3.5 0 0 0-3.3-3.3",
            }
            path {
                d: "M15 5h-4.3",
            }
            circle {
                cx: "18",
                cy: "5",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRoute;
impl IconShape for LdRoute {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "6",
                cy: "19",
                r: "3",
            }
            path {
                d: "M9 19h8.5a3.5 3.5 0 0 0 0-7h-11a3.5 3.5 0 0 1 0-7H15",
            }
            circle {
                cx: "18",
                cy: "5",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRouter;
impl IconShape for LdRouter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "8",
                rx: "2",
                width: "20",
                x: "2",
                y: "14",
            }
            path {
                d: "M6.01 18H6",
            }
            path {
                d: "M10.01 18H10",
            }
            path {
                d: "M15 10v4",
            }
            path {
                d: "M17.84 7.17a4 4 0 0 0-5.66 0",
            }
            path {
                d: "M20.66 4.34a8 8 0 0 0-11.31 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRows2;
impl IconShape for LdRows2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 12h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRows3;
impl IconShape for LdRows3 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M21 9H3",
            }
            path {
                d: "M21 15H3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRows4;
impl IconShape for LdRows4 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M21 7.5H3",
            }
            path {
                d: "M21 12H3",
            }
            path {
                d: "M21 16.5H3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRss;
impl IconShape for LdRss {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 11a9 9 0 0 1 9 9",
            }
            path {
                d: "M4 4a16 16 0 0 1 16 16",
            }
            circle {
                cx: "5",
                cy: "19",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRulerDimensionLine;
impl IconShape for LdRulerDimensionLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 15v-3",
            }
            path {
                d: "M14 15v-3",
            }
            path {
                d: "M18 15v-3",
            }
            path {
                d: "M2 8V4",
            }
            path {
                d: "M22 6H2",
            }
            path {
                d: "M22 8V4",
            }
            path {
                d: "M6 15v-3",
            }
            rect {
                height: "8",
                rx: "2",
                width: "20",
                x: "2",
                y: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRuler;
impl IconShape for LdRuler {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21.3 15.3a2.4 2.4 0 0 1 0 3.4l-2.6 2.6a2.4 2.4 0 0 1-3.4 0L2.7 8.7a2.41 2.41 0 0 1 0-3.4l2.6-2.6a2.41 2.41 0 0 1 3.4 0Z",
            }
            path {
                d: "m14.5 12.5 2-2",
            }
            path {
                d: "m11.5 9.5 2-2",
            }
            path {
                d: "m8.5 6.5 2-2",
            }
            path {
                d: "m17.5 15.5 2-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdRussianRuble;
impl IconShape for LdRussianRuble {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 11h8a4 4 0 0 0 0-8H9v18",
            }
            path {
                d: "M6 15h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSailboat;
impl IconShape for LdSailboat {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2v15",
            }
            path {
                d: "M7 22a4 4 0 0 1-4-4 1 1 0 0 1 1-1h16a1 1 0 0 1 1 1 4 4 0 0 1-4 4z",
            }
            path {
                d: "M9.159 2.46a1 1 0 0 1 1.521-.193l9.977 8.98A1 1 0 0 1 20 13H4a1 1 0 0 1-.824-1.567z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSalad;
impl IconShape for LdSalad {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 21h10",
            }
            path {
                d: "M12 21a9 9 0 0 0 9-9H3a9 9 0 0 0 9 9Z",
            }
            path {
                d: "M11.38 12a2.4 2.4 0 0 1-.4-4.77 2.4 2.4 0 0 1 3.2-2.77 2.4 2.4 0 0 1 3.47-.63 2.4 2.4 0 0 1 3.37 3.37 2.4 2.4 0 0 1-1.1 3.7 2.51 2.51 0 0 1 .03 1.1",
            }
            path {
                d: "m13 12 4-4",
            }
            path {
                d: "M10.9 7.25A3.99 3.99 0 0 0 4 10c0 .73.2 1.41.54 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSandwich;
impl IconShape for LdSandwich {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2.37 11.223 8.372-6.777a2 2 0 0 1 2.516 0l8.371 6.777",
            }
            path {
                d: "M21 15a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1h-5.25",
            }
            path {
                d: "M3 15a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h9",
            }
            path {
                d: "m6.67 15 6.13 4.6a2 2 0 0 0 2.8-.4l3.15-4.2",
            }
            rect {
                height: "4",
                rx: "1",
                width: "20",
                x: "2",
                y: "11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSatelliteDish;
impl IconShape for LdSatelliteDish {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 10a7.31 7.31 0 0 0 10 10Z",
            }
            path {
                d: "m9 15 3-3",
            }
            path {
                d: "M17 13a6 6 0 0 0-6-6",
            }
            path {
                d: "M21 13A10 10 0 0 0 11 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSatellite;
impl IconShape for LdSatellite {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m13.5 6.5-3.148-3.148a1.205 1.205 0 0 0-1.704 0L6.352 5.648a1.205 1.205 0 0 0 0 1.704L9.5 10.5",
            }
            path {
                d: "M16.5 7.5 19 5",
            }
            path {
                d: "m17.5 10.5 3.148 3.148a1.205 1.205 0 0 1 0 1.704l-2.296 2.296a1.205 1.205 0 0 1-1.704 0L13.5 14.5",
            }
            path {
                d: "M9 21a6 6 0 0 0-6-6",
            }
            path {
                d: "M9.352 10.648a1.205 1.205 0 0 0 0 1.704l2.296 2.296a1.205 1.205 0 0 0 1.704 0l4.296-4.296a1.205 1.205 0 0 0 0-1.704l-2.296-2.296a1.205 1.205 0 0 0-1.704 0z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSaudiRiyal;
impl IconShape for LdSaudiRiyal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m20 19.5-5.5 1.2",
            }
            path {
                d: "M14.5 4v11.22a1 1 0 0 0 1.242.97L20 15.2",
            }
            path {
                d: "m2.978 19.351 5.549-1.363A2 2 0 0 0 10 16V2",
            }
            path {
                d: "M20 10 4 13.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSaveAll;
impl IconShape for LdSaveAll {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2v3a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M18 18v-6a1 1 0 0 0-1-1h-6a1 1 0 0 0-1 1v6",
            }
            path {
                d: "M18 22H4a2 2 0 0 1-2-2V6",
            }
            path {
                d: "M8 18a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9.172a2 2 0 0 1 1.414.586l2.828 2.828A2 2 0 0 1 22 6.828V16a2 2 0 0 1-2.01 2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSaveOff;
impl IconShape for LdSaveOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 13H8a1 1 0 0 0-1 1v7",
            }
            path {
                d: "M14 8h1",
            }
            path {
                d: "M17 21v-4",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M20.41 20.41A2 2 0 0 1 19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 .59-1.41",
            }
            path {
                d: "M29.5 11.5s5 5 4 5",
            }
            path {
                d: "M9 3h6.2a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4V15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSave;
impl IconShape for LdSave {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.2 3a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2z",
            }
            path {
                d: "M17 21v-7a1 1 0 0 0-1-1H8a1 1 0 0 0-1 1v7",
            }
            path {
                d: "M7 3v4a1 1 0 0 0 1 1h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScale3d;
impl IconShape for LdScale3d {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 7v11a1 1 0 0 0 1 1h11",
            }
            path {
                d: "M5.293 18.707 11 13",
            }
            circle {
                cx: "19",
                cy: "19",
                r: "2",
            }
            circle {
                cx: "5",
                cy: "5",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScale;
impl IconShape for LdScale {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v18",
            }
            path {
                d: "m19 8 3 8a5 5 0 0 1-6 0zV7",
            }
            path {
                d: "M3 7h1a17 17 0 0 0 8-2 17 17 0 0 0 8 2h1",
            }
            path {
                d: "m5 8 3 8a5 5 0 0 1-6 0zV7",
            }
            path {
                d: "M7 21h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScaling;
impl IconShape for LdScaling {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7",
            }
            path {
                d: "M14 15H9v-5",
            }
            path {
                d: "M16 3h5v5",
            }
            path {
                d: "M21 3 9 15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScanBarcode;
impl IconShape for LdScanBarcode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
            path {
                d: "M8 7v10",
            }
            path {
                d: "M12 7v10",
            }
            path {
                d: "M17 7v10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScanEye;
impl IconShape for LdScanEye {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "1",
            }
            path {
                d: "M18.944 12.33a1 1 0 0 0 0-.66 7.5 7.5 0 0 0-13.888 0 1 1 0 0 0 0 .66 7.5 7.5 0 0 0 13.888 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScanFace;
impl IconShape for LdScanFace {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
            path {
                d: "M8 14s1.5 2 4 2 4-2 4-2",
            }
            path {
                d: "M9 9h.01",
            }
            path {
                d: "M15 9h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScanHeart;
impl IconShape for LdScanHeart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
            path {
                d: "M7.828 13.07A3 3 0 0 1 12 8.764a3 3 0 0 1 4.172 4.306l-3.447 3.62a1 1 0 0 1-1.449 0z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScanLine;
impl IconShape for LdScanLine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
            path {
                d: "M7 12h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScanQrCode;
impl IconShape for LdScanQrCode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 12v4a1 1 0 0 1-1 1h-4",
            }
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M17 8V7",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M7 17h.01",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
            rect {
                height: "5",
                rx: "1",
                width: "5",
                x: "7",
                y: "7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScanSearch;
impl IconShape for LdScanSearch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
            path {
                d: "m16 16-1.9-1.9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScanText;
impl IconShape for LdScanText {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
            path {
                d: "M7 8h8",
            }
            path {
                d: "M7 12h10",
            }
            path {
                d: "M7 16h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScan;
impl IconShape for LdScan {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 7V5a2 2 0 0 1 2-2h2",
            }
            path {
                d: "M17 3h2a2 2 0 0 1 2 2v2",
            }
            path {
                d: "M21 17v2a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M7 21H5a2 2 0 0 1-2-2v-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSchool;
impl IconShape for LdSchool {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 21v-3a2 2 0 0 0-4 0v3",
            }
            path {
                d: "M18 5v16",
            }
            path {
                d: "m4 6 7.106-3.79a2 2 0 0 1 1.788 0L20 6",
            }
            path {
                d: "m6 11-3.52 2.147a1 1 0 0 0-.48.854V19a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-5a1 1 0 0 0-.48-.853L18 11",
            }
            path {
                d: "M6 5v16",
            }
            circle {
                cx: "12",
                cy: "9",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScissorsLineDashed;
impl IconShape for LdScissorsLineDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5.42 9.42 8 12",
            }
            circle {
                cx: "4",
                cy: "8",
                r: "2",
            }
            path {
                d: "m14 6-8.58 8.58",
            }
            circle {
                cx: "4",
                cy: "16",
                r: "2",
            }
            path {
                d: "M10.8 14.8 14 18",
            }
            path {
                d: "M16 12h-2",
            }
            path {
                d: "M22 12h-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScissors;
impl IconShape for LdScissors {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "6",
                cy: "6",
                r: "3",
            }
            path {
                d: "M8.12 8.12 12 12",
            }
            path {
                d: "M20 4 8.12 15.88",
            }
            circle {
                cx: "6",
                cy: "18",
                r: "3",
            }
            path {
                d: "M14.8 14.8 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScreenShareOff;
impl IconShape for LdScreenShareOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 3H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-3",
            }
            path {
                d: "M8 21h8",
            }
            path {
                d: "M12 17v4",
            }
            path {
                d: "m22 3-5 5",
            }
            path {
                d: "m17 3 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScreenShare;
impl IconShape for LdScreenShare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 3H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-3",
            }
            path {
                d: "M8 21h8",
            }
            path {
                d: "M12 17v4",
            }
            path {
                d: "m17 8 5-5",
            }
            path {
                d: "M17 3h5v5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScrollText;
impl IconShape for LdScrollText {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 12h-5",
            }
            path {
                d: "M15 8h-5",
            }
            path {
                d: "M19 17V5a2 2 0 0 0-2-2H4",
            }
            path {
                d: "M8 21h12a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1H11a1 1 0 0 0-1 1v1a2 2 0 1 1-4 0V5a2 2 0 1 0-4 0v2a1 1 0 0 0 1 1h3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdScroll;
impl IconShape for LdScroll {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 17V5a2 2 0 0 0-2-2H4",
            }
            path {
                d: "M8 21h12a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1H11a1 1 0 0 0-1 1v1a2 2 0 1 1-4 0V5a2 2 0 1 0-4 0v2a1 1 0 0 0 1 1h3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSearchCheck;
impl IconShape for LdSearchCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m8 11 2 2 4-4",
            }
            circle {
                cx: "11",
                cy: "11",
                r: "8",
            }
            path {
                d: "m21 21-4.3-4.3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSearchCode;
impl IconShape for LdSearchCode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m13 13.5 2-2.5-2-2.5",
            }
            path {
                d: "m21 21-4.3-4.3",
            }
            path {
                d: "M9 8.5 7 11l2 2.5",
            }
            circle {
                cx: "11",
                cy: "11",
                r: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSearchSlash;
impl IconShape for LdSearchSlash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m13.5 8.5-5 5",
            }
            circle {
                cx: "11",
                cy: "11",
                r: "8",
            }
            path {
                d: "m21 21-4.3-4.3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSearchX;
impl IconShape for LdSearchX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m13.5 8.5-5 5",
            }
            path {
                d: "m8.5 8.5 5 5",
            }
            circle {
                cx: "11",
                cy: "11",
                r: "8",
            }
            path {
                d: "m21 21-4.3-4.3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSearch;
impl IconShape for LdSearch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m21 21-4.34-4.34",
            }
            circle {
                cx: "11",
                cy: "11",
                r: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSection;
impl IconShape for LdSection {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 5a4 3 0 0 0-8 0c0 4 8 3 8 7a4 3 0 0 1-8 0",
            }
            path {
                d: "M8 19a4 3 0 0 0 8 0c0-4-8-3-8-7a4 3 0 0 1 8 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSendHorizontal;
impl IconShape for LdSendHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.714 3.048a.498.498 0 0 0-.683.627l2.843 7.627a2 2 0 0 1 0 1.396l-2.842 7.627a.498.498 0 0 0 .682.627l18-8.5a.5.5 0 0 0 0-.904z",
            }
            path {
                d: "M6 12h16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSendToBack;
impl IconShape for LdSendToBack {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "8",
                rx: "2",
                width: "8",
                x: "14",
                y: "14",
            }
            rect {
                height: "8",
                rx: "2",
                width: "8",
                x: "2",
                y: "2",
            }
            path {
                d: "M7 14v1a2 2 0 0 0 2 2h1",
            }
            path {
                d: "M14 7h1a2 2 0 0 1 2 2v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSend;
impl IconShape for LdSend {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14.536 21.686a.5.5 0 0 0 .937-.024l6.5-19a.496.496 0 0 0-.635-.635l-19 6.5a.5.5 0 0 0-.024.937l7.93 3.18a2 2 0 0 1 1.112 1.11z",
            }
            path {
                d: "m21.854 2.147-10.94 10.939",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSeparatorHorizontal;
impl IconShape for LdSeparatorHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 16-4 4-4-4",
            }
            path {
                d: "M3 12h18",
            }
            path {
                d: "m8 8 4-4 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSeparatorVertical;
impl IconShape for LdSeparatorVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v18",
            }
            path {
                d: "m16 16 4-4-4-4",
            }
            path {
                d: "m8 8-4 4 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdServerCog;
impl IconShape for LdServerCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10.852 14.772-.383.923",
            }
            path {
                d: "M13.148 14.772a3 3 0 1 0-2.296-5.544l-.383-.923",
            }
            path {
                d: "m13.148 9.228.383-.923",
            }
            path {
                d: "m13.53 15.696-.382-.924a3 3 0 1 1-2.296-5.544",
            }
            path {
                d: "m14.772 10.852.923-.383",
            }
            path {
                d: "m14.772 13.148.923.383",
            }
            path {
                d: "M4.5 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-.5",
            }
            path {
                d: "M4.5 14H4a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2h-.5",
            }
            path {
                d: "M6 18h.01",
            }
            path {
                d: "M6 6h.01",
            }
            path {
                d: "m9.228 10.852-.923-.383",
            }
            path {
                d: "m9.228 13.148-.923.383",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdServerCrash;
impl IconShape for LdServerCrash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-2",
            }
            path {
                d: "M6 14H4a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2h-2",
            }
            path {
                d: "M6 6h.01",
            }
            path {
                d: "M6 18h.01",
            }
            path {
                d: "m13 6-4 6h6l-4 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdServerOff;
impl IconShape for LdServerOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 2h13a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-5",
            }
            path {
                d: "M10 10 2.5 2.5C2 2 2 2.5 2 5v3a2 2 0 0 0 2 2h6z",
            }
            path {
                d: "M22 17v-1a2 2 0 0 0-2-2h-1",
            }
            path {
                d: "M4 14a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16.5l1-.5.5.5-8-8H4z",
            }
            path {
                d: "M6 18h.01",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdServer;
impl IconShape for LdServer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "8",
                rx: "2",
                ry: "2",
                width: "20",
                x: "2",
                y: "2",
            }
            rect {
                height: "8",
                rx: "2",
                ry: "2",
                width: "20",
                x: "2",
                y: "14",
            }
            line {
                x1: "6",
                x2: "6.01",
                y1: "6",
                y2: "6",
            }
            line {
                x1: "6",
                x2: "6.01",
                y1: "18",
                y2: "18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSettings2;
impl IconShape for LdSettings2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 17H5",
            }
            path {
                d: "M19 7h-9",
            }
            circle {
                cx: "17",
                cy: "17",
                r: "3",
            }
            circle {
                cx: "7",
                cy: "7",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSettings;
impl IconShape for LdSettings {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9.671 4.136a2.34 2.34 0 0 1 4.659 0 2.34 2.34 0 0 0 3.319 1.915 2.34 2.34 0 0 1 2.33 4.033 2.34 2.34 0 0 0 0 3.831 2.34 2.34 0 0 1-2.33 4.033 2.34 2.34 0 0 0-3.319 1.915 2.34 2.34 0 0 1-4.659 0 2.34 2.34 0 0 0-3.32-1.915 2.34 2.34 0 0 1-2.33-4.033 2.34 2.34 0 0 0 0-3.831A2.34 2.34 0 0 1 6.35 6.051a2.34 2.34 0 0 0 3.319-1.915",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShapes;
impl IconShape for LdShapes {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8.3 10a.7.7 0 0 1-.626-1.079L11.4 3a.7.7 0 0 1 1.198-.043L16.3 8.9a.7.7 0 0 1-.572 1.1Z",
            }
            rect {
                height: "7",
                rx: "1",
                width: "7",
                x: "3",
                y: "14",
            }
            circle {
                cx: "17.5",
                cy: "17.5",
                r: "3.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShare2;
impl IconShape for LdShare2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "18",
                cy: "5",
                r: "3",
            }
            circle {
                cx: "6",
                cy: "12",
                r: "3",
            }
            circle {
                cx: "18",
                cy: "19",
                r: "3",
            }
            line {
                x1: "8.59",
                x2: "15.42",
                y1: "13.51",
                y2: "17.49",
            }
            line {
                x1: "15.41",
                x2: "8.59",
                y1: "6.51",
                y2: "10.49",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShare;
impl IconShape for LdShare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v13",
            }
            path {
                d: "m16 6-4-4-4 4",
            }
            path {
                d: "M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSheet;
impl IconShape for LdSheet {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            line {
                x1: "3",
                x2: "21",
                y1: "9",
                y2: "9",
            }
            line {
                x1: "3",
                x2: "21",
                y1: "15",
                y2: "15",
            }
            line {
                x1: "9",
                x2: "9",
                y1: "9",
                y2: "21",
            }
            line {
                x1: "15",
                x2: "15",
                y1: "9",
                y2: "21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShell;
impl IconShape for LdShell {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 11a2 2 0 1 1-4 0 4 4 0 0 1 8 0 6 6 0 0 1-12 0 8 8 0 0 1 16 0 10 10 0 1 1-20 0 11.93 11.93 0 0 1 2.42-7.22 2 2 0 1 1 3.16 2.44",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldAlert;
impl IconShape for LdShieldAlert {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
            path {
                d: "M12 8v4",
            }
            path {
                d: "M12 16h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldBan;
impl IconShape for LdShieldBan {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
            path {
                d: "m4.243 5.21 14.39 12.472",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldCheck;
impl IconShape for LdShieldCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
            path {
                d: "m9 12 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldEllipsis;
impl IconShape for LdShieldEllipsis {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
            path {
                d: "M8 12h.01",
            }
            path {
                d: "M12 12h.01",
            }
            path {
                d: "M16 12h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldHalf;
impl IconShape for LdShieldHalf {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
            path {
                d: "M12 22V2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldMinus;
impl IconShape for LdShieldMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
            path {
                d: "M9 12h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldOff;
impl IconShape for LdShieldOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M5 5a1 1 0 0 0-1 1v7c0 5 3.5 7.5 7.67 8.94a1 1 0 0 0 .67.01c2.35-.82 4.48-1.97 5.9-3.71",
            }
            path {
                d: "M9.309 3.652A12.252 12.252 0 0 0 11.24 2.28a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1v7a9.784 9.784 0 0 1-.08 1.264",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldPlus;
impl IconShape for LdShieldPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
            path {
                d: "M9 12h6",
            }
            path {
                d: "M12 9v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldQuestionMark;
impl IconShape for LdShieldQuestionMark {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
            path {
                d: "M9.1 9a3 3 0 0 1 5.82 1c0 2-3 3-3 3",
            }
            path {
                d: "M12 17h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldUser;
impl IconShape for LdShieldUser {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
            path {
                d: "M6.376 18.91a6 6 0 0 1 11.249.003",
            }
            circle {
                cx: "12",
                cy: "11",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShieldX;
impl IconShape for LdShieldX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
            path {
                d: "m14.5 9.5-5 5",
            }
            path {
                d: "m9.5 9.5 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShield;
impl IconShape for LdShield {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShipWheel;
impl IconShape for LdShipWheel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "8",
            }
            path {
                d: "M12 2v7.5",
            }
            path {
                d: "m19 5-5.23 5.23",
            }
            path {
                d: "M22 12h-7.5",
            }
            path {
                d: "m19 19-5.23-5.23",
            }
            path {
                d: "M12 14.5V22",
            }
            path {
                d: "M10.23 13.77 5 19",
            }
            path {
                d: "M9.5 12H2",
            }
            path {
                d: "M10.23 10.23 5 5",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShip;
impl IconShape for LdShip {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 10.189V14",
            }
            path {
                d: "M12 2v3",
            }
            path {
                d: "M19 13V7a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2v6",
            }
            path {
                d: "M19.38 20A11.6 11.6 0 0 0 21 14l-8.188-3.639a2 2 0 0 0-1.624 0L3 14a11.6 11.6 0 0 0 2.81 7.76",
            }
            path {
                d: "M2 21c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1s1.2 1 2.5 1c2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShirt;
impl IconShape for LdShirt {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20.38 3.46 16 2a4 4 0 0 1-8 0L3.62 3.46a2 2 0 0 0-1.34 2.23l.58 3.47a1 1 0 0 0 .99.84H6v10c0 1.1.9 2 2 2h8a2 2 0 0 0 2-2V10h2.15a1 1 0 0 0 .99-.84l.58-3.47a2 2 0 0 0-1.34-2.23z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShoppingBag;
impl IconShape for LdShoppingBag {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 10a4 4 0 0 1-8 0",
            }
            path {
                d: "M3.103 6.034h17.794",
            }
            path {
                d: "M3.4 5.467a2 2 0 0 0-.4 1.2V20a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6.667a2 2 0 0 0-.4-1.2l-2-2.667A2 2 0 0 0 17 2H7a2 2 0 0 0-1.6.8z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShoppingBasket;
impl IconShape for LdShoppingBasket {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 11-1 9",
            }
            path {
                d: "m19 11-4-7",
            }
            path {
                d: "M2 11h20",
            }
            path {
                d: "m3.5 11 1.6 7.4a2 2 0 0 0 2 1.6h9.8a2 2 0 0 0 2-1.6l1.7-7.4",
            }
            path {
                d: "M4.5 15.5h15",
            }
            path {
                d: "m5 11 4-7",
            }
            path {
                d: "m9 11 1 9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShoppingCart;
impl IconShape for LdShoppingCart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "8",
                cy: "21",
                r: "1",
            }
            circle {
                cx: "19",
                cy: "21",
                r: "1",
            }
            path {
                d: "M2.05 2.05h2l2.66 12.42a2 2 0 0 0 2 1.58h9.78a2 2 0 0 0 1.95-1.57l1.65-7.43H5.12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShovel;
impl IconShape for LdShovel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21.56 4.56a1.5 1.5 0 0 1 0 2.122l-.47.47a3 3 0 0 1-4.212-.03 3 3 0 0 1 0-4.243l.44-.44a1.5 1.5 0 0 1 2.121 0z",
            }
            path {
                d: "M3 22a1 1 0 0 1-1-1v-3.586a1 1 0 0 1 .293-.707l3.355-3.355a1.205 1.205 0 0 1 1.704 0l3.296 3.296a1.205 1.205 0 0 1 0 1.704l-3.355 3.355a1 1 0 0 1-.707.293z",
            }
            path {
                d: "m9 15 7.879-7.878",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShowerHead;
impl IconShape for LdShowerHead {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m4 4 2.5 2.5",
            }
            path {
                d: "M13.5 6.5a4.95 4.95 0 0 0-7 7",
            }
            path {
                d: "M15 5 5 15",
            }
            path {
                d: "M14 17v.01",
            }
            path {
                d: "M10 16v.01",
            }
            path {
                d: "M13 13v.01",
            }
            path {
                d: "M16 10v.01",
            }
            path {
                d: "M11 20v.01",
            }
            path {
                d: "M17 14v.01",
            }
            path {
                d: "M20 11v.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShredder;
impl IconShape for LdShredder {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 13V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.706.706l3.588 3.588A2.4 2.4 0 0 1 20 8v5",
            }
            path {
                d: "M14 2v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M10 22v-5",
            }
            path {
                d: "M14 19v-2",
            }
            path {
                d: "M18 20v-3",
            }
            path {
                d: "M2 13h20",
            }
            path {
                d: "M6 20v-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShrimp;
impl IconShape for LdShrimp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 12h.01",
            }
            path {
                d: "M13 22c.5-.5 1.12-1 2.5-1-1.38 0-2-.5-2.5-1",
            }
            path {
                d: "M14 2a3.28 3.28 0 0 1-3.227 1.798l-6.17-.561A2.387 2.387 0 1 0 4.387 8H15.5a1 1 0 0 1 0 13 1 1 0 0 0 0-5H12a7 7 0 0 1-7-7V8",
            }
            path {
                d: "M14 8a8.5 8.5 0 0 1 0 8",
            }
            path {
                d: "M16 16c2 0 4.5-4 4-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShrink;
impl IconShape for LdShrink {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m15 15 6 6m-6-6v4.8m0-4.8h4.8",
            }
            path {
                d: "M9 19.8V15m0 0H4.2M9 15l-6 6",
            }
            path {
                d: "M15 4.2V9m0 0h4.8M15 9l6-6",
            }
            path {
                d: "M9 4.2V9m0 0H4.2M9 9 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShrub;
impl IconShape for LdShrub {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 22v-5.172a2 2 0 0 0-.586-1.414L9.5 13.5",
            }
            path {
                d: "M14.5 14.5 12 17",
            }
            path {
                d: "M17 8.8A6 6 0 0 1 13.8 20H10A6.5 6.5 0 0 1 7 8a5 5 0 0 1 10 0z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdShuffle;
impl IconShape for LdShuffle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m18 14 4 4-4 4",
            }
            path {
                d: "m18 2 4 4-4 4",
            }
            path {
                d: "M2 18h1.973a4 4 0 0 0 3.3-1.7l5.454-8.6a4 4 0 0 1 3.3-1.7H22",
            }
            path {
                d: "M2 6h1.972a4 4 0 0 1 3.6 2.2",
            }
            path {
                d: "M22 18h-6.041a4 4 0 0 1-3.3-1.8l-.359-.45",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSigma;
impl IconShape for LdSigma {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 7V5a1 1 0 0 0-1-1H6.5a.5.5 0 0 0-.4.8l4.5 6a2 2 0 0 1 0 2.4l-4.5 6a.5.5 0 0 0 .4.8H17a1 1 0 0 0 1-1v-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSignalHigh;
impl IconShape for LdSignalHigh {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 20h.01",
            }
            path {
                d: "M7 20v-4",
            }
            path {
                d: "M12 20v-8",
            }
            path {
                d: "M17 20V8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSignalLow;
impl IconShape for LdSignalLow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 20h.01",
            }
            path {
                d: "M7 20v-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSignalMedium;
impl IconShape for LdSignalMedium {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 20h.01",
            }
            path {
                d: "M7 20v-4",
            }
            path {
                d: "M12 20v-8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSignalZero;
impl IconShape for LdSignalZero {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 20h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSignal;
impl IconShape for LdSignal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 20h.01",
            }
            path {
                d: "M7 20v-4",
            }
            path {
                d: "M12 20v-8",
            }
            path {
                d: "M17 20V8",
            }
            path {
                d: "M22 4v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSignature;
impl IconShape for LdSignature {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m21 17-2.156-1.868A.5.5 0 0 0 18 15.5v.5a1 1 0 0 1-1 1h-2a1 1 0 0 1-1-1c0-2.545-3.991-3.97-8.5-4a1 1 0 0 0 0 5c4.153 0 4.745-11.295 5.708-13.5a2.5 2.5 0 1 1 3.31 3.284",
            }
            path {
                d: "M3 21h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSignpostBig;
impl IconShape for LdSignpostBig {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 9H4L2 7l2-2h6",
            }
            path {
                d: "M14 5h6l2 2-2 2h-6",
            }
            path {
                d: "M10 22V4a2 2 0 1 1 4 0v18",
            }
            path {
                d: "M8 22h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSignpost;
impl IconShape for LdSignpost {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13v8",
            }
            path {
                d: "M12 3v3",
            }
            path {
                d: "M18 6a2 2 0 0 1 1.387.56l2.307 2.22a1 1 0 0 1 0 1.44l-2.307 2.22A2 2 0 0 1 18 13H6a2 2 0 0 1-1.387-.56l-2.306-2.22a1 1 0 0 1 0-1.44l2.306-2.22A2 2 0 0 1 6 6z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSiren;
impl IconShape for LdSiren {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 18v-6a5 5 0 1 1 10 0v6",
            }
            path {
                d: "M5 21a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-1a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2z",
            }
            path {
                d: "M21 12h1",
            }
            path {
                d: "M18.5 4.5 18 5",
            }
            path {
                d: "M2 12h1",
            }
            path {
                d: "M12 2v1",
            }
            path {
                d: "m4.929 4.929.707.707",
            }
            path {
                d: "M12 12v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSkipBack;
impl IconShape for LdSkipBack {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17.971 4.285A2 2 0 0 1 21 6v12a2 2 0 0 1-3.029 1.715l-9.997-5.998a2 2 0 0 1-.003-3.432z",
            }
            path {
                d: "M3 20V4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSkipForward;
impl IconShape for LdSkipForward {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 4v16",
            }
            path {
                d: "M6.029 4.285A2 2 0 0 0 3 6v12a2 2 0 0 0 3.029 1.715l9.997-5.998a2 2 0 0 0 .003-3.432z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSkull;
impl IconShape for LdSkull {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12.5 17-.5-1-.5 1h1z",
            }
            path {
                d: "M15 22a1 1 0 0 0 1-1v-1a2 2 0 0 0 1.56-3.25 8 8 0 1 0-11.12 0A2 2 0 0 0 8 20v1a1 1 0 0 0 1 1z",
            }
            circle {
                cx: "15",
                cy: "12",
                r: "1",
            }
            circle {
                cx: "9",
                cy: "12",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSlack;
impl IconShape for LdSlack {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "8",
                rx: "1.5",
                width: "3",
                x: "13",
                y: "2",
            }
            path {
                d: "M19 8.5V10h1.5A1.5 1.5 0 1 0 19 8.5",
            }
            rect {
                height: "8",
                rx: "1.5",
                width: "3",
                x: "8",
                y: "14",
            }
            path {
                d: "M5 15.5V14H3.5A1.5 1.5 0 1 0 5 15.5",
            }
            rect {
                height: "3",
                rx: "1.5",
                width: "8",
                x: "14",
                y: "13",
            }
            path {
                d: "M15.5 19H14v1.5a1.5 1.5 0 1 0 1.5-1.5",
            }
            rect {
                height: "3",
                rx: "1.5",
                width: "8",
                x: "2",
                y: "8",
            }
            path {
                d: "M8.5 5H10V3.5A1.5 1.5 0 1 0 8.5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSlash;
impl IconShape for LdSlash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 2 2 22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSlice;
impl IconShape for LdSlice {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 16.586V19a1 1 0 0 1-1 1H2L18.37 3.63a1 1 0 1 1 3 3l-9.663 9.663a1 1 0 0 1-1.414 0L8 14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSlidersHorizontal;
impl IconShape for LdSlidersHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 5H3",
            }
            path {
                d: "M12 19H3",
            }
            path {
                d: "M14 3v4",
            }
            path {
                d: "M16 17v4",
            }
            path {
                d: "M21 12h-9",
            }
            path {
                d: "M21 19h-5",
            }
            path {
                d: "M21 5h-7",
            }
            path {
                d: "M8 10v4",
            }
            path {
                d: "M8 12H3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSlidersVertical;
impl IconShape for LdSlidersVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 8h4",
            }
            path {
                d: "M12 21v-9",
            }
            path {
                d: "M12 8V3",
            }
            path {
                d: "M17 16h4",
            }
            path {
                d: "M19 12V3",
            }
            path {
                d: "M19 21v-5",
            }
            path {
                d: "M3 14h4",
            }
            path {
                d: "M5 10V3",
            }
            path {
                d: "M5 21v-7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSmartphoneCharging;
impl IconShape for LdSmartphoneCharging {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "2",
                ry: "2",
                width: "14",
                x: "5",
                y: "2",
            }
            path {
                d: "M12.667 8 10 12h4l-2.667 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSmartphoneNfc;
impl IconShape for LdSmartphoneNfc {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "12",
                rx: "1",
                width: "7",
                x: "2",
                y: "6",
            }
            path {
                d: "M13 8.32a7.43 7.43 0 0 1 0 7.36",
            }
            path {
                d: "M16.46 6.21a11.76 11.76 0 0 1 0 11.58",
            }
            path {
                d: "M19.91 4.1a15.91 15.91 0 0 1 .01 15.8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSmartphone;
impl IconShape for LdSmartphone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "2",
                ry: "2",
                width: "14",
                x: "5",
                y: "2",
            }
            path {
                d: "M12 18h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSmilePlus;
impl IconShape for LdSmilePlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 11v1a10 10 0 1 1-9-10",
            }
            path {
                d: "M8 14s1.5 2 4 2 4-2 4-2",
            }
            line {
                x1: "9",
                x2: "9.01",
                y1: "9",
                y2: "9",
            }
            line {
                x1: "15",
                x2: "15.01",
                y1: "9",
                y2: "9",
            }
            path {
                d: "M16 5h6",
            }
            path {
                d: "M19 2v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSmile;
impl IconShape for LdSmile {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            path {
                d: "M8 14s1.5 2 4 2 4-2 4-2",
            }
            line {
                x1: "9",
                x2: "9.01",
                y1: "9",
                y2: "9",
            }
            line {
                x1: "15",
                x2: "15.01",
                y1: "9",
                y2: "9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSnail;
impl IconShape for LdSnail {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 13a6 6 0 1 0 12 0 4 4 0 1 0-8 0 2 2 0 0 0 4 0",
            }
            circle {
                cx: "10",
                cy: "13",
                r: "8",
            }
            path {
                d: "M2 21h12c4.4 0 8-3.6 8-8V7a2 2 0 1 0-4 0v6",
            }
            path {
                d: "M18 3 19.1 5.2",
            }
            path {
                d: "M22 3 20.9 5.2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSnowflake;
impl IconShape for LdSnowflake {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 20-1.25-2.5L6 18",
            }
            path {
                d: "M10 4 8.75 6.5 6 6",
            }
            path {
                d: "m14 20 1.25-2.5L18 18",
            }
            path {
                d: "m14 4 1.25 2.5L18 6",
            }
            path {
                d: "m17 21-3-6h-4",
            }
            path {
                d: "m17 3-3 6 1.5 3",
            }
            path {
                d: "M2 12h6.5L10 9",
            }
            path {
                d: "m20 10-1.5 2 1.5 2",
            }
            path {
                d: "M22 12h-6.5L14 15",
            }
            path {
                d: "m4 10 1.5 2L4 14",
            }
            path {
                d: "m7 21 3-6-1.5-3",
            }
            path {
                d: "m7 3 3 6h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSoapDispenserDroplet;
impl IconShape for LdSoapDispenserDroplet {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.5 2v4",
            }
            path {
                d: "M14 2H7a2 2 0 0 0-2 2",
            }
            path {
                d: "M19.29 14.76A6.67 6.67 0 0 1 17 11a6.6 6.6 0 0 1-2.29 3.76c-1.15.92-1.71 2.04-1.71 3.19 0 2.22 1.8 4.05 4 4.05s4-1.83 4-4.05c0-1.16-.57-2.26-1.71-3.19",
            }
            path {
                d: "M9.607 21H6a2 2 0 0 1-2-2v-7a2 2 0 0 1 2-2h7V7a1 1 0 0 0-1-1H9a1 1 0 0 0-1 1v3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSofa;
impl IconShape for LdSofa {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M20 9V6a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v3",
            }
            path {
                d: "M2 16a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-5a2 2 0 0 0-4 0v1.5a.5.5 0 0 1-.5.5h-11a.5.5 0 0 1-.5-.5V11a2 2 0 0 0-4 0z",
            }
            path {
                d: "M4 18v2",
            }
            path {
                d: "M20 18v2",
            }
            path {
                d: "M12 4v9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSolarPanel;
impl IconShape for LdSolarPanel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 2h2",
            }
            path {
                d: "m14.28 14-4.56 8",
            }
            path {
                d: "m21 22-1.558-4H4.558",
            }
            path {
                d: "M3 10v2",
            }
            path {
                d: "M6.245 15.04A2 2 0 0 1 8 14h12a1 1 0 0 1 .864 1.505l-3.11 5.457A2 2 0 0 1 16 22H4a1 1 0 0 1-.863-1.506z",
            }
            path {
                d: "M7 2a4 4 0 0 1-4 4",
            }
            path {
                d: "m8.66 7.66 1.41 1.41",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSoup;
impl IconShape for LdSoup {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 21a9 9 0 0 0 9-9H3a9 9 0 0 0 9 9Z",
            }
            path {
                d: "M7 21h10",
            }
            path {
                d: "M19.5 12 22 6",
            }
            path {
                d: "M16.25 3c.27.1.8.53.75 1.36-.06.83-.93 1.2-1 2.02-.05.78.34 1.24.73 1.62",
            }
            path {
                d: "M11.25 3c.27.1.8.53.74 1.36-.05.83-.93 1.2-.98 2.02-.06.78.33 1.24.72 1.62",
            }
            path {
                d: "M6.25 3c.27.1.8.53.75 1.36-.06.83-.93 1.2-1 2.02-.05.78.34 1.24.74 1.62",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSpace;
impl IconShape for LdSpace {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 17v1c0 .5-.5 1-1 1H3c-.5 0-1-.5-1-1v-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSpade;
impl IconShape for LdSpade {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 18v4",
            }
            path {
                d: "M2 14.499a5.5 5.5 0 0 0 9.591 3.675.6.6 0 0 1 .818.001A5.5 5.5 0 0 0 22 14.5c0-2.29-1.5-4-3-5.5l-5.492-5.312a2 2 0 0 0-3-.02L5 8.999c-1.5 1.5-3 3.2-3 5.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSparkle;
impl IconShape for LdSparkle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.017 2.814a1 1 0 0 1 1.966 0l1.051 5.558a2 2 0 0 0 1.594 1.594l5.558 1.051a1 1 0 0 1 0 1.966l-5.558 1.051a2 2 0 0 0-1.594 1.594l-1.051 5.558a1 1 0 0 1-1.966 0l-1.051-5.558a2 2 0 0 0-1.594-1.594l-5.558-1.051a1 1 0 0 1 0-1.966l5.558-1.051a2 2 0 0 0 1.594-1.594z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSparkles;
impl IconShape for LdSparkles {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.017 2.814a1 1 0 0 1 1.966 0l1.051 5.558a2 2 0 0 0 1.594 1.594l5.558 1.051a1 1 0 0 1 0 1.966l-5.558 1.051a2 2 0 0 0-1.594 1.594l-1.051 5.558a1 1 0 0 1-1.966 0l-1.051-5.558a2 2 0 0 0-1.594-1.594l-5.558-1.051a1 1 0 0 1 0-1.966l5.558-1.051a2 2 0 0 0 1.594-1.594z",
            }
            path {
                d: "M20 2v4",
            }
            path {
                d: "M22 4h-4",
            }
            circle {
                cx: "4",
                cy: "20",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSpeaker;
impl IconShape for LdSpeaker {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "2",
                width: "16",
                x: "4",
                y: "2",
            }
            path {
                d: "M12 6h.01",
            }
            circle {
                cx: "12",
                cy: "14",
                r: "4",
            }
            path {
                d: "M12 14h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSpeech;
impl IconShape for LdSpeech {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8.8 20v-4.1l1.9.2a2.3 2.3 0 0 0 2.164-2.1V8.3A5.37 5.37 0 0 0 2 8.25c0 2.8.656 3.054 1 4.55a5.77 5.77 0 0 1 .029 2.758L2 20",
            }
            path {
                d: "M19.8 17.8a7.5 7.5 0 0 0 .003-10.603",
            }
            path {
                d: "M17 15a3.5 3.5 0 0 0-.025-4.975",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSpellCheck2;
impl IconShape for LdSpellCheck2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m6 16 6-12 6 12",
            }
            path {
                d: "M8 12h8",
            }
            path {
                d: "M4 21c1.1 0 1.1-1 2.3-1s1.1 1 2.3 1c1.1 0 1.1-1 2.3-1 1.1 0 1.1 1 2.3 1 1.1 0 1.1-1 2.3-1 1.1 0 1.1 1 2.3 1 1.1 0 1.1-1 2.3-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSpellCheck;
impl IconShape for LdSpellCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m6 16 6-12 6 12",
            }
            path {
                d: "M8 12h8",
            }
            path {
                d: "m16 20 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSplinePointer;
impl IconShape for LdSplinePointer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.034 12.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.943l-3.444 1.068a1 1 0 0 0-.66.66l-1.067 3.443a.5.5 0 0 1-.943.033z",
            }
            path {
                d: "M5 17A12 12 0 0 1 17 5",
            }
            circle {
                cx: "19",
                cy: "5",
                r: "2",
            }
            circle {
                cx: "5",
                cy: "19",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSpline;
impl IconShape for LdSpline {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "19",
                cy: "5",
                r: "2",
            }
            circle {
                cx: "5",
                cy: "19",
                r: "2",
            }
            path {
                d: "M5 17A12 12 0 0 1 17 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSplit;
impl IconShape for LdSplit {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 3h5v5",
            }
            path {
                d: "M8 3H3v5",
            }
            path {
                d: "M12 22v-8.3a4 4 0 0 0-1.172-2.872L3 3",
            }
            path {
                d: "m15 9 6-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSpool;
impl IconShape for LdSpool {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 13.44 4.442 17.082A2 2 0 0 0 4.982 21H19a2 2 0 0 0 .558-3.921l-1.115-.32A2 2 0 0 1 17 14.837V7.66",
            }
            path {
                d: "m7 10.56 12.558-3.642A2 2 0 0 0 19.018 3H5a2 2 0 0 0-.558 3.921l1.115.32A2 2 0 0 1 7 9.163v7.178",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSpotlight;
impl IconShape for LdSpotlight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.295 19.562 16 22",
            }
            path {
                d: "m17 16 3.758 2.098",
            }
            path {
                d: "m19 12.5 3.026-.598",
            }
            path {
                d: "M7.61 6.3a3 3 0 0 0-3.92 1.3l-1.38 2.79a3 3 0 0 0 1.3 3.91l6.89 3.597a1 1 0 0 0 1.342-.447l3.106-6.211a1 1 0 0 0-.447-1.341z",
            }
            path {
                d: "M8 9V2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSprayCan;
impl IconShape for LdSprayCan {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 3h.01",
            }
            path {
                d: "M7 5h.01",
            }
            path {
                d: "M11 7h.01",
            }
            path {
                d: "M3 7h.01",
            }
            path {
                d: "M7 9h.01",
            }
            path {
                d: "M3 11h.01",
            }
            rect {
                height: "4",
                width: "4",
                x: "15",
                y: "5",
            }
            path {
                d: "m19 9 2 2v10c0 .6-.4 1-1 1h-6c-.6 0-1-.4-1-1V11l2-2",
            }
            path {
                d: "m13 14 8-2",
            }
            path {
                d: "m13 19 8-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSprout;
impl IconShape for LdSprout {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 9.536V7a4 4 0 0 1 4-4h1.5a.5.5 0 0 1 .5.5V5a4 4 0 0 1-4 4 4 4 0 0 0-4 4c0 2 1 3 1 5a5 5 0 0 1-1 3",
            }
            path {
                d: "M4 9a5 5 0 0 1 8 4 5 5 0 0 1-8-4",
            }
            path {
                d: "M5 21h14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareActivity;
impl IconShape for LdSquareActivity {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M17 12h-2l-2 5-2-10-2 5H7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowDownLeft;
impl IconShape for LdSquareArrowDownLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m16 8-8 8",
            }
            path {
                d: "M16 16H8V8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowDownRight;
impl IconShape for LdSquareArrowDownRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m8 8 8 8",
            }
            path {
                d: "M16 8v8H8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowDown;
impl IconShape for LdSquareArrowDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M12 8v8",
            }
            path {
                d: "m8 12 4 4 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowLeft;
impl IconShape for LdSquareArrowLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m12 8-4 4 4 4",
            }
            path {
                d: "M16 12H8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowOutDownLeft;
impl IconShape for LdSquareArrowOutDownLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 21h6a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v6",
            }
            path {
                d: "m3 21 9-9",
            }
            path {
                d: "M9 21H3v-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowOutDownRight;
impl IconShape for LdSquareArrowOutDownRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 11V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6",
            }
            path {
                d: "m21 21-9-9",
            }
            path {
                d: "M21 15v6h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowOutUpLeft;
impl IconShape for LdSquareArrowOutUpLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 3h6a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-6",
            }
            path {
                d: "m3 3 9 9",
            }
            path {
                d: "M3 9V3h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowOutUpRight;
impl IconShape for LdSquareArrowOutUpRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h6",
            }
            path {
                d: "m21 3-9 9",
            }
            path {
                d: "M15 3h6v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowRight;
impl IconShape for LdSquareArrowRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M8 12h8",
            }
            path {
                d: "m12 16 4-4-4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowUpLeft;
impl IconShape for LdSquareArrowUpLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M8 16V8h8",
            }
            path {
                d: "M16 16 8 8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowUpRight;
impl IconShape for LdSquareArrowUpRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M8 8h8v8",
            }
            path {
                d: "m8 16 8-8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareArrowUp;
impl IconShape for LdSquareArrowUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m16 12-4-4-4 4",
            }
            path {
                d: "M12 16V8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareAsterisk;
impl IconShape for LdSquareAsterisk {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M12 8v8",
            }
            path {
                d: "m8.5 14 7-4",
            }
            path {
                d: "m8.5 10 7 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareBottomDashedScissors;
impl IconShape for LdSquareBottomDashedScissors {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v16a2 2 0 0 1-2 2",
            }
            path {
                d: "M10 22H8",
            }
            path {
                d: "M16 22h-2",
            }
            circle {
                cx: "8",
                cy: "8",
                r: "2",
            }
            path {
                d: "M9.414 9.414 12 12",
            }
            path {
                d: "M14.8 14.8 18 18",
            }
            circle {
                cx: "8",
                cy: "16",
                r: "2",
            }
            path {
                d: "m18 6-8.586 8.586",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareChartGantt;
impl IconShape for LdSquareChartGantt {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M9 8h7",
            }
            path {
                d: "M8 12h6",
            }
            path {
                d: "M11 16h5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareCheckBig;
impl IconShape for LdSquareCheckBig {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 10.656V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h12.344",
            }
            path {
                d: "m9 11 3 3L22 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareCheck;
impl IconShape for LdSquareCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m9 12 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareChevronDown;
impl IconShape for LdSquareChevronDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m16 10-4 4-4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareChevronLeft;
impl IconShape for LdSquareChevronLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m14 16-4-4 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareChevronRight;
impl IconShape for LdSquareChevronRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m10 8 4 4-4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareChevronUp;
impl IconShape for LdSquareChevronUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m8 14 4-4 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareCode;
impl IconShape for LdSquareCode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 9-3 3 3 3",
            }
            path {
                d: "m14 15 3-3-3-3",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareDashedBottomCode;
impl IconShape for LdSquareDashedBottomCode {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 9.5 8 12l2 2.5",
            }
            path {
                d: "M14 21h1",
            }
            path {
                d: "m14 9.5 2 2.5-2 2.5",
            }
            path {
                d: "M5 21a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2",
            }
            path {
                d: "M9 21h1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareDashedBottom;
impl IconShape for LdSquareDashedBottom {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 21a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2",
            }
            path {
                d: "M9 21h1",
            }
            path {
                d: "M14 21h1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareDashedKanban;
impl IconShape for LdSquareDashedKanban {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 7v7",
            }
            path {
                d: "M12 7v4",
            }
            path {
                d: "M16 7v9",
            }
            path {
                d: "M5 3a2 2 0 0 0-2 2",
            }
            path {
                d: "M9 3h1",
            }
            path {
                d: "M14 3h1",
            }
            path {
                d: "M19 3a2 2 0 0 1 2 2",
            }
            path {
                d: "M21 9v1",
            }
            path {
                d: "M21 14v1",
            }
            path {
                d: "M21 19a2 2 0 0 1-2 2",
            }
            path {
                d: "M14 21h1",
            }
            path {
                d: "M9 21h1",
            }
            path {
                d: "M5 21a2 2 0 0 1-2-2",
            }
            path {
                d: "M3 14v1",
            }
            path {
                d: "M3 9v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareDashedMousePointer;
impl IconShape for LdSquareDashedMousePointer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.034 12.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.943l-3.444 1.068a1 1 0 0 0-.66.66l-1.067 3.443a.5.5 0 0 1-.943.033z",
            }
            path {
                d: "M5 3a2 2 0 0 0-2 2",
            }
            path {
                d: "M19 3a2 2 0 0 1 2 2",
            }
            path {
                d: "M5 21a2 2 0 0 1-2-2",
            }
            path {
                d: "M9 3h1",
            }
            path {
                d: "M9 21h2",
            }
            path {
                d: "M14 3h1",
            }
            path {
                d: "M3 9v1",
            }
            path {
                d: "M21 9v2",
            }
            path {
                d: "M3 14v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareDashedTopSolid;
impl IconShape for LdSquareDashedTopSolid {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 21h1",
            }
            path {
                d: "M21 14v1",
            }
            path {
                d: "M21 19a2 2 0 0 1-2 2",
            }
            path {
                d: "M21 9v1",
            }
            path {
                d: "M3 14v1",
            }
            path {
                d: "M3 5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2",
            }
            path {
                d: "M3 9v1",
            }
            path {
                d: "M5 21a2 2 0 0 1-2-2",
            }
            path {
                d: "M9 21h1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareDashed;
impl IconShape for LdSquareDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 3a2 2 0 0 0-2 2",
            }
            path {
                d: "M19 3a2 2 0 0 1 2 2",
            }
            path {
                d: "M21 19a2 2 0 0 1-2 2",
            }
            path {
                d: "M5 21a2 2 0 0 1-2-2",
            }
            path {
                d: "M9 3h1",
            }
            path {
                d: "M9 21h1",
            }
            path {
                d: "M14 3h1",
            }
            path {
                d: "M14 21h1",
            }
            path {
                d: "M3 9v1",
            }
            path {
                d: "M21 9v1",
            }
            path {
                d: "M3 14v1",
            }
            path {
                d: "M21 14v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareDivide;
impl IconShape for LdSquareDivide {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            line {
                x1: "8",
                x2: "16",
                y1: "12",
                y2: "12",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "16",
                y2: "16",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "8",
                y2: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareDot;
impl IconShape for LdSquareDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareEqual;
impl IconShape for LdSquareEqual {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M7 10h10",
            }
            path {
                d: "M7 14h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareFunction;
impl IconShape for LdSquareFunction {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M9 17c2 0 2.8-1 2.8-2.8V10c0-2 1-3.3 3.2-3",
            }
            path {
                d: "M9 11.2h5.7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareKanban;
impl IconShape for LdSquareKanban {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M8 7v7",
            }
            path {
                d: "M12 7v4",
            }
            path {
                d: "M16 7v9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareLibrary;
impl IconShape for LdSquareLibrary {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M7 7v10",
            }
            path {
                d: "M11 7v10",
            }
            path {
                d: "m15 7 2 10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareM;
impl IconShape for LdSquareM {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 16V8.5a.5.5 0 0 1 .9-.3l2.7 3.599a.5.5 0 0 0 .8 0l2.7-3.6a.5.5 0 0 1 .9.3V16",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareMenu;
impl IconShape for LdSquareMenu {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M7 8h10",
            }
            path {
                d: "M7 12h10",
            }
            path {
                d: "M7 16h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareMinus;
impl IconShape for LdSquareMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M8 12h8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareMousePointer;
impl IconShape for LdSquareMousePointer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.034 12.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.943l-3.444 1.068a1 1 0 0 0-.66.66l-1.067 3.443a.5.5 0 0 1-.943.033z",
            }
            path {
                d: "M21 11V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareParkingOff;
impl IconShape for LdSquareParkingOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.6 3.6A2 2 0 0 1 5 3h14a2 2 0 0 1 2 2v14a2 2 0 0 1-.59 1.41",
            }
            path {
                d: "M3 8.7V19a2 2 0 0 0 2 2h10.3",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M13 13a3 3 0 1 0 0-6H9v2",
            }
            path {
                d: "M9 17v-2.3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareParking;
impl IconShape for LdSquareParking {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M9 17V7h4a3 3 0 0 1 0 6H9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquarePause;
impl IconShape for LdSquarePause {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            line {
                x1: "10",
                x2: "10",
                y1: "15",
                y2: "9",
            }
            line {
                x1: "14",
                x2: "14",
                y1: "15",
                y2: "9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquarePen;
impl IconShape for LdSquarePen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7",
            }
            path {
                d: "M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquarePercent;
impl IconShape for LdSquarePercent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m15 9-6 6",
            }
            path {
                d: "M9 9h.01",
            }
            path {
                d: "M15 15h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquarePi;
impl IconShape for LdSquarePi {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M7 7h10",
            }
            path {
                d: "M10 7v10",
            }
            path {
                d: "M16 17a2 2 0 0 1-2-2V7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquarePilcrow;
impl IconShape for LdSquarePilcrow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M12 12H9.5a2.5 2.5 0 0 1 0-5H17",
            }
            path {
                d: "M12 7v10",
            }
            path {
                d: "M16 7v10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquarePlay;
impl IconShape for LdSquarePlay {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M9 9.003a1 1 0 0 1 1.517-.859l4.997 2.997a1 1 0 0 1 0 1.718l-4.997 2.997A1 1 0 0 1 9 14.996z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquarePlus;
impl IconShape for LdSquarePlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M8 12h8",
            }
            path {
                d: "M12 8v8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquarePower;
impl IconShape for LdSquarePower {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 7v4",
            }
            path {
                d: "M7.998 9.003a5 5 0 1 0 8-.005",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareRadical;
impl IconShape for LdSquareRadical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 12h2l2 5 2-10h4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareRoundCorner;
impl IconShape for LdSquareRoundCorner {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 11a8 8 0 0 0-8-8",
            }
            path {
                d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareScissors;
impl IconShape for LdSquareScissors {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "2",
                width: "20",
                x: "2",
                y: "2",
            }
            circle {
                cx: "8",
                cy: "8",
                r: "2",
            }
            path {
                d: "M9.414 9.414 12 12",
            }
            path {
                d: "M14.8 14.8 18 18",
            }
            circle {
                cx: "8",
                cy: "16",
                r: "2",
            }
            path {
                d: "m18 6-8.586 8.586",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareSigma;
impl IconShape for LdSquareSigma {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M16 8.9V7H8l4 5-4 5h8v-1.9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareSlash;
impl IconShape for LdSquareSlash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            line {
                x1: "9",
                x2: "15",
                y1: "15",
                y2: "9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareSplitHorizontal;
impl IconShape for LdSquareSplitHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 19H5c-1 0-2-1-2-2V7c0-1 1-2 2-2h3",
            }
            path {
                d: "M16 5h3c1 0 2 1 2 2v10c0 1-1 2-2 2h-3",
            }
            line {
                x1: "12",
                x2: "12",
                y1: "4",
                y2: "20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareSplitVertical;
impl IconShape for LdSquareSplitVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M5 8V5c0-1 1-2 2-2h10c1 0 2 1 2 2v3",
            }
            path {
                d: "M19 16v3c0 1-1 2-2 2H7c-1 0-2-1-2-2v-3",
            }
            line {
                x1: "4",
                x2: "20",
                y1: "12",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareSquare;
impl IconShape for LdSquareSquare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            rect {
                height: "8",
                rx: "1",
                width: "8",
                x: "8",
                y: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareStack;
impl IconShape for LdSquareStack {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 10c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h4c1.1 0 2 .9 2 2",
            }
            path {
                d: "M10 16c-1.1 0-2-.9-2-2v-4c0-1.1.9-2 2-2h4c1.1 0 2 .9 2 2",
            }
            rect {
                height: "8",
                rx: "2",
                width: "8",
                x: "14",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareStar;
impl IconShape for LdSquareStar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.035 7.69a1 1 0 0 1 1.909.024l.737 1.452a1 1 0 0 0 .737.535l1.634.256a1 1 0 0 1 .588 1.806l-1.172 1.168a1 1 0 0 0-.282.866l.259 1.613a1 1 0 0 1-1.541 1.134l-1.465-.75a1 1 0 0 0-.912 0l-1.465.75a1 1 0 0 1-1.539-1.133l.258-1.613a1 1 0 0 0-.282-.866l-1.156-1.153a1 1 0 0 1 .572-1.822l1.633-.256a1 1 0 0 0 .737-.535z",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareStop;
impl IconShape for LdSquareStop {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            rect {
                height: "6",
                rx: "1",
                width: "6",
                x: "9",
                y: "9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareTerminal;
impl IconShape for LdSquareTerminal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m7 11 2-2-2-2",
            }
            path {
                d: "M11 13h4",
            }
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareUserRound;
impl IconShape for LdSquareUserRound {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 21a6 6 0 0 0-12 0",
            }
            circle {
                cx: "12",
                cy: "11",
                r: "4",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareUser;
impl IconShape for LdSquareUser {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "3",
            }
            path {
                d: "M7 21v-2a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquareX;
impl IconShape for LdSquareX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "m15 9-6 6",
            }
            path {
                d: "m9 9 6 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquare;
impl IconShape for LdSquare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquaresExclude;
impl IconShape for LdSquaresExclude {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 12v2a2 2 0 0 1-2 2H9a1 1 0 0 0-1 1v3a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V10a2 2 0 0 0-2-2h0",
            }
            path {
                d: "M4 16a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v3a1 1 0 0 1-1 1h-5a2 2 0 0 0-2 2v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquaresIntersect;
impl IconShape for LdSquaresIntersect {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 22a2 2 0 0 1-2-2",
            }
            path {
                d: "M14 2a2 2 0 0 1 2 2",
            }
            path {
                d: "M16 22h-2",
            }
            path {
                d: "M2 10V8",
            }
            path {
                d: "M2 4a2 2 0 0 1 2-2",
            }
            path {
                d: "M20 8a2 2 0 0 1 2 2",
            }
            path {
                d: "M22 14v2",
            }
            path {
                d: "M22 20a2 2 0 0 1-2 2",
            }
            path {
                d: "M4 16a2 2 0 0 1-2-2",
            }
            path {
                d: "M8 10a2 2 0 0 1 2-2h5a1 1 0 0 1 1 1v5a2 2 0 0 1-2 2H9a1 1 0 0 1-1-1z",
            }
            path {
                d: "M8 2h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquaresSubtract;
impl IconShape for LdSquaresSubtract {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 22a2 2 0 0 1-2-2",
            }
            path {
                d: "M16 22h-2",
            }
            path {
                d: "M16 4a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h3a1 1 0 0 0 1-1v-5a2 2 0 0 1 2-2h5a1 1 0 0 0 1-1z",
            }
            path {
                d: "M20 8a2 2 0 0 1 2 2",
            }
            path {
                d: "M22 14v2",
            }
            path {
                d: "M22 20a2 2 0 0 1-2 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquaresUnite;
impl IconShape for LdSquaresUnite {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 16a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v3a1 1 0 0 0 1 1h3a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H10a2 2 0 0 1-2-2v-3a1 1 0 0 0-1-1z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquircleDashed;
impl IconShape for LdSquircleDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.77 3.043a34 34 0 0 0-3.54 0",
            }
            path {
                d: "M13.771 20.956a33 33 0 0 1-3.541.001",
            }
            path {
                d: "M20.18 17.74c-.51 1.15-1.29 1.93-2.439 2.44",
            }
            path {
                d: "M20.18 6.259c-.51-1.148-1.291-1.929-2.44-2.438",
            }
            path {
                d: "M20.957 10.23a33 33 0 0 1 0 3.54",
            }
            path {
                d: "M3.043 10.23a34 34 0 0 0 .001 3.541",
            }
            path {
                d: "M6.26 20.179c-1.15-.508-1.93-1.29-2.44-2.438",
            }
            path {
                d: "M6.26 3.82c-1.149.51-1.93 1.291-2.44 2.44",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquircle;
impl IconShape for LdSquircle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3c7.2 0 9 1.8 9 9s-1.8 9-9 9-9-1.8-9-9 1.8-9 9-9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSquirrel;
impl IconShape for LdSquirrel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.236 22a3 3 0 0 0-2.2-5",
            }
            path {
                d: "M16 20a3 3 0 0 1 3-3h1a2 2 0 0 0 2-2v-2a4 4 0 0 0-4-4V4",
            }
            path {
                d: "M18 13h.01",
            }
            path {
                d: "M18 6a4 4 0 0 0-4 4 7 7 0 0 0-7 7c0-5 4-5 4-10.5a4.5 4.5 0 1 0-9 0 2.5 2.5 0 0 0 5 0C7 10 3 11 3 17c0 2.8 2.2 5 5 5h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStamp;
impl IconShape for LdStamp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 13V8.5C14 7 15 7 15 5a3 3 0 0 0-6 0c0 2 1 2 1 3.5V13",
            }
            path {
                d: "M20 15.5a2.5 2.5 0 0 0-2.5-2.5h-11A2.5 2.5 0 0 0 4 15.5V17a1 1 0 0 0 1 1h14a1 1 0 0 0 1-1z",
            }
            path {
                d: "M5 22h14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStarHalf;
impl IconShape for LdStarHalf {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 18.338a2.1 2.1 0 0 0-.987.244L6.396 21.01a.53.53 0 0 1-.77-.56l.881-5.139a2.12 2.12 0 0 0-.611-1.879L2.16 9.795a.53.53 0 0 1 .294-.906l5.165-.755a2.12 2.12 0 0 0 1.597-1.16l2.309-4.679A.53.53 0 0 1 12 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStarOff;
impl IconShape for LdStarOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8.34 8.34 2 9.27l5 4.87L5.82 21 12 17.77 18.18 21l-.59-3.43",
            }
            path {
                d: "M18.42 12.76 22 9.27l-6.91-1L12 2l-1.44 2.91",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStar;
impl IconShape for LdStar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.525 2.295a.53.53 0 0 1 .95 0l2.31 4.679a2.123 2.123 0 0 0 1.595 1.16l5.166.756a.53.53 0 0 1 .294.904l-3.736 3.638a2.123 2.123 0 0 0-.611 1.878l.882 5.14a.53.53 0 0 1-.771.56l-4.618-2.428a2.122 2.122 0 0 0-1.973 0L6.396 21.01a.53.53 0 0 1-.77-.56l.881-5.139a2.122 2.122 0 0 0-.611-1.879L2.16 9.795a.53.53 0 0 1 .294-.906l5.165-.755a2.122 2.122 0 0 0 1.597-1.16z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStepBack;
impl IconShape for LdStepBack {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.971 4.285A2 2 0 0 1 17 6v12a2 2 0 0 1-3.029 1.715l-9.997-5.998a2 2 0 0 1-.003-3.432z",
            }
            path {
                d: "M21 20V4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStepForward;
impl IconShape for LdStepForward {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.029 4.285A2 2 0 0 0 7 6v12a2 2 0 0 0 3.029 1.715l9.997-5.998a2 2 0 0 0 .003-3.432z",
            }
            path {
                d: "M3 4v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStethoscope;
impl IconShape for LdStethoscope {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 2v2",
            }
            path {
                d: "M5 2v2",
            }
            path {
                d: "M5 3H4a2 2 0 0 0-2 2v4a6 6 0 0 0 12 0V5a2 2 0 0 0-2-2h-1",
            }
            path {
                d: "M8 15a6 6 0 0 0 12 0v-3",
            }
            circle {
                cx: "20",
                cy: "10",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSticker;
impl IconShape for LdSticker {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 9a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 15 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2z",
            }
            path {
                d: "M15 3v5a1 1 0 0 0 1 1h5",
            }
            path {
                d: "M8 13h.01",
            }
            path {
                d: "M16 13h.01",
            }
            path {
                d: "M10 16s.8 1 2 1c1.3 0 2-1 2-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStickyNote;
impl IconShape for LdStickyNote {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 9a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 15 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2z",
            }
            path {
                d: "M15 3v5a1 1 0 0 0 1 1h5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStore;
impl IconShape for LdStore {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 21v-5a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v5",
            }
            path {
                d: "M17.774 10.31a1.12 1.12 0 0 0-1.549 0 2.5 2.5 0 0 1-3.451 0 1.12 1.12 0 0 0-1.548 0 2.5 2.5 0 0 1-3.452 0 1.12 1.12 0 0 0-1.549 0 2.5 2.5 0 0 1-3.77-3.248l2.889-4.184A2 2 0 0 1 7 2h10a2 2 0 0 1 1.653.873l2.895 4.192a2.5 2.5 0 0 1-3.774 3.244",
            }
            path {
                d: "M4 10.95V19a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8.05",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStretchHorizontal;
impl IconShape for LdStretchHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
            rect {
                height: "6",
                rx: "2",
                width: "20",
                x: "2",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStretchVertical;
impl IconShape for LdStretchVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "2",
                width: "6",
                x: "4",
                y: "2",
            }
            rect {
                height: "20",
                rx: "2",
                width: "6",
                x: "14",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdStrikethrough;
impl IconShape for LdStrikethrough {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 4H9a3 3 0 0 0-2.83 4",
            }
            path {
                d: "M14 12a4 4 0 0 1 0 8H6",
            }
            line {
                x1: "4",
                x2: "20",
                y1: "12",
                y2: "12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSubscript;
impl IconShape for LdSubscript {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m4 5 8 8",
            }
            path {
                d: "m12 5-8 8",
            }
            path {
                d: "M20 19h-4c0-1.5.44-2 1.5-2.5S20 15.33 20 14c0-.47-.17-.93-.48-1.29a2.11 2.11 0 0 0-2.62-.44c-.42.24-.74.62-.9 1.07",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSunDim;
impl IconShape for LdSunDim {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "4",
            }
            path {
                d: "M12 4h.01",
            }
            path {
                d: "M20 12h.01",
            }
            path {
                d: "M12 20h.01",
            }
            path {
                d: "M4 12h.01",
            }
            path {
                d: "M17.657 6.343h.01",
            }
            path {
                d: "M17.657 17.657h.01",
            }
            path {
                d: "M6.343 17.657h.01",
            }
            path {
                d: "M6.343 6.343h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSunMedium;
impl IconShape for LdSunMedium {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "4",
            }
            path {
                d: "M12 3v1",
            }
            path {
                d: "M12 20v1",
            }
            path {
                d: "M3 12h1",
            }
            path {
                d: "M20 12h1",
            }
            path {
                d: "m18.364 5.636-.707.707",
            }
            path {
                d: "m6.343 17.657-.707.707",
            }
            path {
                d: "m5.636 5.636.707.707",
            }
            path {
                d: "m17.657 17.657.707.707",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSunMoon;
impl IconShape for LdSunMoon {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v2",
            }
            path {
                d: "M14.837 16.385a6 6 0 1 1-7.223-7.222c.624-.147.97.66.715 1.248a4 4 0 0 0 5.26 5.259c.589-.255 1.396.09 1.248.715",
            }
            path {
                d: "M16 12a4 4 0 0 0-4-4",
            }
            path {
                d: "m19 5-1.256 1.256",
            }
            path {
                d: "M20 12h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSunSnow;
impl IconShape for LdSunSnow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 21v-1",
            }
            path {
                d: "M10 4V3",
            }
            path {
                d: "M10 9a3 3 0 0 0 0 6",
            }
            path {
                d: "m14 20 1.25-2.5L18 18",
            }
            path {
                d: "m14 4 1.25 2.5L18 6",
            }
            path {
                d: "m17 21-3-6 1.5-3H22",
            }
            path {
                d: "m17 3-3 6 1.5 3",
            }
            path {
                d: "M2 12h1",
            }
            path {
                d: "m20 10-1.5 2 1.5 2",
            }
            path {
                d: "m3.64 18.36.7-.7",
            }
            path {
                d: "m4.34 6.34-.7-.7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSun;
impl IconShape for LdSun {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "4",
            }
            path {
                d: "M12 2v2",
            }
            path {
                d: "M12 20v2",
            }
            path {
                d: "m4.93 4.93 1.41 1.41",
            }
            path {
                d: "m17.66 17.66 1.41 1.41",
            }
            path {
                d: "M2 12h2",
            }
            path {
                d: "M20 12h2",
            }
            path {
                d: "m6.34 17.66-1.41 1.41",
            }
            path {
                d: "m19.07 4.93-1.41 1.41",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSunrise;
impl IconShape for LdSunrise {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v8",
            }
            path {
                d: "m4.93 10.93 1.41 1.41",
            }
            path {
                d: "M2 18h2",
            }
            path {
                d: "M20 18h2",
            }
            path {
                d: "m19.07 10.93-1.41 1.41",
            }
            path {
                d: "M22 22H2",
            }
            path {
                d: "m8 6 4-4 4 4",
            }
            path {
                d: "M16 18a4 4 0 0 0-8 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSunset;
impl IconShape for LdSunset {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 10V2",
            }
            path {
                d: "m4.93 10.93 1.41 1.41",
            }
            path {
                d: "M2 18h2",
            }
            path {
                d: "M20 18h2",
            }
            path {
                d: "m19.07 10.93-1.41 1.41",
            }
            path {
                d: "M22 22H2",
            }
            path {
                d: "m16 6-4 4-4-4",
            }
            path {
                d: "M16 18a4 4 0 0 0-8 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSuperscript;
impl IconShape for LdSuperscript {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m4 19 8-8",
            }
            path {
                d: "m12 19-8-8",
            }
            path {
                d: "M20 12h-4c0-1.5.442-2 1.5-2.5S20 8.334 20 7.002c0-.472-.17-.93-.484-1.29a2.105 2.105 0 0 0-2.617-.436c-.42.239-.738.614-.899 1.06",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSwatchBook;
impl IconShape for LdSwatchBook {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 17a4 4 0 0 1-8 0V5a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2Z",
            }
            path {
                d: "M16.7 13H19a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2H7",
            }
            path {
                d: "M 7 17h.01",
            }
            path {
                d: "m11 8 2.3-2.3a2.4 2.4 0 0 1 3.404.004L18.6 7.6a2.4 2.4 0 0 1 .026 3.434L9.9 19.8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSwissFranc;
impl IconShape for LdSwissFranc {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 21V3h8",
            }
            path {
                d: "M6 16h9",
            }
            path {
                d: "M10 9.5h7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSwitchCamera;
impl IconShape for LdSwitchCamera {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 19H4a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h5",
            }
            path {
                d: "M13 5h7a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-5",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "3",
            }
            path {
                d: "m18 22-3-3 3-3",
            }
            path {
                d: "m6 2 3 3-3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSword;
impl IconShape for LdSword {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m11 19-6-6",
            }
            path {
                d: "m5 21-2-2",
            }
            path {
                d: "m8 16-4 4",
            }
            path {
                d: "M9.5 17.5 21 6V3h-3L6.5 14.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSwords;
impl IconShape for LdSwords {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            polyline {
                points: "14.5 17.5 3 6 3 3 6 3 17.5 14.5",
            }
            line {
                x1: "13",
                x2: "19",
                y1: "19",
                y2: "13",
            }
            line {
                x1: "16",
                x2: "20",
                y1: "16",
                y2: "20",
            }
            line {
                x1: "19",
                x2: "21",
                y1: "21",
                y2: "19",
            }
            polyline {
                points: "14.5 6.5 18 3 21 3 21 6 17.5 9.5",
            }
            line {
                x1: "5",
                x2: "9",
                y1: "14",
                y2: "18",
            }
            line {
                x1: "7",
                x2: "4",
                y1: "17",
                y2: "20",
            }
            line {
                x1: "3",
                x2: "5",
                y1: "19",
                y2: "21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdSyringe;
impl IconShape for LdSyringe {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m18 2 4 4",
            }
            path {
                d: "m17 7 3-3",
            }
            path {
                d: "M19 9 8.7 19.3c-1 1-2.5 1-3.4 0l-.6-.6c-1-1-1-2.5 0-3.4L15 5",
            }
            path {
                d: "m9 11 4 4",
            }
            path {
                d: "m5 19-3 3",
            }
            path {
                d: "m14 4 6 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTable2;
impl IconShape for LdTable2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 3H5a2 2 0 0 0-2 2v4m6-6h10a2 2 0 0 1 2 2v4M9 3v18m0 0h10a2 2 0 0 0 2-2V9M9 21H5a2 2 0 0 1-2-2V9m0 0h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTableCellsMerge;
impl IconShape for LdTableCellsMerge {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 21v-6",
            }
            path {
                d: "M12 9V3",
            }
            path {
                d: "M3 15h18",
            }
            path {
                d: "M3 9h18",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTableCellsSplit;
impl IconShape for LdTableCellsSplit {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 15V9",
            }
            path {
                d: "M3 15h18",
            }
            path {
                d: "M3 9h18",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTableColumnsSplit;
impl IconShape for LdTableColumnsSplit {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 14v2",
            }
            path {
                d: "M14 20v2",
            }
            path {
                d: "M14 2v2",
            }
            path {
                d: "M14 8v2",
            }
            path {
                d: "M2 15h8",
            }
            path {
                d: "M2 3h6a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H2",
            }
            path {
                d: "M2 9h8",
            }
            path {
                d: "M22 15h-4",
            }
            path {
                d: "M22 3h-2a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h2",
            }
            path {
                d: "M22 9h-4",
            }
            path {
                d: "M5 3v18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTableOfContents;
impl IconShape for LdTableOfContents {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 5H3",
            }
            path {
                d: "M16 12H3",
            }
            path {
                d: "M16 19H3",
            }
            path {
                d: "M21 5h.01",
            }
            path {
                d: "M21 12h.01",
            }
            path {
                d: "M21 19h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTableProperties;
impl IconShape for LdTableProperties {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 3v18",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M21 9H3",
            }
            path {
                d: "M21 15H3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTableRowsSplit;
impl IconShape for LdTableRowsSplit {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 10h2",
            }
            path {
                d: "M15 22v-8",
            }
            path {
                d: "M15 2v4",
            }
            path {
                d: "M2 10h2",
            }
            path {
                d: "M20 10h2",
            }
            path {
                d: "M3 19h18",
            }
            path {
                d: "M3 22v-6a2 2 135 0 1 2-2h14a2 2 45 0 1 2 2v6",
            }
            path {
                d: "M3 2v2a2 2 45 0 0 2 2h14a2 2 135 0 0 2-2V2",
            }
            path {
                d: "M8 10h2",
            }
            path {
                d: "M9 22v-8",
            }
            path {
                d: "M9 2v4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTable;
impl IconShape for LdTable {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v18",
            }
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 9h18",
            }
            path {
                d: "M3 15h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTabletSmartphone;
impl IconShape for LdTabletSmartphone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "14",
                rx: "2",
                width: "10",
                x: "3",
                y: "8",
            }
            path {
                d: "M5 4a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v16a2 2 0 0 1-2 2h-2.4",
            }
            path {
                d: "M8 18h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTablet;
impl IconShape for LdTablet {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "20",
                rx: "2",
                ry: "2",
                width: "16",
                x: "4",
                y: "2",
            }
            line {
                x1: "12",
                x2: "12.01",
                y1: "18",
                y2: "18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTablets;
impl IconShape for LdTablets {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "7",
                cy: "7",
                r: "5",
            }
            circle {
                cx: "17",
                cy: "17",
                r: "5",
            }
            path {
                d: "M12 17h10",
            }
            path {
                d: "m3.46 10.54 7.08-7.08",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTag;
impl IconShape for LdTag {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.586 2.586A2 2 0 0 0 11.172 2H4a2 2 0 0 0-2 2v7.172a2 2 0 0 0 .586 1.414l8.704 8.704a2.426 2.426 0 0 0 3.42 0l6.58-6.58a2.426 2.426 0 0 0 0-3.42z",
            }
            circle {
                cx: "7.5",
                cy: "7.5",
                r: ".5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTags;
impl IconShape for LdTags {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.172 2a2 2 0 0 1 1.414.586l6.71 6.71a2.4 2.4 0 0 1 0 3.408l-4.592 4.592a2.4 2.4 0 0 1-3.408 0l-6.71-6.71A2 2 0 0 1 6 9.172V3a1 1 0 0 1 1-1z",
            }
            path {
                d: "M2 7v6.172a2 2 0 0 0 .586 1.414l6.71 6.71a2.4 2.4 0 0 0 3.191.193",
            }
            circle {
                cx: "10.5",
                cy: "6.5",
                r: ".5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTally1;
impl IconShape for LdTally1 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 4v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTally2;
impl IconShape for LdTally2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 4v16",
            }
            path {
                d: "M9 4v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTally3;
impl IconShape for LdTally3 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 4v16",
            }
            path {
                d: "M9 4v16",
            }
            path {
                d: "M14 4v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTally4;
impl IconShape for LdTally4 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 4v16",
            }
            path {
                d: "M9 4v16",
            }
            path {
                d: "M14 4v16",
            }
            path {
                d: "M19 4v16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTally5;
impl IconShape for LdTally5 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 4v16",
            }
            path {
                d: "M9 4v16",
            }
            path {
                d: "M14 4v16",
            }
            path {
                d: "M19 4v16",
            }
            path {
                d: "M22 6 2 18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTangent;
impl IconShape for LdTangent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "17",
                cy: "4",
                r: "2",
            }
            path {
                d: "M15.59 5.41 5.41 15.59",
            }
            circle {
                cx: "4",
                cy: "17",
                r: "2",
            }
            path {
                d: "M12 22s-4-9-1.5-11.5S22 12 22 12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTarget;
impl IconShape for LdTarget {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "6",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTelescope;
impl IconShape for LdTelescope {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10.065 12.493-6.18 1.318a.934.934 0 0 1-1.108-.702l-.537-2.15a1.07 1.07 0 0 1 .691-1.265l13.504-4.44",
            }
            path {
                d: "m13.56 11.747 4.332-.924",
            }
            path {
                d: "m16 21-3.105-6.21",
            }
            path {
                d: "M16.485 5.94a2 2 0 0 1 1.455-2.425l1.09-.272a1 1 0 0 1 1.212.727l1.515 6.06a1 1 0 0 1-.727 1.213l-1.09.272a2 2 0 0 1-2.425-1.455z",
            }
            path {
                d: "m6.158 8.633 1.114 4.456",
            }
            path {
                d: "m8 21 3.105-6.21",
            }
            circle {
                cx: "12",
                cy: "13",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTentTree;
impl IconShape for LdTentTree {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "4",
                cy: "4",
                r: "2",
            }
            path {
                d: "m14 5 3-3 3 3",
            }
            path {
                d: "m14 10 3-3 3 3",
            }
            path {
                d: "M17 14V2",
            }
            path {
                d: "M17 14H7l-5 8h20Z",
            }
            path {
                d: "M8 14v8",
            }
            path {
                d: "m9 14 5 8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTent;
impl IconShape for LdTent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3.5 21 14 3",
            }
            path {
                d: "M20.5 21 10 3",
            }
            path {
                d: "M15.5 21 12 15l-3.5 6",
            }
            path {
                d: "M2 21h20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTerminal;
impl IconShape for LdTerminal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 19h8",
            }
            path {
                d: "m4 17 6-6-6-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTestTubeDiagonal;
impl IconShape for LdTestTubeDiagonal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 7 6.82 21.18a2.83 2.83 0 0 1-3.99-.01a2.83 2.83 0 0 1 0-4L17 3",
            }
            path {
                d: "m16 2 6 6",
            }
            path {
                d: "M12 16H4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTestTube;
impl IconShape for LdTestTube {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14.5 2v17.5c0 1.4-1.1 2.5-2.5 2.5c-1.4 0-2.5-1.1-2.5-2.5V2",
            }
            path {
                d: "M8.5 2h7",
            }
            path {
                d: "M14.5 16h-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTestTubes;
impl IconShape for LdTestTubes {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 2v17.5A2.5 2.5 0 0 1 6.5 22A2.5 2.5 0 0 1 4 19.5V2",
            }
            path {
                d: "M20 2v17.5a2.5 2.5 0 0 1-2.5 2.5a2.5 2.5 0 0 1-2.5-2.5V2",
            }
            path {
                d: "M3 2h7",
            }
            path {
                d: "M14 2h7",
            }
            path {
                d: "M9 16H4",
            }
            path {
                d: "M20 16h-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextAlignCenter;
impl IconShape for LdTextAlignCenter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 5H3",
            }
            path {
                d: "M17 12H7",
            }
            path {
                d: "M19 19H5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextAlignEnd;
impl IconShape for LdTextAlignEnd {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 5H3",
            }
            path {
                d: "M21 12H9",
            }
            path {
                d: "M21 19H7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextAlignJustify;
impl IconShape for LdTextAlignJustify {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 5h18",
            }
            path {
                d: "M3 12h18",
            }
            path {
                d: "M3 19h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextAlignStart;
impl IconShape for LdTextAlignStart {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 5H3",
            }
            path {
                d: "M15 12H3",
            }
            path {
                d: "M17 19H3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextCursorInput;
impl IconShape for LdTextCursorInput {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 20h-1a2 2 0 0 1-2-2 2 2 0 0 1-2 2H6",
            }
            path {
                d: "M13 8h7a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-7",
            }
            path {
                d: "M5 16H4a2 2 0 0 1-2-2v-4a2 2 0 0 1 2-2h1",
            }
            path {
                d: "M6 4h1a2 2 0 0 1 2 2 2 2 0 0 1 2-2h1",
            }
            path {
                d: "M9 6v12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextCursor;
impl IconShape for LdTextCursor {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 22h-1a4 4 0 0 1-4-4V6a4 4 0 0 1 4-4h1",
            }
            path {
                d: "M7 22h1a4 4 0 0 0 4-4v-1",
            }
            path {
                d: "M7 2h1a4 4 0 0 1 4 4v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextInitial;
impl IconShape for LdTextInitial {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 5h6",
            }
            path {
                d: "M15 12h6",
            }
            path {
                d: "M3 19h18",
            }
            path {
                d: "m3 12 3.553-7.724a.5.5 0 0 1 .894 0L11 12",
            }
            path {
                d: "M3.92 10h6.16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextQuote;
impl IconShape for LdTextQuote {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 5H3",
            }
            path {
                d: "M21 12H8",
            }
            path {
                d: "M21 19H8",
            }
            path {
                d: "M3 12v7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextSearch;
impl IconShape for LdTextSearch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 5H3",
            }
            path {
                d: "M10 12H3",
            }
            path {
                d: "M10 19H3",
            }
            circle {
                cx: "17",
                cy: "15",
                r: "3",
            }
            path {
                d: "m21 19-1.9-1.9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextSelect;
impl IconShape for LdTextSelect {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 21h1",
            }
            path {
                d: "M14 3h1",
            }
            path {
                d: "M19 3a2 2 0 0 1 2 2",
            }
            path {
                d: "M21 14v1",
            }
            path {
                d: "M21 19a2 2 0 0 1-2 2",
            }
            path {
                d: "M21 9v1",
            }
            path {
                d: "M3 14v1",
            }
            path {
                d: "M3 9v1",
            }
            path {
                d: "M5 21a2 2 0 0 1-2-2",
            }
            path {
                d: "M5 3a2 2 0 0 0-2 2",
            }
            path {
                d: "M7 12h10",
            }
            path {
                d: "M7 16h6",
            }
            path {
                d: "M7 8h8",
            }
            path {
                d: "M9 21h1",
            }
            path {
                d: "M9 3h1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTextWrap;
impl IconShape for LdTextWrap {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 16-3 3 3 3",
            }
            path {
                d: "M3 12h14.5a1 1 0 0 1 0 7H13",
            }
            path {
                d: "M3 19h6",
            }
            path {
                d: "M3 5h18",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTheater;
impl IconShape for LdTheater {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 10s3-3 3-8",
            }
            path {
                d: "M22 10s-3-3-3-8",
            }
            path {
                d: "M10 2c0 4.4-3.6 8-8 8",
            }
            path {
                d: "M14 2c0 4.4 3.6 8 8 8",
            }
            path {
                d: "M2 10s2 2 2 5",
            }
            path {
                d: "M22 10s-2 2-2 5",
            }
            path {
                d: "M8 15h8",
            }
            path {
                d: "M2 22v-1a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1",
            }
            path {
                d: "M14 22v-1a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdThermometerSnowflake;
impl IconShape for LdThermometerSnowflake {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 20-1.25-2.5L6 18",
            }
            path {
                d: "M10 4 8.75 6.5 6 6",
            }
            path {
                d: "M10.585 15H10",
            }
            path {
                d: "M2 12h6.5L10 9",
            }
            path {
                d: "M20 14.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0z",
            }
            path {
                d: "m4 10 1.5 2L4 14",
            }
            path {
                d: "m7 21 3-6-1.5-3",
            }
            path {
                d: "m7 3 3 6h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdThermometerSun;
impl IconShape for LdThermometerSun {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 9a4 4 0 0 0-2 7.5",
            }
            path {
                d: "M12 3v2",
            }
            path {
                d: "m6.6 18.4-1.4 1.4",
            }
            path {
                d: "M20 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z",
            }
            path {
                d: "M4 13H2",
            }
            path {
                d: "M6.34 7.34 4.93 5.93",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdThermometer;
impl IconShape for LdThermometer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdThumbsDown;
impl IconShape for LdThumbsDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 14V2",
            }
            path {
                d: "M9 18.12 10 14H4.17a2 2 0 0 1-1.92-2.56l2.33-8A2 2 0 0 1 6.5 2H20a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2.76a2 2 0 0 0-1.79 1.11L12 22a3.13 3.13 0 0 1-3-3.88Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdThumbsUp;
impl IconShape for LdThumbsUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 10v12",
            }
            path {
                d: "M15 5.88 14 10h5.83a2 2 0 0 1 1.92 2.56l-2.33 8A2 2 0 0 1 17.5 22H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2h2.76a2 2 0 0 0 1.79-1.11L12 2a3.13 3.13 0 0 1 3 3.88Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTicketCheck;
impl IconShape for LdTicketCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z",
            }
            path {
                d: "m9 12 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTicketMinus;
impl IconShape for LdTicketMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z",
            }
            path {
                d: "M9 12h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTicketPercent;
impl IconShape for LdTicketPercent {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9a3 3 0 1 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 1 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z",
            }
            path {
                d: "M9 9h.01",
            }
            path {
                d: "m15 9-6 6",
            }
            path {
                d: "M15 15h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTicketPlus;
impl IconShape for LdTicketPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z",
            }
            path {
                d: "M9 12h6",
            }
            path {
                d: "M12 9v6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTicketSlash;
impl IconShape for LdTicketSlash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z",
            }
            path {
                d: "m9.5 14.5 5-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTicketX;
impl IconShape for LdTicketX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z",
            }
            path {
                d: "m9.5 14.5 5-5",
            }
            path {
                d: "m9.5 9.5 5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTicket;
impl IconShape for LdTicket {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z",
            }
            path {
                d: "M13 5v2",
            }
            path {
                d: "M13 17v2",
            }
            path {
                d: "M13 11v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTicketsPlane;
impl IconShape for LdTicketsPlane {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.5 17h1.227a2 2 0 0 0 1.345-.52L18 12",
            }
            path {
                d: "m12 13.5 3.75.5",
            }
            path {
                d: "m4.5 8 10.58-5.06a1 1 0 0 1 1.342.488L18.5 8",
            }
            path {
                d: "M6 10V8",
            }
            path {
                d: "M6 14v1",
            }
            path {
                d: "M6 19v2",
            }
            rect {
                height: "13",
                rx: "2",
                width: "20",
                x: "2",
                y: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTickets;
impl IconShape for LdTickets {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m4.5 8 10.58-5.06a1 1 0 0 1 1.342.488L18.5 8",
            }
            path {
                d: "M6 10V8",
            }
            path {
                d: "M6 14v1",
            }
            path {
                d: "M6 19v2",
            }
            rect {
                height: "13",
                rx: "2",
                width: "20",
                x: "2",
                y: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTimerOff;
impl IconShape for LdTimerOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2h4",
            }
            path {
                d: "M4.6 11a8 8 0 0 0 1.7 8.7 8 8 0 0 0 8.7 1.7",
            }
            path {
                d: "M7.4 7.4a8 8 0 0 1 10.3 1 8 8 0 0 1 .9 10.2",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M12 12v-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTimerReset;
impl IconShape for LdTimerReset {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2h4",
            }
            path {
                d: "M12 14v-4",
            }
            path {
                d: "M4 13a8 8 0 0 1 8-7 8 8 0 1 1-5.3 14L4 17.6",
            }
            path {
                d: "M9 17H4v5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTimer;
impl IconShape for LdTimer {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            line {
                x1: "10",
                x2: "14",
                y1: "2",
                y2: "2",
            }
            line {
                x1: "12",
                x2: "15",
                y1: "14",
                y2: "11",
            }
            circle {
                cx: "12",
                cy: "14",
                r: "8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdToggleLeft;
impl IconShape for LdToggleLeft {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "9",
                cy: "12",
                r: "3",
            }
            rect {
                height: "14",
                rx: "7",
                width: "20",
                x: "2",
                y: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdToggleRight;
impl IconShape for LdToggleRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "15",
                cy: "12",
                r: "3",
            }
            rect {
                height: "14",
                rx: "7",
                width: "20",
                x: "2",
                y: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdToilet;
impl IconShape for LdToilet {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 12h13a1 1 0 0 1 1 1 5 5 0 0 1-5 5h-.598a.5.5 0 0 0-.424.765l1.544 2.47a.5.5 0 0 1-.424.765H5.402a.5.5 0 0 1-.424-.765L7 18",
            }
            path {
                d: "M8 18a5 5 0 0 1-5-5V4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdToolCase;
impl IconShape for LdToolCase {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 15h4",
            }
            path {
                d: "m14.817 10.995-.971-1.45 1.034-1.232a2 2 0 0 0-2.025-3.238l-1.82.364L9.91 3.885a2 2 0 0 0-3.625.748L6.141 6.55l-1.725.426a2 2 0 0 0-.19 3.756l.657.27",
            }
            path {
                d: "m18.822 10.995 2.26-5.38a1 1 0 0 0-.557-1.318L16.954 2.9a1 1 0 0 0-1.281.533l-.924 2.122",
            }
            path {
                d: "M4 12.006A1 1 0 0 1 4.994 11H19a1 1 0 0 1 1 1v7a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTornado;
impl IconShape for LdTornado {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 4H3",
            }
            path {
                d: "M18 8H6",
            }
            path {
                d: "M19 12H9",
            }
            path {
                d: "M16 16h-6",
            }
            path {
                d: "M11 20H9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTorus;
impl IconShape for LdTorus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            ellipse {
                cx: "12",
                cy: "11",
                rx: "3",
                ry: "2",
            }
            ellipse {
                cx: "12",
                cy: "12.5",
                rx: "10",
                ry: "8.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTouchpadOff;
impl IconShape for LdTouchpadOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 20v-6",
            }
            path {
                d: "M19.656 14H22",
            }
            path {
                d: "M2 14h12",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M20 20H4a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2",
            }
            path {
                d: "M9.656 4H20a2 2 0 0 1 2 2v10.344",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTouchpad;
impl IconShape for LdTouchpad {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
            path {
                d: "M2 14h20",
            }
            path {
                d: "M12 20v-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTowerControl;
impl IconShape for LdTowerControl {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18.2 12.27 20 6H4l1.8 6.27a1 1 0 0 0 .95.73h10.5a1 1 0 0 0 .96-.73Z",
            }
            path {
                d: "M8 13v9",
            }
            path {
                d: "M16 22v-9",
            }
            path {
                d: "m9 6 1 7",
            }
            path {
                d: "m15 6-1 7",
            }
            path {
                d: "M12 6V2",
            }
            path {
                d: "M13 2h-2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdToyBrick;
impl IconShape for LdToyBrick {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "12",
                rx: "1",
                width: "18",
                x: "3",
                y: "8",
            }
            path {
                d: "M10 8V5c0-.6-.4-1-1-1H6a1 1 0 0 0-1 1v3",
            }
            path {
                d: "M19 8V5c0-.6-.4-1-1-1h-3a1 1 0 0 0-1 1v3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTractor;
impl IconShape for LdTractor {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m10 11 11 .9a1 1 0 0 1 .8 1.1l-.665 4.158a1 1 0 0 1-.988.842H20",
            }
            path {
                d: "M16 18h-5",
            }
            path {
                d: "M18 5a1 1 0 0 0-1 1v5.573",
            }
            path {
                d: "M3 4h8.129a1 1 0 0 1 .99.863L13 11.246",
            }
            path {
                d: "M4 11V4",
            }
            path {
                d: "M7 15h.01",
            }
            path {
                d: "M8 10.1V4",
            }
            circle {
                cx: "18",
                cy: "18",
                r: "2",
            }
            circle {
                cx: "7",
                cy: "15",
                r: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrafficCone;
impl IconShape for LdTrafficCone {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16.05 10.966a5 2.5 0 0 1-8.1 0",
            }
            path {
                d: "m16.923 14.049 4.48 2.04a1 1 0 0 1 .001 1.831l-8.574 3.9a2 2 0 0 1-1.66 0l-8.574-3.91a1 1 0 0 1 0-1.83l4.484-2.04",
            }
            path {
                d: "M16.949 14.14a5 2.5 0 1 1-9.9 0L10.063 3.5a2 2 0 0 1 3.874 0z",
            }
            path {
                d: "M9.194 6.57a5 2.5 0 0 0 5.61 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrainFrontTunnel;
impl IconShape for LdTrainFrontTunnel {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 22V12a10 10 0 1 1 20 0v10",
            }
            path {
                d: "M15 6.8v1.4a3 2.8 0 1 1-6 0V6.8",
            }
            path {
                d: "M10 15h.01",
            }
            path {
                d: "M14 15h.01",
            }
            path {
                d: "M10 19a4 4 0 0 1-4-4v-3a6 6 0 1 1 12 0v3a4 4 0 0 1-4 4Z",
            }
            path {
                d: "m9 19-2 3",
            }
            path {
                d: "m15 19 2 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrainFront;
impl IconShape for LdTrainFront {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 3.1V7a4 4 0 0 0 8 0V3.1",
            }
            path {
                d: "m9 15-1-1",
            }
            path {
                d: "m15 15 1-1",
            }
            path {
                d: "M9 19c-2.8 0-5-2.2-5-5v-4a8 8 0 0 1 16 0v4c0 2.8-2.2 5-5 5Z",
            }
            path {
                d: "m8 19-2 3",
            }
            path {
                d: "m16 19 2 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrainTrack;
impl IconShape for LdTrainTrack {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 17 17 2",
            }
            path {
                d: "m2 14 8 8",
            }
            path {
                d: "m5 11 8 8",
            }
            path {
                d: "m8 8 8 8",
            }
            path {
                d: "m11 5 8 8",
            }
            path {
                d: "m14 2 8 8",
            }
            path {
                d: "M7 22 22 7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTramFront;
impl IconShape for LdTramFront {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "16",
                rx: "2",
                width: "16",
                x: "4",
                y: "3",
            }
            path {
                d: "M4 11h16",
            }
            path {
                d: "M12 3v8",
            }
            path {
                d: "m8 19-2 3",
            }
            path {
                d: "m18 22-2-3",
            }
            path {
                d: "M8 15h.01",
            }
            path {
                d: "M16 15h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTransgender;
impl IconShape for LdTransgender {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 16v6",
            }
            path {
                d: "M14 20h-4",
            }
            path {
                d: "M18 2h4v4",
            }
            path {
                d: "m2 2 7.17 7.17",
            }
            path {
                d: "M2 5.355V2h3.357",
            }
            path {
                d: "m22 2-7.17 7.17",
            }
            path {
                d: "M8 5 5 8",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrash2;
impl IconShape for LdTrash2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 11v6",
            }
            path {
                d: "M14 11v6",
            }
            path {
                d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6",
            }
            path {
                d: "M3 6h18",
            }
            path {
                d: "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrash;
impl IconShape for LdTrash {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6",
            }
            path {
                d: "M3 6h18",
            }
            path {
                d: "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTreeDeciduous;
impl IconShape for LdTreeDeciduous {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 19a4 4 0 0 1-2.24-7.32A3.5 3.5 0 0 1 9 6.03V6a3 3 0 1 1 6 0v.04a3.5 3.5 0 0 1 3.24 5.65A4 4 0 0 1 16 19Z",
            }
            path {
                d: "M12 19v3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTreePalm;
impl IconShape for LdTreePalm {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13 8c0-2.76-2.46-5-5.5-5S2 5.24 2 8h2l1-1 1 1h4",
            }
            path {
                d: "M13 7.14A5.82 5.82 0 0 1 16.5 6c3.04 0 5.5 2.24 5.5 5h-3l-1-1-1 1h-3",
            }
            path {
                d: "M5.89 9.71c-2.15 2.15-2.3 5.47-.35 7.43l4.24-4.25.7-.7.71-.71 2.12-2.12c-1.95-1.96-5.27-1.8-7.42.35",
            }
            path {
                d: "M11 15.5c.5 2.5-.17 4.5-1 6.5h4c2-5.5-.5-12-1-14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTreePine;
impl IconShape for LdTreePine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m17 14 3 3.3a1 1 0 0 1-.7 1.7H4.7a1 1 0 0 1-.7-1.7L7 14h-.3a1 1 0 0 1-.7-1.7L9 9h-.2A1 1 0 0 1 8 7.3L12 3l4 4.3a1 1 0 0 1-.8 1.7H15l3 3.3a1 1 0 0 1-.7 1.7H17Z",
            }
            path {
                d: "M12 22v-3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrees;
impl IconShape for LdTrees {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 10v.2A3 3 0 0 1 8.9 16H5a3 3 0 0 1-1-5.8V10a3 3 0 0 1 6 0Z",
            }
            path {
                d: "M7 16v6",
            }
            path {
                d: "M13 19v3",
            }
            path {
                d: "M12 19h8.3a1 1 0 0 0 .7-1.7L18 14h.3a1 1 0 0 0 .7-1.7L16 9h.2a1 1 0 0 0 .8-1.7L13 3l-1.4 1.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrello;
impl IconShape for LdTrello {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                ry: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            rect {
                height: "9",
                width: "3",
                x: "7",
                y: "7",
            }
            rect {
                height: "5",
                width: "3",
                x: "14",
                y: "7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrendingDown;
impl IconShape for LdTrendingDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 17h6v-6",
            }
            path {
                d: "m22 17-8.5-8.5-5 5L2 7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrendingUpDown;
impl IconShape for LdTrendingUpDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14.828 14.828 21 21",
            }
            path {
                d: "M21 16v5h-5",
            }
            path {
                d: "m21 3-9 9-4-4-6 6",
            }
            path {
                d: "M21 8V3h-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrendingUp;
impl IconShape for LdTrendingUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 7h6v6",
            }
            path {
                d: "m22 7-8.5 8.5-5-5L2 17",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTriangleAlert;
impl IconShape for LdTriangleAlert {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3",
            }
            path {
                d: "M12 9v4",
            }
            path {
                d: "M12 17h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTriangleDashed;
impl IconShape for LdTriangleDashed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.17 4.193a2 2 0 0 1 3.666.013",
            }
            path {
                d: "M14 21h2",
            }
            path {
                d: "m15.874 7.743 1 1.732",
            }
            path {
                d: "m18.849 12.952 1 1.732",
            }
            path {
                d: "M21.824 18.18a2 2 0 0 1-1.835 2.824",
            }
            path {
                d: "M4.024 21a2 2 0 0 1-1.839-2.839",
            }
            path {
                d: "m5.136 12.952-1 1.732",
            }
            path {
                d: "M8 21h2",
            }
            path {
                d: "m8.102 7.743-1 1.732",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTriangleRight;
impl IconShape for LdTriangleRight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 18a2 2 0 0 1-2 2H3c-1.1 0-1.3-.6-.4-1.3L20.4 4.3c.9-.7 1.6-.4 1.6.7Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTriangle;
impl IconShape for LdTriangle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M13.73 4a2 2 0 0 0-3.46 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTrophy;
impl IconShape for LdTrophy {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 14.66v1.626a2 2 0 0 1-.976 1.696A5 5 0 0 0 7 21.978",
            }
            path {
                d: "M14 14.66v1.626a2 2 0 0 0 .976 1.696A5 5 0 0 1 17 21.978",
            }
            path {
                d: "M18 9h1.5a1 1 0 0 0 0-5H18",
            }
            path {
                d: "M4 22h16",
            }
            path {
                d: "M6 9a6 6 0 0 0 12 0V3a1 1 0 0 0-1-1H7a1 1 0 0 0-1 1z",
            }
            path {
                d: "M6 9H4.5a1 1 0 0 1 0-5H6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTruckElectric;
impl IconShape for LdTruckElectric {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 19V7a2 2 0 0 0-2-2H9",
            }
            path {
                d: "M15 19H9",
            }
            path {
                d: "M19 19h2a1 1 0 0 0 1-1v-3.65a1 1 0 0 0-.22-.62L18.3 9.38a1 1 0 0 0-.78-.38H14",
            }
            path {
                d: "M2 13v5a1 1 0 0 0 1 1h2",
            }
            path {
                d: "M4 3 2.15 5.15a.495.495 0 0 0 .35.86h2.15a.47.47 0 0 1 .35.86L3 9.02",
            }
            circle {
                cx: "17",
                cy: "19",
                r: "2",
            }
            circle {
                cx: "7",
                cy: "19",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTruck;
impl IconShape for LdTruck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 18V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v11a1 1 0 0 0 1 1h2",
            }
            path {
                d: "M15 18H9",
            }
            path {
                d: "M19 18h2a1 1 0 0 0 1-1v-3.65a1 1 0 0 0-.22-.624l-3.48-4.35A1 1 0 0 0 17.52 8H14",
            }
            circle {
                cx: "17",
                cy: "18",
                r: "2",
            }
            circle {
                cx: "7",
                cy: "18",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTurkishLira;
impl IconShape for LdTurkishLira {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 4 5 9",
            }
            path {
                d: "m15 8.5-10 5",
            }
            path {
                d: "M18 12a9 9 0 0 1-9 9V3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTurntable;
impl IconShape for LdTurntable {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 12.01h.01",
            }
            path {
                d: "M18 8v4a8 8 0 0 1-1.07 4",
            }
            circle {
                cx: "10",
                cy: "12",
                r: "4",
            }
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTurtle;
impl IconShape for LdTurtle {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m12 10 2 4v3a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-3a8 8 0 1 0-16 0v3a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-3l2-4h4Z",
            }
            path {
                d: "M4.82 7.9 8 10",
            }
            path {
                d: "M15.18 7.9 12 10",
            }
            path {
                d: "M16.93 10H20a2 2 0 0 1 0 4H2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTvMinimalPlay;
impl IconShape for LdTvMinimalPlay {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15.033 9.44a.647.647 0 0 1 0 1.12l-4.065 2.352a.645.645 0 0 1-.968-.56V7.648a.645.645 0 0 1 .967-.56z",
            }
            path {
                d: "M7 21h10",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTvMinimal;
impl IconShape for LdTvMinimal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M7 21h10",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTv;
impl IconShape for LdTv {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m17 2-5 5-5-5",
            }
            rect {
                height: "15",
                rx: "2",
                width: "20",
                x: "2",
                y: "7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTwitch;
impl IconShape for LdTwitch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 2H3v16h5v4l4-4h5l4-4V2zm-10 9V7m5 4V7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTwitter;
impl IconShape for LdTwitter {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M22 4s-.7 2.1-2 3.4c1.6 10-9.4 17.3-18 11.6 2.2.1 4.4-.6 6-2C3 15.5.5 9.6 3 5c2.2 2.6 5.6 4.1 9 4-.9-4.2 4-6.6 7-3.8 1.1 0 3-1.2 3-1.2z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdTypeOutline;
impl IconShape for LdTypeOutline {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 16.5a.5.5 0 0 0 .5.5h.5a2 2 0 0 1 0 4H9a2 2 0 0 1 0-4h.5a.5.5 0 0 0 .5-.5v-9a.5.5 0 0 0-.5-.5h-3a.5.5 0 0 0-.5.5V8a2 2 0 0 1-4 0V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v3a2 2 0 0 1-4 0v-.5a.5.5 0 0 0-.5-.5h-3a.5.5 0 0 0-.5.5Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdType;
impl IconShape for LdType {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 4v16",
            }
            path {
                d: "M4 7V5a1 1 0 0 1 1-1h14a1 1 0 0 1 1 1v2",
            }
            path {
                d: "M9 20h6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUmbrellaOff;
impl IconShape for LdUmbrellaOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13v7a2 2 0 0 0 4 0",
            }
            path {
                d: "M12 2v2",
            }
            path {
                d: "M18.656 13h2.336a1 1 0 0 0 .97-1.274 10.284 10.284 0 0 0-12.07-7.51",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "M5.961 5.957a10.28 10.28 0 0 0-3.922 5.769A1 1 0 0 0 3 13h10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUmbrella;
impl IconShape for LdUmbrella {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 13v7a2 2 0 0 0 4 0",
            }
            path {
                d: "M12 2v2",
            }
            path {
                d: "M20.992 13a1 1 0 0 0 .97-1.274 10.284 10.284 0 0 0-19.923 0A1 1 0 0 0 3 13z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUnderline;
impl IconShape for LdUnderline {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M6 4v6a6 6 0 0 0 12 0V4",
            }
            line {
                x1: "4",
                x2: "20",
                y1: "20",
                y2: "20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUndo2;
impl IconShape for LdUndo2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M9 14 4 9l5-5",
            }
            path {
                d: "M4 9h10.5a5.5 5.5 0 0 1 5.5 5.5a5.5 5.5 0 0 1-5.5 5.5H11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUndoDot;
impl IconShape for LdUndoDot {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 17a9 9 0 0 0-15-6.7L3 13",
            }
            path {
                d: "M3 7v6h6",
            }
            circle {
                cx: "12",
                cy: "17",
                r: "1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUndo;
impl IconShape for LdUndo {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 7v6h6",
            }
            path {
                d: "M21 17a9 9 0 0 0-9-9 9 9 0 0 0-6 2.3L3 13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUnfoldHorizontal;
impl IconShape for LdUnfoldHorizontal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 12h6",
            }
            path {
                d: "M8 12H2",
            }
            path {
                d: "M12 2v2",
            }
            path {
                d: "M12 8v2",
            }
            path {
                d: "M12 14v2",
            }
            path {
                d: "M12 20v2",
            }
            path {
                d: "m19 15 3-3-3-3",
            }
            path {
                d: "m5 9-3 3 3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUnfoldVertical;
impl IconShape for LdUnfoldVertical {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 22v-6",
            }
            path {
                d: "M12 8V2",
            }
            path {
                d: "M4 12H2",
            }
            path {
                d: "M10 12H8",
            }
            path {
                d: "M16 12h-2",
            }
            path {
                d: "M22 12h-2",
            }
            path {
                d: "m15 19-3 3-3-3",
            }
            path {
                d: "m15 5-3-3-3 3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUngroup;
impl IconShape for LdUngroup {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "6",
                rx: "1",
                width: "8",
                x: "5",
                y: "4",
            }
            rect {
                height: "6",
                rx: "1",
                width: "8",
                x: "11",
                y: "14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUniversity;
impl IconShape for LdUniversity {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14 21v-3a2 2 0 0 0-4 0v3",
            }
            path {
                d: "M18 12h.01",
            }
            path {
                d: "M18 16h.01",
            }
            path {
                d: "M22 7a1 1 0 0 0-1-1h-2a2 2 0 0 1-1.143-.359L13.143 2.36a2 2 0 0 0-2.286-.001L6.143 5.64A2 2 0 0 1 5 6H3a1 1 0 0 0-1 1v12a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2z",
            }
            path {
                d: "M6 12h.01",
            }
            path {
                d: "M6 16h.01",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUnlink2;
impl IconShape for LdUnlink2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 7h2a5 5 0 0 1 0 10h-2m-6 0H7A5 5 0 0 1 7 7h2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUnlink;
impl IconShape for LdUnlink {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m18.84 12.25 1.72-1.71h-.02a5.004 5.004 0 0 0-.12-7.07 5.006 5.006 0 0 0-6.95 0l-1.72 1.71",
            }
            path {
                d: "m5.17 11.75-1.71 1.71a5.004 5.004 0 0 0 .12 7.07 5.006 5.006 0 0 0 6.95 0l1.71-1.71",
            }
            line {
                x1: "8",
                x2: "8",
                y1: "2",
                y2: "5",
            }
            line {
                x1: "2",
                x2: "5",
                y1: "8",
                y2: "8",
            }
            line {
                x1: "16",
                x2: "16",
                y1: "19",
                y2: "22",
            }
            line {
                x1: "19",
                x2: "22",
                y1: "16",
                y2: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUnplug;
impl IconShape for LdUnplug {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m19 5 3-3",
            }
            path {
                d: "m2 22 3-3",
            }
            path {
                d: "M6.3 20.3a2.4 2.4 0 0 0 3.4 0L12 18l-6-6-2.3 2.3a2.4 2.4 0 0 0 0 3.4Z",
            }
            path {
                d: "M7.5 13.5 10 11",
            }
            path {
                d: "M10.5 16.5 13 14",
            }
            path {
                d: "m12 6 6 6 2.3-2.3a2.4 2.4 0 0 0 0-3.4l-2.6-2.6a2.4 2.4 0 0 0-3.4 0Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUpload;
impl IconShape for LdUpload {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 3v12",
            }
            path {
                d: "m17 8-5-5-5 5",
            }
            path {
                d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUsb;
impl IconShape for LdUsb {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "10",
                cy: "7",
                r: "1",
            }
            circle {
                cx: "4",
                cy: "20",
                r: "1",
            }
            path {
                d: "M4.7 19.3 19 5",
            }
            path {
                d: "m21 3-3 1 2 2Z",
            }
            path {
                d: "M9.26 7.68 5 12l2 5",
            }
            path {
                d: "m10 14 5 2 3.5-3.5",
            }
            path {
                d: "m18 12 1-1 1 1-1 1Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserCheck;
impl IconShape for LdUserCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 11 2 2 4-4",
            }
            path {
                d: "M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2",
            }
            circle {
                cx: "9",
                cy: "7",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserCog;
impl IconShape for LdUserCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 15H6a4 4 0 0 0-4 4v2",
            }
            path {
                d: "m14.305 16.53.923-.382",
            }
            path {
                d: "m15.228 13.852-.923-.383",
            }
            path {
                d: "m16.852 12.228-.383-.923",
            }
            path {
                d: "m16.852 17.772-.383.924",
            }
            path {
                d: "m19.148 12.228.383-.923",
            }
            path {
                d: "m19.53 18.696-.382-.924",
            }
            path {
                d: "m20.772 13.852.924-.383",
            }
            path {
                d: "m20.772 16.148.924.383",
            }
            circle {
                cx: "18",
                cy: "15",
                r: "3",
            }
            circle {
                cx: "9",
                cy: "7",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserLock;
impl IconShape for LdUserLock {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "10",
                cy: "7",
                r: "4",
            }
            path {
                d: "M10.3 15H7a4 4 0 0 0-4 4v2",
            }
            path {
                d: "M15 15.5V14a2 2 0 0 1 4 0v1.5",
            }
            rect {
                height: "5",
                rx: ".899",
                width: "8",
                x: "13",
                y: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserMinus;
impl IconShape for LdUserMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2",
            }
            circle {
                cx: "9",
                cy: "7",
                r: "4",
            }
            line {
                x1: "22",
                x2: "16",
                y1: "11",
                y2: "11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserPen;
impl IconShape for LdUserPen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.5 15H7a4 4 0 0 0-4 4v2",
            }
            path {
                d: "M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z",
            }
            circle {
                cx: "10",
                cy: "7",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserPlus;
impl IconShape for LdUserPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2",
            }
            circle {
                cx: "9",
                cy: "7",
                r: "4",
            }
            line {
                x1: "19",
                x2: "19",
                y1: "8",
                y2: "14",
            }
            line {
                x1: "22",
                x2: "16",
                y1: "11",
                y2: "11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserRoundCheck;
impl IconShape for LdUserRoundCheck {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 21a8 8 0 0 1 13.292-6",
            }
            circle {
                cx: "10",
                cy: "8",
                r: "5",
            }
            path {
                d: "m16 19 2 2 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserRoundCog;
impl IconShape for LdUserRoundCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14.305 19.53.923-.382",
            }
            path {
                d: "m15.228 16.852-.923-.383",
            }
            path {
                d: "m16.852 15.228-.383-.923",
            }
            path {
                d: "m16.852 20.772-.383.924",
            }
            path {
                d: "m19.148 15.228.383-.923",
            }
            path {
                d: "m19.53 21.696-.382-.924",
            }
            path {
                d: "M2 21a8 8 0 0 1 10.434-7.62",
            }
            path {
                d: "m20.772 16.852.924-.383",
            }
            path {
                d: "m20.772 19.148.924.383",
            }
            circle {
                cx: "10",
                cy: "8",
                r: "5",
            }
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserRoundMinus;
impl IconShape for LdUserRoundMinus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 21a8 8 0 0 1 13.292-6",
            }
            circle {
                cx: "10",
                cy: "8",
                r: "5",
            }
            path {
                d: "M22 19h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserRoundPen;
impl IconShape for LdUserRoundPen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 21a8 8 0 0 1 10.821-7.487",
            }
            path {
                d: "M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z",
            }
            circle {
                cx: "10",
                cy: "8",
                r: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserRoundPlus;
impl IconShape for LdUserRoundPlus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 21a8 8 0 0 1 13.292-6",
            }
            circle {
                cx: "10",
                cy: "8",
                r: "5",
            }
            path {
                d: "M19 16v6",
            }
            path {
                d: "M22 19h-6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserRoundSearch;
impl IconShape for LdUserRoundSearch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "10",
                cy: "8",
                r: "5",
            }
            path {
                d: "M2 21a8 8 0 0 1 10.434-7.62",
            }
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
            path {
                d: "m22 22-1.9-1.9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserRoundX;
impl IconShape for LdUserRoundX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 21a8 8 0 0 1 11.873-7",
            }
            circle {
                cx: "10",
                cy: "8",
                r: "5",
            }
            path {
                d: "m17 17 5 5",
            }
            path {
                d: "m22 17-5 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserRound;
impl IconShape for LdUserRound {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "8",
                r: "5",
            }
            path {
                d: "M20 21a8 8 0 0 0-16 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserSearch;
impl IconShape for LdUserSearch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "10",
                cy: "7",
                r: "4",
            }
            path {
                d: "M10.3 15H7a4 4 0 0 0-4 4v2",
            }
            circle {
                cx: "17",
                cy: "17",
                r: "3",
            }
            path {
                d: "m21 21-1.9-1.9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserStar;
impl IconShape for LdUserStar {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16.051 12.616a1 1 0 0 1 1.909.024l.737 1.452a1 1 0 0 0 .737.535l1.634.256a1 1 0 0 1 .588 1.806l-1.172 1.168a1 1 0 0 0-.282.866l.259 1.613a1 1 0 0 1-1.541 1.134l-1.465-.75a1 1 0 0 0-.912 0l-1.465.75a1 1 0 0 1-1.539-1.133l.258-1.613a1 1 0 0 0-.282-.866l-1.156-1.153a1 1 0 0 1 .572-1.822l1.633-.256a1 1 0 0 0 .737-.535z",
            }
            path {
                d: "M8 15H7a4 4 0 0 0-4 4v2",
            }
            circle {
                cx: "10",
                cy: "7",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUserX;
impl IconShape for LdUserX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2",
            }
            circle {
                cx: "9",
                cy: "7",
                r: "4",
            }
            line {
                x1: "17",
                x2: "22",
                y1: "8",
                y2: "13",
            }
            line {
                x1: "22",
                x2: "17",
                y1: "8",
                y2: "13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUser;
impl IconShape for LdUser {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 21v-2a4 4 0 0 0-4-4H9a4 4 0 0 0-4 4v2",
            }
            circle {
                cx: "12",
                cy: "7",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUsersRound;
impl IconShape for LdUsersRound {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 21a8 8 0 0 0-16 0",
            }
            circle {
                cx: "10",
                cy: "8",
                r: "5",
            }
            path {
                d: "M22 20c0-3.37-2-6.5-4-8a5 5 0 0 0-.45-8.3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUsers;
impl IconShape for LdUsers {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2",
            }
            path {
                d: "M16 3.128a4 4 0 0 1 0 7.744",
            }
            path {
                d: "M22 21v-2a4 4 0 0 0-3-3.87",
            }
            circle {
                cx: "9",
                cy: "7",
                r: "4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUtensilsCrossed;
impl IconShape for LdUtensilsCrossed {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 2-2.3 2.3a3 3 0 0 0 0 4.2l1.8 1.8a3 3 0 0 0 4.2 0L22 8",
            }
            path {
                d: "M15 15 3.3 3.3a4.2 4.2 0 0 0 0 6l7.3 7.3c.7.7 2 .7 2.8 0L15 15Zm0 0 7 7",
            }
            path {
                d: "m2.1 21.8 6.4-6.3",
            }
            path {
                d: "m19 5-7 7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUtensils;
impl IconShape for LdUtensils {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 2v7c0 1.1.9 2 2 2h4a2 2 0 0 0 2-2V2",
            }
            path {
                d: "M7 2v20",
            }
            path {
                d: "M21 15V2a5 5 0 0 0-5 5v6c0 1.1.9 2 2 2h3Zm0 0v7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdUtilityPole;
impl IconShape for LdUtilityPole {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v20",
            }
            path {
                d: "M2 5h20",
            }
            path {
                d: "M3 3v2",
            }
            path {
                d: "M7 3v2",
            }
            path {
                d: "M17 3v2",
            }
            path {
                d: "M21 3v2",
            }
            path {
                d: "m19 5-7 7-7-7",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVariable;
impl IconShape for LdVariable {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 21s-4-3-4-9 4-9 4-9",
            }
            path {
                d: "M16 3s4 3 4 9-4 9-4 9",
            }
            line {
                x1: "15",
                x2: "9",
                y1: "9",
                y2: "15",
            }
            line {
                x1: "9",
                x2: "15",
                y1: "9",
                y2: "15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVault;
impl IconShape for LdVault {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            circle {
                cx: "7.5",
                cy: "7.5",
                r: ".5",
            }
            path {
                d: "m7.9 7.9 2.7 2.7",
            }
            circle {
                cx: "16.5",
                cy: "7.5",
                r: ".5",
            }
            path {
                d: "m13.4 10.6 2.7-2.7",
            }
            circle {
                cx: "7.5",
                cy: "16.5",
                r: ".5",
            }
            path {
                d: "m7.9 16.1 2.7-2.7",
            }
            circle {
                cx: "16.5",
                cy: "16.5",
                r: ".5",
            }
            path {
                d: "m13.4 13.4 2.7 2.7",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVectorSquare;
impl IconShape for LdVectorSquare {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19.5 7a24 24 0 0 1 0 10",
            }
            path {
                d: "M4.5 7a24 24 0 0 0 0 10",
            }
            path {
                d: "M7 19.5a24 24 0 0 0 10 0",
            }
            path {
                d: "M7 4.5a24 24 0 0 1 10 0",
            }
            rect {
                height: "5",
                rx: "1",
                width: "5",
                x: "17",
                y: "17",
            }
            rect {
                height: "5",
                rx: "1",
                width: "5",
                x: "17",
                y: "2",
            }
            rect {
                height: "5",
                rx: "1",
                width: "5",
                x: "2",
                y: "17",
            }
            rect {
                height: "5",
                rx: "1",
                width: "5",
                x: "2",
                y: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVegan;
impl IconShape for LdVegan {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 8q6 0 6-6-6 0-6 6",
            }
            path {
                d: "M17.41 3.59a10 10 0 1 0 3 3",
            }
            path {
                d: "M2 2a26.6 26.6 0 0 1 10 20c.9-6.82 1.5-9.5 4-14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVenetianMask;
impl IconShape for LdVenetianMask {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 11c-1.5 0-2.5.5-3 2",
            }
            path {
                d: "M4 6a2 2 0 0 0-2 2v4a5 5 0 0 0 5 5 8 8 0 0 1 5 2 8 8 0 0 1 5-2 5 5 0 0 0 5-5V8a2 2 0 0 0-2-2h-3a8 8 0 0 0-5 2 8 8 0 0 0-5-2z",
            }
            path {
                d: "M6 11c1.5 0 2.5.5 3 2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVenusAndMars;
impl IconShape for LdVenusAndMars {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 20h4",
            }
            path {
                d: "M12 16v6",
            }
            path {
                d: "M17 2h4v4",
            }
            path {
                d: "m21 2-5.46 5.46",
            }
            circle {
                cx: "12",
                cy: "11",
                r: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVenus;
impl IconShape for LdVenus {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 15v7",
            }
            path {
                d: "M9 19h6",
            }
            circle {
                cx: "12",
                cy: "9",
                r: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVibrateOff;
impl IconShape for LdVibrateOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 8 2 2-2 2 2 2-2 2",
            }
            path {
                d: "m22 8-2 2 2 2-2 2 2 2",
            }
            path {
                d: "M8 8v10c0 .55.45 1 1 1h6c.55 0 1-.45 1-1v-2",
            }
            path {
                d: "M16 10.34V6c0-.55-.45-1-1-1h-4.34",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVibrate;
impl IconShape for LdVibrate {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 8 2 2-2 2 2 2-2 2",
            }
            path {
                d: "m22 8-2 2 2 2-2 2 2 2",
            }
            rect {
                height: "14",
                rx: "1",
                width: "8",
                x: "8",
                y: "5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVideoOff;
impl IconShape for LdVideoOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.66 6H14a2 2 0 0 1 2 2v2.5l5.248-3.062A.5.5 0 0 1 22 7.87v8.196",
            }
            path {
                d: "M16 16a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h2",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVideo;
impl IconShape for LdVideo {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m16 13 5.223 3.482a.5.5 0 0 0 .777-.416V7.87a.5.5 0 0 0-.752-.432L16 10.5",
            }
            rect {
                height: "12",
                rx: "2",
                width: "14",
                x: "2",
                y: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVideotape;
impl IconShape for LdVideotape {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "16",
                rx: "2",
                width: "20",
                x: "2",
                y: "4",
            }
            path {
                d: "M2 8h20",
            }
            circle {
                cx: "8",
                cy: "14",
                r: "2",
            }
            path {
                d: "M8 12h8",
            }
            circle {
                cx: "16",
                cy: "14",
                r: "2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdView;
impl IconShape for LdView {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M21 17v2a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-2",
            }
            path {
                d: "M21 7V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "1",
            }
            path {
                d: "M18.944 12.33a1 1 0 0 0 0-.66 7.5 7.5 0 0 0-13.888 0 1 1 0 0 0 0 .66 7.5 7.5 0 0 0 13.888 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVoicemail;
impl IconShape for LdVoicemail {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "6",
                cy: "12",
                r: "4",
            }
            circle {
                cx: "18",
                cy: "12",
                r: "4",
            }
            line {
                x1: "6",
                x2: "18",
                y1: "16",
                y2: "16",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVolleyball;
impl IconShape for LdVolleyball {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.1 7.1a16.55 16.55 0 0 1 10.9 4",
            }
            path {
                d: "M12 12a12.6 12.6 0 0 1-8.7 5",
            }
            path {
                d: "M16.8 13.6a16.55 16.55 0 0 1-9 7.5",
            }
            path {
                d: "M20.7 17a12.8 12.8 0 0 0-8.7-5 13.3 13.3 0 0 1 0-10",
            }
            path {
                d: "M6.3 3.8a16.55 16.55 0 0 0 1.9 11.5",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "10",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVolume1;
impl IconShape for LdVolume1 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z",
            }
            path {
                d: "M16 9a5 5 0 0 1 0 6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVolume2;
impl IconShape for LdVolume2 {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z",
            }
            path {
                d: "M16 9a5 5 0 0 1 0 6",
            }
            path {
                d: "M19.364 18.364a9 9 0 0 0 0-12.728",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVolumeOff;
impl IconShape for LdVolumeOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M16 9a5 5 0 0 1 .95 2.293",
            }
            path {
                d: "M19.364 5.636a9 9 0 0 1 1.889 9.96",
            }
            path {
                d: "m2 2 20 20",
            }
            path {
                d: "m7 7-.587.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298V11",
            }
            path {
                d: "M9.828 4.172A.686.686 0 0 1 11 4.657v.686",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVolumeX;
impl IconShape for LdVolumeX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z",
            }
            line {
                x1: "22",
                x2: "16",
                y1: "9",
                y2: "15",
            }
            line {
                x1: "16",
                x2: "22",
                y1: "9",
                y2: "15",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVolume;
impl IconShape for LdVolume {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdVote;
impl IconShape for LdVote {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m9 12 2 2 4-4",
            }
            path {
                d: "M5 7c0-1.1.9-2 2-2h10a2 2 0 0 1 2 2v12H5V7Z",
            }
            path {
                d: "M22 19H2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWalletCards;
impl IconShape for LdWalletCards {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "18",
                rx: "2",
                width: "18",
                x: "3",
                y: "3",
            }
            path {
                d: "M3 9a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2",
            }
            path {
                d: "M3 11h3c.8 0 1.6.3 2.1.9l1.1.9c1.6 1.6 4.1 1.6 5.7 0l1.1-.9c.5-.5 1.3-.9 2.1-.9H21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWalletMinimal;
impl IconShape for LdWalletMinimal {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 14h.01",
            }
            path {
                d: "M7 7h12a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWallet;
impl IconShape for LdWallet {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 7V4a1 1 0 0 0-1-1H5a2 2 0 0 0 0 4h15a1 1 0 0 1 1 1v4h-3a2 2 0 0 0 0 4h3a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1",
            }
            path {
                d: "M3 5v14a2 2 0 0 0 2 2h15a1 1 0 0 0 1-1v-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWallpaper;
impl IconShape for LdWallpaper {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 17v4",
            }
            path {
                d: "M8 21h8",
            }
            path {
                d: "m9 17 6.1-6.1a2 2 0 0 1 2.81.01L22 15",
            }
            circle {
                cx: "8",
                cy: "9",
                r: "2",
            }
            rect {
                height: "14",
                rx: "2",
                width: "20",
                x: "2",
                y: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWandSparkles;
impl IconShape for LdWandSparkles {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m21.64 3.64-1.28-1.28a1.21 1.21 0 0 0-1.72 0L2.36 18.64a1.21 1.21 0 0 0 0 1.72l1.28 1.28a1.2 1.2 0 0 0 1.72 0L21.64 5.36a1.2 1.2 0 0 0 0-1.72",
            }
            path {
                d: "m14 7 3 3",
            }
            path {
                d: "M5 6v4",
            }
            path {
                d: "M19 14v4",
            }
            path {
                d: "M10 2v2",
            }
            path {
                d: "M7 8H3",
            }
            path {
                d: "M21 16h-4",
            }
            path {
                d: "M11 3H9",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWand;
impl IconShape for LdWand {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M15 4V2",
            }
            path {
                d: "M15 16v-2",
            }
            path {
                d: "M8 9h2",
            }
            path {
                d: "M20 9h2",
            }
            path {
                d: "M17.8 11.8 19 13",
            }
            path {
                d: "M15 9h.01",
            }
            path {
                d: "M17.8 6.2 19 5",
            }
            path {
                d: "m3 21 9-9",
            }
            path {
                d: "M12.2 6.2 11 5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWarehouse;
impl IconShape for LdWarehouse {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 21V10a1 1 0 0 0-1-1H7a1 1 0 0 0-1 1v11",
            }
            path {
                d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8a2 2 0 0 1 1.132-1.803l7.95-3.974a2 2 0 0 1 1.837 0l7.948 3.974A2 2 0 0 1 22 8z",
            }
            path {
                d: "M6 13h12",
            }
            path {
                d: "M6 17h12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWashingMachine;
impl IconShape for LdWashingMachine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M3 6h3",
            }
            path {
                d: "M17 6h.01",
            }
            rect {
                height: "20",
                rx: "2",
                width: "18",
                x: "3",
                y: "2",
            }
            circle {
                cx: "12",
                cy: "13",
                r: "5",
            }
            path {
                d: "M12 18a2.5 2.5 0 0 0 0-5 2.5 2.5 0 0 1 0-5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWatch;
impl IconShape for LdWatch {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 10v2.2l1.6 1",
            }
            path {
                d: "m16.13 7.66-.81-4.05a2 2 0 0 0-2-1.61h-2.68a2 2 0 0 0-2 1.61l-.78 4.05",
            }
            path {
                d: "m7.88 16.36.8 4a2 2 0 0 0 2 1.61h2.72a2 2 0 0 0 2-1.61l.81-4.05",
            }
            circle {
                cx: "12",
                cy: "12",
                r: "6",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWavesArrowDown;
impl IconShape for LdWavesArrowDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 10L12 2",
            }
            path {
                d: "M16 6L12 10L8 6",
            }
            path {
                d: "M2 15C2.6 15.5 3.2 16 4.5 16C7 16 7 14 9.5 14C12.1 14 11.9 16 14.5 16C17 16 17 14 19.5 14C20.8 14 21.4 14.5 22 15",
            }
            path {
                d: "M2 21C2.6 21.5 3.2 22 4.5 22C7 22 7 20 9.5 20C12.1 20 11.9 22 14.5 22C17 22 17 20 19.5 20C20.8 20 21.4 20.5 22 21",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWavesArrowUp;
impl IconShape for LdWavesArrowUp {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 2v8",
            }
            path {
                d: "M2 15c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1",
            }
            path {
                d: "M2 21c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1",
            }
            path {
                d: "m8 6 4-4 4 4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWavesLadder;
impl IconShape for LdWavesLadder {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M19 5a2 2 0 0 0-2 2v11",
            }
            path {
                d: "M2 18c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1",
            }
            path {
                d: "M7 13h10",
            }
            path {
                d: "M7 9h10",
            }
            path {
                d: "M9 5a2 2 0 0 0-2 2v11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWaves;
impl IconShape for LdWaves {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 6c.6.5 1.2 1 2.5 1C7 7 7 5 9.5 5c2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1",
            }
            path {
                d: "M2 12c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1",
            }
            path {
                d: "M2 18c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWaypoints;
impl IconShape for LdWaypoints {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "4.5",
                r: "2.5",
            }
            path {
                d: "m10.2 6.3-3.9 3.9",
            }
            circle {
                cx: "4.5",
                cy: "12",
                r: "2.5",
            }
            path {
                d: "M7 12h10",
            }
            circle {
                cx: "19.5",
                cy: "12",
                r: "2.5",
            }
            path {
                d: "m13.8 17.7 3.9-3.9",
            }
            circle {
                cx: "12",
                cy: "19.5",
                r: "2.5",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWebcam;
impl IconShape for LdWebcam {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "10",
                r: "8",
            }
            circle {
                cx: "12",
                cy: "10",
                r: "3",
            }
            path {
                d: "M7 22h10",
            }
            path {
                d: "M12 22v-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWebhookOff;
impl IconShape for LdWebhookOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M17 17h-5c-1.09-.02-1.94.92-2.5 1.9A3 3 0 1 1 2.57 15",
            }
            path {
                d: "M9 3.4a4 4 0 0 1 6.52.66",
            }
            path {
                d: "m6 17 3.1-5.8a2.5 2.5 0 0 0 .057-2.05",
            }
            path {
                d: "M20.3 20.3a4 4 0 0 1-2.3.7",
            }
            path {
                d: "M18.6 13a4 4 0 0 1 3.357 3.414",
            }
            path {
                d: "m12 6 .6 1",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWebhook;
impl IconShape for LdWebhook {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 16.98h-5.99c-1.1 0-1.95.94-2.48 1.9A4 4 0 0 1 2 17c.01-.7.2-1.4.57-2",
            }
            path {
                d: "m6 17 3.13-5.78c.53-.97.1-2.18-.5-3.1a4 4 0 1 1 6.89-4.06",
            }
            path {
                d: "m12 6 3.13 5.73C15.66 12.7 16.9 13 18 13a4 4 0 0 1 0 8",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWeight;
impl IconShape for LdWeight {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "12",
                cy: "5",
                r: "3",
            }
            path {
                d: "M6.5 8a2 2 0 0 0-1.905 1.46L2.1 18.5A2 2 0 0 0 4 21h16a2 2 0 0 0 1.925-2.54L19.4 9.5A2 2 0 0 0 17.48 8Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWheatOff;
impl IconShape for LdWheatOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m2 22 10-10",
            }
            path {
                d: "m16 8-1.17 1.17",
            }
            path {
                d: "M3.47 12.53 5 11l1.53 1.53a3.5 3.5 0 0 1 0 4.94L5 19l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z",
            }
            path {
                d: "m8 8-.53.53a3.5 3.5 0 0 0 0 4.94L9 15l1.53-1.53c.55-.55.88-1.25.98-1.97",
            }
            path {
                d: "M10.91 5.26c.15-.26.34-.51.56-.73L13 3l1.53 1.53a3.5 3.5 0 0 1 .28 4.62",
            }
            path {
                d: "M20 2h2v2a4 4 0 0 1-4 4h-2V6a4 4 0 0 1 4-4Z",
            }
            path {
                d: "M11.47 17.47 13 19l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L5 19l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z",
            }
            path {
                d: "m16 16-.53.53a3.5 3.5 0 0 1-4.94 0L9 15l1.53-1.53a3.49 3.49 0 0 1 1.97-.98",
            }
            path {
                d: "M18.74 13.09c.26-.15.51-.34.73-.56L21 11l-1.53-1.53a3.5 3.5 0 0 0-4.62-.28",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWheat;
impl IconShape for LdWheat {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 22 16 8",
            }
            path {
                d: "M3.47 12.53 5 11l1.53 1.53a3.5 3.5 0 0 1 0 4.94L5 19l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z",
            }
            path {
                d: "M7.47 8.53 9 7l1.53 1.53a3.5 3.5 0 0 1 0 4.94L9 15l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z",
            }
            path {
                d: "M11.47 4.53 13 3l1.53 1.53a3.5 3.5 0 0 1 0 4.94L13 11l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z",
            }
            path {
                d: "M20 2h2v2a4 4 0 0 1-4 4h-2V6a4 4 0 0 1 4-4Z",
            }
            path {
                d: "M11.47 17.47 13 19l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L5 19l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z",
            }
            path {
                d: "M15.47 13.47 17 15l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L9 15l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z",
            }
            path {
                d: "M19.47 9.47 21 11l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L13 11l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWholeWord;
impl IconShape for LdWholeWord {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "7",
                cy: "12",
                r: "3",
            }
            path {
                d: "M10 9v6",
            }
            circle {
                cx: "17",
                cy: "12",
                r: "3",
            }
            path {
                d: "M14 7v8",
            }
            path {
                d: "M22 17v1c0 .5-.5 1-1 1H3c-.5 0-1-.5-1-1v-1",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWifiCog;
impl IconShape for LdWifiCog {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m14.305 19.53.923-.382",
            }
            path {
                d: "m15.228 16.852-.923-.383",
            }
            path {
                d: "m16.852 15.228-.383-.923",
            }
            path {
                d: "m16.852 20.772-.383.924",
            }
            path {
                d: "m19.148 15.228.383-.923",
            }
            path {
                d: "m19.53 21.696-.382-.924",
            }
            path {
                d: "M2 7.82a15 15 0 0 1 20 0",
            }
            path {
                d: "m20.772 16.852.924-.383",
            }
            path {
                d: "m20.772 19.148.924.383",
            }
            path {
                d: "M5 11.858a10 10 0 0 1 11.5-1.785",
            }
            path {
                d: "M8.5 15.429a5 5 0 0 1 2.413-1.31",
            }
            circle {
                cx: "18",
                cy: "18",
                r: "3",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWifiHigh;
impl IconShape for LdWifiHigh {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 20h.01",
            }
            path {
                d: "M5 12.859a10 10 0 0 1 14 0",
            }
            path {
                d: "M8.5 16.429a5 5 0 0 1 7 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWifiLow;
impl IconShape for LdWifiLow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 20h.01",
            }
            path {
                d: "M8.5 16.429a5 5 0 0 1 7 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWifiOff;
impl IconShape for LdWifiOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 20h.01",
            }
            path {
                d: "M8.5 16.429a5 5 0 0 1 7 0",
            }
            path {
                d: "M5 12.859a10 10 0 0 1 5.17-2.69",
            }
            path {
                d: "M19 12.859a10 10 0 0 0-2.007-1.523",
            }
            path {
                d: "M2 8.82a15 15 0 0 1 4.177-2.643",
            }
            path {
                d: "M22 8.82a15 15 0 0 0-11.288-3.764",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWifiPen;
impl IconShape for LdWifiPen {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2 8.82a15 15 0 0 1 20 0",
            }
            path {
                d: "M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z",
            }
            path {
                d: "M5 12.859a10 10 0 0 1 10.5-2.222",
            }
            path {
                d: "M8.5 16.429a5 5 0 0 1 3-1.406",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWifiSync;
impl IconShape for LdWifiSync {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M11.965 10.105v4L13.5 12.5a5 5 0 0 1 8 1.5",
            }
            path {
                d: "M11.965 14.105h4",
            }
            path {
                d: "M17.965 18.105h4L20.43 19.71a5 5 0 0 1-8-1.5",
            }
            path {
                d: "M2 8.82a15 15 0 0 1 20 0",
            }
            path {
                d: "M21.965 22.105v-4",
            }
            path {
                d: "M5 12.86a10 10 0 0 1 3-2.032",
            }
            path {
                d: "M8.5 16.429h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWifiZero;
impl IconShape for LdWifiZero {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 20h.01",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWifi;
impl IconShape for LdWifi {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12 20h.01",
            }
            path {
                d: "M2 8.82a15 15 0 0 1 20 0",
            }
            path {
                d: "M5 12.859a10 10 0 0 1 14 0",
            }
            path {
                d: "M8.5 16.429a5 5 0 0 1 7 0",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWindArrowDown;
impl IconShape for LdWindArrowDown {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10 2v8",
            }
            path {
                d: "M12.8 21.6A2 2 0 1 0 14 18H2",
            }
            path {
                d: "M17.5 10a2.5 2.5 0 1 1 2 4H2",
            }
            path {
                d: "m6 6 4 4 4-4",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWind;
impl IconShape for LdWind {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M12.8 19.6A2 2 0 1 0 14 16H2",
            }
            path {
                d: "M17.5 8a2.5 2.5 0 1 1 2 4H2",
            }
            path {
                d: "M9.8 4.4A2 2 0 1 1 11 8H2",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWineOff;
impl IconShape for LdWineOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 22h8",
            }
            path {
                d: "M7 10h3m7 0h-1.343",
            }
            path {
                d: "M12 15v7",
            }
            path {
                d: "M7.307 7.307A12.33 12.33 0 0 0 7 10a5 5 0 0 0 7.391 4.391M8.638 2.981C8.75 2.668 8.872 2.34 9 2h6c1.5 4 2 6 2 8 0 .407-.05.809-.145 1.198",
            }
            line {
                x1: "2",
                x2: "22",
                y1: "2",
                y2: "22",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWine;
impl IconShape for LdWine {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M8 22h8",
            }
            path {
                d: "M7 10h10",
            }
            path {
                d: "M12 15v7",
            }
            path {
                d: "M12 15a5 5 0 0 0 5-5c0-2-.5-4-2-8H9c-1.5 4-2 6-2 8a5 5 0 0 0 5 5Z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWorkflow;
impl IconShape for LdWorkflow {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            rect {
                height: "8",
                rx: "2",
                width: "8",
                x: "3",
                y: "3",
            }
            path {
                d: "M7 11v4a2 2 0 0 0 2 2h4",
            }
            rect {
                height: "8",
                rx: "2",
                width: "8",
                x: "13",
                y: "13",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWorm;
impl IconShape for LdWorm {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "m19 12-1.5 3",
            }
            path {
                d: "M19.63 18.81 22 20",
            }
            path {
                d: "M6.47 8.23a1.68 1.68 0 0 1 2.44 1.93l-.64 2.08a6.76 6.76 0 0 0 10.16 7.67l.42-.27a1 1 0 1 0-2.73-4.21l-.42.27a1.76 1.76 0 0 1-2.63-1.99l.64-2.08A6.66 6.66 0 0 0 3.94 3.9l-.7.4a1 1 0 1 0 2.55 4.34z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdWrench;
impl IconShape for LdWrench {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.106-3.105c.32-.322.863-.22.983.218a6 6 0 0 1-8.259 7.057l-7.91 7.91a1 1 0 0 1-2.999-3l7.91-7.91a6 6 0 0 1 7.057-8.259c.438.12.54.662.219.984z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdX;
impl IconShape for LdX {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M18 6 6 18",
            }
            path {
                d: "m6 6 12 12",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdYoutube;
impl IconShape for LdYoutube {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M2.5 17a24.12 24.12 0 0 1 0-10 2 2 0 0 1 1.4-1.4 49.56 49.56 0 0 1 16.2 0A2 2 0 0 1 21.5 7a24.12 24.12 0 0 1 0 10 2 2 0 0 1-1.4 1.4 49.55 49.55 0 0 1-16.2 0A2 2 0 0 1 2.5 17",
            }
            path {
                d: "m10 15 5-3-5-3z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdZapOff;
impl IconShape for LdZapOff {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M10.513 4.856 13.12 2.17a.5.5 0 0 1 .86.46l-1.377 4.317",
            }
            path {
                d: "M15.656 10H20a1 1 0 0 1 .78 1.63l-1.72 1.773",
            }
            path {
                d: "M16.273 16.273 10.88 21.83a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14H4a1 1 0 0 1-.78-1.63l4.507-4.643",
            }
            path {
                d: "m2 2 20 20",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdZap;
impl IconShape for LdZap {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            path {
                d: "M4 14a1 1 0 0 1-.78-1.63l9.9-10.2a.5.5 0 0 1 .86.46l-1.92 6.02A1 1 0 0 0 13 10h7a1 1 0 0 1 .78 1.63l-9.9 10.2a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14z",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdZoomIn;
impl IconShape for LdZoomIn {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "11",
                cy: "11",
                r: "8",
            }
            line {
                x1: "21",
                x2: "16.65",
                y1: "21",
                y2: "16.65",
            }
            line {
                x1: "11",
                x2: "11",
                y1: "8",
                y2: "14",
            }
            line {
                x1: "8",
                x2: "14",
                y1: "11",
                y2: "11",
            }
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct LdZoomOut;
impl IconShape for LdZoomOut {
    fn view_box(&self) -> &str {
        "0 0 24 24"
    }
    fn xmlns(&self) -> &str {
        "http://www.w3.org/2000/svg"
    }
    fn fill_and_stroke<'a>(&self, user_color: &'a str) -> (&'a str, &'a str, &'a str) {
        ("none", user_color, "2")
    }
    fn stroke_linecap(&self) -> &str {
        "round"
    }
    fn stroke_linejoin(&self) -> &str {
        "round"
    }
    fn child_elements(&self) -> Element {
        rsx! {
            circle {
                cx: "11",
                cy: "11",
                r: "8",
            }
            line {
                x1: "21",
                x2: "16.65",
                y1: "21",
                y2: "16.65",
            }
            line {
                x1: "8",
                x2: "14",
                y1: "11",
                y2: "11",
            }
        }
    }
}
