dioxus-icons-feather 0.2.1

// Auto Generated! DO NOT EDIT!

use dioxus::prelude::*;
pub use dioxus_icon_component::{Icon, IconProps, IconShape};


#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Activity;

impl IconShape for Activity {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "22 12 18 12 15 21 9 3 6 12 2 12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Airplay;

impl IconShape for Airplay {
    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",
            }
polygon {
        points: "12 15 17 21 7 21 12 15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct AlertCircle;

impl IconShape for AlertCircle {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct AlertOctagon;

impl IconShape for AlertOctagon {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2",
            }
line {
        x1: "12",
        x2: "12",
        y1: "8",
        y2: "12",
            }
line {
        x1: "12",
        x2: "12.01",
        y1: "16",
        y2: "16",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct AlertTriangle;

impl IconShape for AlertTriangle {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z",
            }
line {
        x1: "12",
        x2: "12",
        y1: "9",
        y2: "13",
            }
line {
        x1: "12",
        x2: "12.01",
        y1: "17",
        y2: "17",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct AlignCenter;

impl IconShape for AlignCenter {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "18",
        x2: "6",
        y1: "10",
        y2: "10",
            }
line {
        x1: "21",
        x2: "3",
        y1: "6",
        y2: "6",
            }
line {
        x1: "21",
        x2: "3",
        y1: "14",
        y2: "14",
            }
line {
        x1: "18",
        x2: "6",
        y1: "18",
        y2: "18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct AlignJustify;

impl IconShape for AlignJustify {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "21",
        x2: "3",
        y1: "10",
        y2: "10",
            }
line {
        x1: "21",
        x2: "3",
        y1: "6",
        y2: "6",
            }
line {
        x1: "21",
        x2: "3",
        y1: "14",
        y2: "14",
            }
line {
        x1: "21",
        x2: "3",
        y1: "18",
        y2: "18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct AlignLeft;

impl IconShape for AlignLeft {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "17",
        x2: "3",
        y1: "10",
        y2: "10",
            }
line {
        x1: "21",
        x2: "3",
        y1: "6",
        y2: "6",
            }
line {
        x1: "21",
        x2: "3",
        y1: "14",
        y2: "14",
            }
line {
        x1: "17",
        x2: "3",
        y1: "18",
        y2: "18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct AlignRight;

impl IconShape for AlignRight {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "21",
        x2: "7",
        y1: "10",
        y2: "10",
            }
line {
        x1: "21",
        x2: "3",
        y1: "6",
        y2: "6",
            }
line {
        x1: "21",
        x2: "3",
        y1: "14",
        y2: "14",
            }
line {
        x1: "21",
        x2: "7",
        y1: "18",
        y2: "18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Anchor;

impl IconShape for Anchor {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "5",
        r: "3",
            }
line {
        x1: "12",
        x2: "12",
        y1: "22",
        y2: "8",
            }
path {
        d: "M5 12H2a10 10 0 0 0 20 0h-3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Aperture;

impl IconShape for Aperture {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
line {
        x1: "14.31",
        x2: "20.05",
        y1: "8",
        y2: "17.94",
            }
line {
        x1: "9.69",
        x2: "21.17",
        y1: "8",
        y2: "8",
            }
line {
        x1: "7.38",
        x2: "13.12",
        y1: "12",
        y2: "2.06",
            }
line {
        x1: "9.69",
        x2: "3.95",
        y1: "16",
        y2: "6.06",
            }
line {
        x1: "14.31",
        x2: "2.83",
        y1: "16",
        y2: "16",
            }
line {
        x1: "16.62",
        x2: "10.88",
        y1: "12",
        y2: "21.94",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Archive;

impl IconShape for Archive {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "21 8 21 21 3 21 3 8",
            }
rect {
        height: "5",
        width: "22",
        x: "1",
        y: "3",
            }
line {
        x1: "10",
        x2: "14",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowDown;

impl IconShape for ArrowDown {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "12",
        x2: "12",
        y1: "5",
        y2: "19",
            }
polyline {
        points: "19 12 12 19 5 12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowDownCircle;

impl IconShape for ArrowDownCircle {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
polyline {
        points: "8 12 12 16 16 12",
            }
line {
        x1: "12",
        x2: "12",
        y1: "8",
        y2: "16",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowDownLeft;

impl IconShape for ArrowDownLeft {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "17",
        x2: "7",
        y1: "7",
        y2: "17",
            }
polyline {
        points: "17 17 7 17 7 7",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowDownRight;

impl IconShape for ArrowDownRight {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "7",
        x2: "17",
        y1: "7",
        y2: "17",
            }
polyline {
        points: "17 7 17 17 7 17",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowLeft;

impl IconShape for ArrowLeft {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "19",
        x2: "5",
        y1: "12",
        y2: "12",
            }
polyline {
        points: "12 19 5 12 12 5",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowLeftCircle;

impl IconShape for ArrowLeftCircle {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
polyline {
        points: "12 8 8 12 12 16",
            }
line {
        x1: "16",
        x2: "8",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowRight;

impl IconShape for ArrowRight {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "5",
        x2: "19",
        y1: "12",
        y2: "12",
            }
polyline {
        points: "12 5 19 12 12 19",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowRightCircle;

impl IconShape for ArrowRightCircle {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
polyline {
        points: "12 16 16 12 12 8",
            }
line {
        x1: "8",
        x2: "16",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowUp;

impl IconShape for ArrowUp {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "12",
        x2: "12",
        y1: "19",
        y2: "5",
            }
polyline {
        points: "5 12 12 5 19 12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowUpCircle;

impl IconShape for ArrowUpCircle {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
polyline {
        points: "16 12 12 8 8 12",
            }
line {
        x1: "12",
        x2: "12",
        y1: "16",
        y2: "8",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowUpLeft;

impl IconShape for ArrowUpLeft {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "17",
        x2: "7",
        y1: "17",
        y2: "7",
            }
polyline {
        points: "7 17 7 7 17 7",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ArrowUpRight;

impl IconShape for ArrowUpRight {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "7",
        x2: "17",
        y1: "17",
        y2: "7",
            }
polyline {
        points: "7 7 17 7 17 17",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct AtSign;

impl IconShape for AtSign {
    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-3.92 7.94",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Award;

impl IconShape for Award {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "8",
        r: "7",
            }
polyline {
        points: "8.21 13.89 7 23 12 20 17 23 15.79 13.88",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct BarChart;

impl IconShape for BarChart {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "12",
        x2: "12",
        y1: "20",
        y2: "10",
            }
line {
        x1: "18",
        x2: "18",
        y1: "20",
        y2: "4",
            }
line {
        x1: "6",
        x2: "6",
        y1: "20",
        y2: "16",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct BarChart2;

impl IconShape for BarChart2 {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "18",
        x2: "18",
        y1: "20",
        y2: "10",
            }
line {
        x1: "12",
        x2: "12",
        y1: "20",
        y2: "4",
            }
line {
        x1: "6",
        x2: "6",
        y1: "20",
        y2: "14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Battery;

impl IconShape for Battery {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "12",
        rx: "2",
        ry: "2",
        width: "18",
        x: "1",
        y: "6",
            }
line {
        x1: "23",
        x2: "23",
        y1: "13",
        y2: "11",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct BatteryCharging;

impl IconShape for BatteryCharging {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M5 18H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3.19M15 6h2a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-3.19",
            }
line {
        x1: "23",
        x2: "23",
        y1: "13",
        y2: "11",
            }
polyline {
        points: "11 6 7 12 13 12 9 18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Bell;

impl IconShape for Bell {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9",
            }
path {
        d: "M13.73 21a2 2 0 0 1-3.46 0",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct BellOff;

impl IconShape for BellOff {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M13.73 21a2 2 0 0 1-3.46 0",
            }
path {
        d: "M18.63 13A17.89 17.89 0 0 1 18 8",
            }
path {
        d: "M6.26 6.26A5.86 5.86 0 0 0 6 8c0 7-3 9-3 9h14",
            }
path {
        d: "M18 8a6 6 0 0 0-9.33-5",
            }
line {
        x1: "1",
        x2: "23",
        y1: "1",
        y2: "23",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Bluetooth;

impl IconShape for Bluetooth {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "6.5 6.5 17.5 17.5 12 23 12 1 17.5 6.5 6.5 17.5",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Bold;

impl IconShape for Bold {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M6 4h8a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z",
            }
path {
        d: "M6 12h9a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Book;

impl IconShape for Book {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M4 19.5A2.5 2.5 0 0 1 6.5 17H20",
            }
path {
        d: "M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct BookOpen;

impl IconShape for BookOpen {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z",
            }
path {
        d: "M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Bookmark;

impl IconShape for Bookmark {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Briefcase;

impl IconShape for Briefcase {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "14",
        rx: "2",
        ry: "2",
        width: "20",
        x: "2",
        y: "7",
            }
path {
        d: "M16 21V5a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Calendar;

impl IconShape for Calendar {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "18",
        rx: "2",
        ry: "2",
        width: "18",
        x: "3",
        y: "4",
            }
line {
        x1: "16",
        x2: "16",
        y1: "2",
        y2: "6",
            }
line {
        x1: "8",
        x2: "8",
        y1: "2",
        y2: "6",
            }
line {
        x1: "3",
        x2: "21",
        y1: "10",
        y2: "10",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Camera;

impl IconShape for Camera {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M23 19a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h4l2-3h6l2 3h4a2 2 0 0 1 2 2z",
            }
circle {
        cx: "12",
        cy: "13",
        r: "4",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CameraOff;

impl IconShape for CameraOff {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "1",
        x2: "23",
        y1: "1",
        y2: "23",
            }
path {
        d: "M21 21H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3m3-3h6l2 3h4a2 2 0 0 1 2 2v9.34m-7.72-2.06a4 4 0 1 1-5.56-5.56",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Cast;

impl IconShape for Cast {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M2 16.1A5 5 0 0 1 5.9 20M2 12.05A9 9 0 0 1 9.95 20M2 8V6a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-6",
            }
line {
        x1: "2",
        x2: "2.01",
        y1: "20",
        y2: "20",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Check;

impl IconShape for Check {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "20 6 9 17 4 12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CheckCircle;

impl IconShape for CheckCircle {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M22 11.08V12a10 10 0 1 1-5.93-9.14",
            }
polyline {
        points: "22 4 12 14.01 9 11.01",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CheckSquare;

impl IconShape for CheckSquare {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "9 11 12 14 22 4",
            }
path {
        d: "M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ChevronDown;

impl IconShape for ChevronDown {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "6 9 12 15 18 9",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ChevronLeft;

impl IconShape for ChevronLeft {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "15 18 9 12 15 6",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ChevronRight;

impl IconShape for ChevronRight {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "9 18 15 12 9 6",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ChevronUp;

impl IconShape for ChevronUp {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "18 15 12 9 6 15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ChevronsDown;

impl IconShape for ChevronsDown {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "7 13 12 18 17 13",
            }
polyline {
        points: "7 6 12 11 17 6",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ChevronsLeft;

impl IconShape for ChevronsLeft {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "11 17 6 12 11 7",
            }
polyline {
        points: "18 17 13 12 18 7",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ChevronsRight;

impl IconShape for ChevronsRight {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "13 17 18 12 13 7",
            }
polyline {
        points: "6 17 11 12 6 7",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ChevronsUp;

impl IconShape for ChevronsUp {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "17 11 12 6 7 11",
            }
polyline {
        points: "17 18 12 13 7 18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Chrome;

impl IconShape for Chrome {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
circle {
        cx: "12",
        cy: "12",
        r: "4",
            }
line {
        x1: "21.17",
        x2: "12",
        y1: "8",
        y2: "8",
            }
line {
        x1: "3.95",
        x2: "8.54",
        y1: "6.06",
        y2: "14",
            }
line {
        x1: "10.88",
        x2: "15.46",
        y1: "21.94",
        y2: "14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Circle;

impl IconShape for Circle {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Clipboard;

impl IconShape for Clipboard {
    fn child_elements(&self) -> Element {
        rsx!(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",
            }
rect {
        height: "4",
        rx: "1",
        ry: "1",
        width: "8",
        x: "8",
        y: "2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Clock;

impl IconShape for Clock {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
polyline {
        points: "12 6 12 12 16 14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Cloud;

impl IconShape for Cloud {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M18 10h-1.26A8 8 0 1 0 9 20h9a5 5 0 0 0 0-10z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CloudDrizzle;

impl IconShape for CloudDrizzle {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "8",
        x2: "8",
        y1: "19",
        y2: "21",
            }
line {
        x1: "8",
        x2: "8",
        y1: "13",
        y2: "15",
            }
line {
        x1: "16",
        x2: "16",
        y1: "19",
        y2: "21",
            }
line {
        x1: "16",
        x2: "16",
        y1: "13",
        y2: "15",
            }
line {
        x1: "12",
        x2: "12",
        y1: "21",
        y2: "23",
            }
line {
        x1: "12",
        x2: "12",
        y1: "15",
        y2: "17",
            }
path {
        d: "M20 16.58A5 5 0 0 0 18 7h-1.26A8 8 0 1 0 4 15.25",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CloudLightning;

impl IconShape for CloudLightning {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M19 16.9A5 5 0 0 0 18 7h-1.26a8 8 0 1 0-11.62 9",
            }
polyline {
        points: "13 11 9 17 15 17 11 23",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CloudOff;

impl IconShape for CloudOff {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M22.61 16.95A5 5 0 0 0 18 10h-1.26a8 8 0 0 0-7.05-6M5 5a8 8 0 0 0 4 15h9a5 5 0 0 0 1.7-.3",
            }
line {
        x1: "1",
        x2: "23",
        y1: "1",
        y2: "23",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CloudRain;

impl IconShape for CloudRain {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "16",
        x2: "16",
        y1: "13",
        y2: "21",
            }
line {
        x1: "8",
        x2: "8",
        y1: "13",
        y2: "21",
            }
line {
        x1: "12",
        x2: "12",
        y1: "15",
        y2: "23",
            }
path {
        d: "M20 16.58A5 5 0 0 0 18 7h-1.26A8 8 0 1 0 4 15.25",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CloudSnow;

impl IconShape for CloudSnow {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M20 17.58A5 5 0 0 0 18 8h-1.26A8 8 0 1 0 4 16.25",
            }
line {
        x1: "8",
        x2: "8.01",
        y1: "16",
        y2: "16",
            }
line {
        x1: "8",
        x2: "8.01",
        y1: "20",
        y2: "20",
            }
line {
        x1: "12",
        x2: "12.01",
        y1: "18",
        y2: "18",
            }
line {
        x1: "12",
        x2: "12.01",
        y1: "22",
        y2: "22",
            }
line {
        x1: "16",
        x2: "16.01",
        y1: "16",
        y2: "16",
            }
line {
        x1: "16",
        x2: "16.01",
        y1: "20",
        y2: "20",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Code;

impl IconShape for Code {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "16 18 22 12 16 6",
            }
polyline {
        points: "8 6 2 12 8 18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Codepen;

impl IconShape for Codepen {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Codesandbox;

impl IconShape for Codesandbox {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Coffee;

impl IconShape for Coffee {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M18 8h1a4 4 0 0 1 0 8h-1",
            }
path {
        d: "M2 8h16v9a4 4 0 0 1-4 4H6a4 4 0 0 1-4-4V8z",
            }
line {
        x1: "6",
        x2: "6",
        y1: "1",
        y2: "4",
            }
line {
        x1: "10",
        x2: "10",
        y1: "1",
        y2: "4",
            }
line {
        x1: "14",
        x2: "14",
        y1: "1",
        y2: "4",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Columns;

impl IconShape for Columns {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M12 3h7a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-7m0-18H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7m0-18v18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Command;

impl IconShape for Command {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M18 3a3 3 0 0 0-3 3v12a3 3 0 0 0 3 3 3 3 0 0 0 3-3 3 3 0 0 0-3-3H6a3 3 0 0 0-3 3 3 3 0 0 0 3 3 3 3 0 0 0 3-3V6a3 3 0 0 0-3-3 3 3 0 0 0-3 3 3 3 0 0 0 3 3h12a3 3 0 0 0 3-3 3 3 0 0 0-3-3z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Compass;

impl IconShape for Compass {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
polygon {
        points: "16.24 7.76 14.12 14.12 7.76 16.24 9.88 9.88 16.24 7.76",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Copy;

impl IconShape for Copy {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "13",
        rx: "2",
        ry: "2",
        width: "13",
        x: "9",
        y: "9",
            }
path {
        d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CornerDownLeft;

impl IconShape for CornerDownLeft {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "9 10 4 15 9 20",
            }
path {
        d: "M20 4v7a4 4 0 0 1-4 4H4",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CornerDownRight;

impl IconShape for CornerDownRight {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "15 10 20 15 15 20",
            }
path {
        d: "M4 4v7a4 4 0 0 0 4 4h12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CornerLeftDown;

impl IconShape for CornerLeftDown {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "14 15 9 20 4 15",
            }
path {
        d: "M20 4h-7a4 4 0 0 0-4 4v12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CornerLeftUp;

impl IconShape for CornerLeftUp {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "14 9 9 4 4 9",
            }
path {
        d: "M20 20h-7a4 4 0 0 1-4-4V4",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CornerRightDown;

impl IconShape for CornerRightDown {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "10 15 15 20 20 15",
            }
path {
        d: "M4 4h7a4 4 0 0 1 4 4v12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CornerRightUp;

impl IconShape for CornerRightUp {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "10 9 15 4 20 9",
            }
path {
        d: "M4 20h7a4 4 0 0 0 4-4V4",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CornerUpLeft;

impl IconShape for CornerUpLeft {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "9 14 4 9 9 4",
            }
path {
        d: "M20 20v-7a4 4 0 0 0-4-4H4",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CornerUpRight;

impl IconShape for CornerUpRight {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "15 14 20 9 15 4",
            }
path {
        d: "M4 20v-7a4 4 0 0 1 4-4h12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Cpu;

impl IconShape for Cpu {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "16",
        rx: "2",
        ry: "2",
        width: "16",
        x: "4",
        y: "4",
            }
rect {
        height: "6",
        width: "6",
        x: "9",
        y: "9",
            }
line {
        x1: "9",
        x2: "9",
        y1: "1",
        y2: "4",
            }
line {
        x1: "15",
        x2: "15",
        y1: "1",
        y2: "4",
            }
line {
        x1: "9",
        x2: "9",
        y1: "20",
        y2: "23",
            }
line {
        x1: "15",
        x2: "15",
        y1: "20",
        y2: "23",
            }
line {
        x1: "20",
        x2: "23",
        y1: "9",
        y2: "9",
            }
line {
        x1: "20",
        x2: "23",
        y1: "14",
        y2: "14",
            }
line {
        x1: "1",
        x2: "4",
        y1: "9",
        y2: "9",
            }
line {
        x1: "1",
        x2: "4",
        y1: "14",
        y2: "14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct CreditCard;

impl IconShape for CreditCard {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "16",
        rx: "2",
        ry: "2",
        width: "22",
        x: "1",
        y: "4",
            }
line {
        x1: "1",
        x2: "23",
        y1: "10",
        y2: "10",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Crop;

impl IconShape for Crop {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M6.13 1L6 16a2 2 0 0 0 2 2h15",
            }
path {
        d: "M1 6.13L16 6a2 2 0 0 1 2 2v15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Crosshair;

impl IconShape for Crosshair {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Database;

impl IconShape for Database {
    fn child_elements(&self) -> Element {
        rsx!(ellipse {
        cx: "12",
        cy: "5",
        rx: "9",
        ry: "3",
            }
path {
        d: "M21 12c0 1.66-4 3-9 3s-9-1.34-9-3",
            }
path {
        d: "M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Delete;

impl IconShape for Delete {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21 4H8l-7 8 7 8h13a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2z",
            }
line {
        x1: "18",
        x2: "12",
        y1: "9",
        y2: "15",
            }
line {
        x1: "12",
        x2: "18",
        y1: "9",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Disc;

impl IconShape for Disc {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
circle {
        cx: "12",
        cy: "12",
        r: "3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Divide;

impl IconShape for Divide {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "6",
        r: "2",
            }
line {
        x1: "5",
        x2: "19",
        y1: "12",
        y2: "12",
            }
circle {
        cx: "12",
        cy: "18",
        r: "2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct DivideCircle;

impl IconShape for DivideCircle {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct DivideSquare;

impl IconShape for DivideSquare {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct DollarSign;

impl IconShape for DollarSign {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "12",
        x2: "12",
        y1: "1",
        y2: "23",
            }
path {
        d: "M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Download;

impl IconShape for Download {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4",
            }
polyline {
        points: "7 10 12 15 17 10",
            }
line {
        x1: "12",
        x2: "12",
        y1: "15",
        y2: "3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct DownloadCloud;

impl IconShape for DownloadCloud {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "8 17 12 21 16 17",
            }
line {
        x1: "12",
        x2: "12",
        y1: "12",
        y2: "21",
            }
path {
        d: "M20.88 18.09A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.29",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Dribbble;

impl IconShape for Dribbble {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
path {
        d: "M8.56 2.75c4.37 6.03 6.02 9.42 8.03 17.72m2.54-15.38c-3.72 4.35-8.94 5.66-16.88 5.85m19.5 1.9c-3.5-.93-6.63-.82-8.94 0-2.58.92-5.01 2.86-7.44 6.32",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Droplet;

impl IconShape for Droplet {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M12 2.69l5.66 5.66a8 8 0 1 1-11.31 0z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Edit;

impl IconShape for Edit {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7",
            }
path {
        d: "M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Edit2;

impl IconShape for Edit2 {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Edit3;

impl IconShape for Edit3 {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M12 20h9",
            }
path {
        d: "M16.5 3.5a2.121 2.121 0 0 1 3 3L7 19l-4 1 1-4L16.5 3.5z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ExternalLink;

impl IconShape for ExternalLink {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6",
            }
polyline {
        points: "15 3 21 3 21 9",
            }
line {
        x1: "10",
        x2: "21",
        y1: "14",
        y2: "3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Eye;

impl IconShape for Eye {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z",
            }
circle {
        cx: "12",
        cy: "12",
        r: "3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct EyeOff;

impl IconShape for EyeOff {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M17.94 17.94A10.07 10.07 0 0 1 12 20c-7 0-11-8-11-8a18.45 18.45 0 0 1 5.06-5.94M9.9 4.24A9.12 9.12 0 0 1 12 4c7 0 11 8 11 8a18.5 18.5 0 0 1-2.16 3.19m-6.72-1.07a3 3 0 1 1-4.24-4.24",
            }
line {
        x1: "1",
        x2: "23",
        y1: "1",
        y2: "23",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Facebook;

impl IconShape for Facebook {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct FastForward;

impl IconShape for FastForward {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "13 19 22 12 13 5 13 19",
            }
polygon {
        points: "2 19 11 12 2 5 2 19",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Feather;

impl IconShape for Feather {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M20.24 12.24a6 6 0 0 0-8.49-8.49L5 10.5V19h8.5z",
            }
line {
        x1: "16",
        x2: "2",
        y1: "8",
        y2: "22",
            }
line {
        x1: "17.5",
        x2: "9",
        y1: "15",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Figma;

impl IconShape for Figma {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct File;

impl IconShape for File {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M13 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V9z",
            }
polyline {
        points: "13 2 13 9 20 9",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct FileMinus;

impl IconShape for FileMinus {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z",
            }
polyline {
        points: "14 2 14 8 20 8",
            }
line {
        x1: "9",
        x2: "15",
        y1: "15",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct FilePlus;

impl IconShape for FilePlus {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z",
            }
polyline {
        points: "14 2 14 8 20 8",
            }
line {
        x1: "12",
        x2: "12",
        y1: "18",
        y2: "12",
            }
line {
        x1: "9",
        x2: "15",
        y1: "15",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct FileText;

impl IconShape for FileText {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z",
            }
polyline {
        points: "14 2 14 8 20 8",
            }
line {
        x1: "16",
        x2: "8",
        y1: "13",
        y2: "13",
            }
line {
        x1: "16",
        x2: "8",
        y1: "17",
        y2: "17",
            }
polyline {
        points: "10 9 9 9 8 9",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Film;

impl IconShape for Film {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "20",
        rx: "2.18",
        ry: "2.18",
        width: "20",
        x: "2",
        y: "2",
            }
line {
        x1: "7",
        x2: "7",
        y1: "2",
        y2: "22",
            }
line {
        x1: "17",
        x2: "17",
        y1: "2",
        y2: "22",
            }
line {
        x1: "2",
        x2: "22",
        y1: "12",
        y2: "12",
            }
line {
        x1: "2",
        x2: "7",
        y1: "7",
        y2: "7",
            }
line {
        x1: "2",
        x2: "7",
        y1: "17",
        y2: "17",
            }
line {
        x1: "17",
        x2: "22",
        y1: "17",
        y2: "17",
            }
line {
        x1: "17",
        x2: "22",
        y1: "7",
        y2: "7",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Filter;

impl IconShape for Filter {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Flag;

impl IconShape for Flag {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M4 15s1-1 4-1 5 2 8 2 4-1 4-1V3s-1 1-4 1-5-2-8-2-4 1-4 1z",
            }
line {
        x1: "4",
        x2: "4",
        y1: "22",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Folder;

impl IconShape for Folder {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct FolderMinus;

impl IconShape for FolderMinus {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z",
            }
line {
        x1: "9",
        x2: "15",
        y1: "14",
        y2: "14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct FolderPlus;

impl IconShape for FolderPlus {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z",
            }
line {
        x1: "12",
        x2: "12",
        y1: "11",
        y2: "17",
            }
line {
        x1: "9",
        x2: "15",
        y1: "14",
        y2: "14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Framer;

impl IconShape for Framer {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M5 16V9h14V2H5l14 14h-7m-7 0l7 7v-7m-7 0h7",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Frown;

impl IconShape for Frown {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Gift;

impl IconShape for Gift {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "20 12 20 22 4 22 4 12",
            }
rect {
        height: "5",
        width: "20",
        x: "2",
        y: "7",
            }
line {
        x1: "12",
        x2: "12",
        y1: "22",
        y2: "7",
            }
path {
        d: "M12 7H7.5a2.5 2.5 0 0 1 0-5C11 2 12 7 12 7z",
            }
path {
        d: "M12 7h4.5a2.5 2.5 0 0 0 0-5C13 2 12 7 12 7z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct GitBranch;

impl IconShape for GitBranch {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct GitCommit;

impl IconShape for GitCommit {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "4",
            }
line {
        x1: "1.05",
        x2: "7",
        y1: "12",
        y2: "12",
            }
line {
        x1: "17.01",
        x2: "22.96",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct GitMerge;

impl IconShape for GitMerge {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct GitPullRequest;

impl IconShape for GitPullRequest {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Github;

impl IconShape for Github {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M9 19c-5 1.5-5-2.5-7-3m14 6v-3.87a3.37 3.37 0 0 0-.94-2.61c3.14-.35 6.44-1.54 6.44-7A5.44 5.44 0 0 0 20 4.77 5.07 5.07 0 0 0 19.91 1S18.73.65 16 2.48a13.38 13.38 0 0 0-7 0C6.27.65 5.09 1 5.09 1A5.07 5.07 0 0 0 5 4.77a5.44 5.44 0 0 0-1.5 3.78c0 5.42 3.3 6.61 6.44 7A3.37 3.37 0 0 0 9 18.13V22",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Gitlab;

impl IconShape for Gitlab {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M22.65 14.39L12 22.13 1.35 14.39a.84.84 0 0 1-.3-.94l1.22-3.78 2.44-7.51A.42.42 0 0 1 4.82 2a.43.43 0 0 1 .58 0 .42.42 0 0 1 .11.18l2.44 7.49h8.1l2.44-7.51A.42.42 0 0 1 18.6 2a.43.43 0 0 1 .58 0 .42.42 0 0 1 .11.18l2.44 7.51L23 13.45a.84.84 0 0 1-.35.94z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Globe;

impl IconShape for Globe {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
line {
        x1: "2",
        x2: "22",
        y1: "12",
        y2: "12",
            }
path {
        d: "M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Grid;

impl IconShape for Grid {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "7",
        width: "7",
        x: "3",
        y: "3",
            }
rect {
        height: "7",
        width: "7",
        x: "14",
        y: "3",
            }
rect {
        height: "7",
        width: "7",
        x: "14",
        y: "14",
            }
rect {
        height: "7",
        width: "7",
        x: "3",
        y: "14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct HardDrive;

impl IconShape for HardDrive {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "22",
        x2: "2",
        y1: "12",
        y2: "12",
            }
path {
        d: "M5.45 5.11L2 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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Hash;

impl IconShape for Hash {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Headphones;

impl IconShape for Headphones {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M3 18v-6a9 9 0 0 1 18 0v6",
            }
path {
        d: "M21 19a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3zM3 19a2 2 0 0 0 2 2h1a2 2 0 0 0 2-2v-3a2 2 0 0 0-2-2H3z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Heart;

impl IconShape for Heart {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct HelpCircle;

impl IconShape for HelpCircle {
    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",
            }
line {
        x1: "12",
        x2: "12.01",
        y1: "17",
        y2: "17",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Hexagon;

impl IconShape for Hexagon {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Home;

impl IconShape for Home {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z",
            }
polyline {
        points: "9 22 9 12 15 12 15 22",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct IconBox;

impl IconShape for IconBox {
    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: "3.27 6.96 12 12.01 20.73 6.96",
            }
line {
        x1: "12",
        x2: "12",
        y1: "22.08",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct IconType;

impl IconShape for IconType {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "4 7 4 4 20 4 20 7",
            }
line {
        x1: "9",
        x2: "15",
        y1: "20",
        y2: "20",
            }
line {
        x1: "12",
        x2: "12",
        y1: "4",
        y2: "20",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Image;

impl IconShape for Image {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "18",
        rx: "2",
        ry: "2",
        width: "18",
        x: "3",
        y: "3",
            }
circle {
        cx: "8.5",
        cy: "8.5",
        r: "1.5",
            }
polyline {
        points: "21 15 16 10 5 21",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Inbox;

impl IconShape for Inbox {
    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.11L2 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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Info;

impl IconShape for Info {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
line {
        x1: "12",
        x2: "12",
        y1: "16",
        y2: "12",
            }
line {
        x1: "12",
        x2: "12.01",
        y1: "8",
        y2: "8",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Instagram;

impl IconShape for Instagram {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Italic;

impl IconShape for Italic {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Key;

impl IconShape for Key {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21 2l-2 2m-7.61 7.61a5.5 5.5 0 1 1-7.778 7.778 5.5 5.5 0 0 1 7.777-7.777zm0 0L15.5 7.5m0 0l3 3L22 7l-3-3m-3.5 3.5L19 4",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Layers;

impl IconShape for Layers {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "12 2 2 7 12 12 22 7 12 2",
            }
polyline {
        points: "2 17 12 22 22 17",
            }
polyline {
        points: "2 12 12 17 22 12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Layout;

impl IconShape for Layout {
    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: "9",
        x2: "9",
        y1: "21",
        y2: "9",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct LifeBuoy;

impl IconShape for LifeBuoy {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
circle {
        cx: "12",
        cy: "12",
        r: "4",
            }
line {
        x1: "4.93",
        x2: "9.17",
        y1: "4.93",
        y2: "9.17",
            }
line {
        x1: "14.83",
        x2: "19.07",
        y1: "14.83",
        y2: "19.07",
            }
line {
        x1: "14.83",
        x2: "19.07",
        y1: "9.17",
        y2: "4.93",
            }
line {
        x1: "14.83",
        x2: "18.36",
        y1: "9.17",
        y2: "5.64",
            }
line {
        x1: "4.93",
        x2: "9.17",
        y1: "19.07",
        y2: "14.83",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Link;

impl IconShape for Link {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Link2;

impl IconShape for Link2 {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3",
            }
line {
        x1: "8",
        x2: "16",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Linkedin;

impl IconShape for Linkedin {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct List;

impl IconShape for List {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "8",
        x2: "21",
        y1: "6",
        y2: "6",
            }
line {
        x1: "8",
        x2: "21",
        y1: "12",
        y2: "12",
            }
line {
        x1: "8",
        x2: "21",
        y1: "18",
        y2: "18",
            }
line {
        x1: "3",
        x2: "3.01",
        y1: "6",
        y2: "6",
            }
line {
        x1: "3",
        x2: "3.01",
        y1: "12",
        y2: "12",
            }
line {
        x1: "3",
        x2: "3.01",
        y1: "18",
        y2: "18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Loader;

impl IconShape for Loader {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "12",
        x2: "12",
        y1: "2",
        y2: "6",
            }
line {
        x1: "12",
        x2: "12",
        y1: "18",
        y2: "22",
            }
line {
        x1: "4.93",
        x2: "7.76",
        y1: "4.93",
        y2: "7.76",
            }
line {
        x1: "16.24",
        x2: "19.07",
        y1: "16.24",
        y2: "19.07",
            }
line {
        x1: "2",
        x2: "6",
        y1: "12",
        y2: "12",
            }
line {
        x1: "18",
        x2: "22",
        y1: "12",
        y2: "12",
            }
line {
        x1: "4.93",
        x2: "7.76",
        y1: "19.07",
        y2: "16.24",
            }
line {
        x1: "16.24",
        x2: "19.07",
        y1: "7.76",
        y2: "4.93",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Lock;

impl IconShape for Lock {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct LogIn;

impl IconShape for LogIn {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4",
            }
polyline {
        points: "10 17 15 12 10 7",
            }
line {
        x1: "15",
        x2: "3",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct LogOut;

impl IconShape for LogOut {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4",
            }
polyline {
        points: "16 17 21 12 16 7",
            }
line {
        x1: "21",
        x2: "9",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Mail;

impl IconShape for Mail {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z",
            }
polyline {
        points: "22,6 12,13 2,6",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Map;

impl IconShape for Map {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "1 6 1 22 8 18 16 22 23 18 23 2 16 6 8 2 1 6",
            }
line {
        x1: "8",
        x2: "8",
        y1: "2",
        y2: "18",
            }
line {
        x1: "16",
        x2: "16",
        y1: "6",
        y2: "22",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct MapPin;

impl IconShape for MapPin {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21 10c0 7-9 13-9 13s-9-6-9-13a9 9 0 0 1 18 0z",
            }
circle {
        cx: "12",
        cy: "10",
        r: "3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Maximize;

impl IconShape for Maximize {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Maximize2;

impl IconShape for Maximize2 {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "15 3 21 3 21 9",
            }
polyline {
        points: "9 21 3 21 3 15",
            }
line {
        x1: "21",
        x2: "14",
        y1: "3",
        y2: "10",
            }
line {
        x1: "3",
        x2: "10",
        y1: "21",
        y2: "14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Meh;

impl IconShape for Meh {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Menu;

impl IconShape for Menu {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "3",
        x2: "21",
        y1: "12",
        y2: "12",
            }
line {
        x1: "3",
        x2: "21",
        y1: "6",
        y2: "6",
            }
line {
        x1: "3",
        x2: "21",
        y1: "18",
        y2: "18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct MessageCircle;

impl IconShape for MessageCircle {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct MessageSquare;

impl IconShape for MessageSquare {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Mic;

impl IconShape for Mic {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M12 1a3 3 0 0 0-3 3v8a3 3 0 0 0 6 0V4a3 3 0 0 0-3-3z",
            }
path {
        d: "M19 10v2a7 7 0 0 1-14 0v-2",
            }
line {
        x1: "12",
        x2: "12",
        y1: "19",
        y2: "23",
            }
line {
        x1: "8",
        x2: "16",
        y1: "23",
        y2: "23",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct MicOff;

impl IconShape for MicOff {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "1",
        x2: "23",
        y1: "1",
        y2: "23",
            }
path {
        d: "M9 9v3a3 3 0 0 0 5.12 2.12M15 9.34V4a3 3 0 0 0-5.94-.6",
            }
path {
        d: "M17 16.95A7 7 0 0 1 5 12v-2m14 0v2a7 7 0 0 1-.11 1.23",
            }
line {
        x1: "12",
        x2: "12",
        y1: "19",
        y2: "23",
            }
line {
        x1: "8",
        x2: "16",
        y1: "23",
        y2: "23",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Minimize;

impl IconShape for Minimize {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M8 3v3a2 2 0 0 1-2 2H3m18 0h-3a2 2 0 0 1-2-2V3m0 18v-3a2 2 0 0 1 2-2h3M3 16h3a2 2 0 0 1 2 2v3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Minimize2;

impl IconShape for Minimize2 {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "4 14 10 14 10 20",
            }
polyline {
        points: "20 10 14 10 14 4",
            }
line {
        x1: "14",
        x2: "21",
        y1: "10",
        y2: "3",
            }
line {
        x1: "3",
        x2: "10",
        y1: "21",
        y2: "14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Minus;

impl IconShape for Minus {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "5",
        x2: "19",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct MinusCircle;

impl IconShape for MinusCircle {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
line {
        x1: "8",
        x2: "16",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct MinusSquare;

impl IconShape for MinusSquare {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Monitor;

impl IconShape for Monitor {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "14",
        rx: "2",
        ry: "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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Moon;

impl IconShape for Moon {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct MoreHorizontal;

impl IconShape for MoreHorizontal {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct MoreVertical;

impl IconShape for MoreVertical {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct MousePointer;

impl IconShape for MousePointer {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M3 3l7.07 16.97 2.51-7.39 7.39-2.51L3 3z",
            }
path {
        d: "M13 13l6 6",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Move;

impl IconShape for Move {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "5 9 2 12 5 15",
            }
polyline {
        points: "9 5 12 2 15 5",
            }
polyline {
        points: "15 19 12 22 9 19",
            }
polyline {
        points: "19 9 22 12 19 15",
            }
line {
        x1: "2",
        x2: "22",
        y1: "12",
        y2: "12",
            }
line {
        x1: "12",
        x2: "12",
        y1: "2",
        y2: "22",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Music;

impl IconShape for Music {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Navigation;

impl IconShape for Navigation {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "3 11 22 2 13 21 11 13 3 11",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Navigation2;

impl IconShape for Navigation2 {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "12 2 19 21 12 17 5 21 12 2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Octagon;

impl IconShape for Octagon {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Package;

impl IconShape for Package {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "16.5",
        x2: "7.5",
        y1: "9.4",
        y2: "4.21",
            }
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: "3.27 6.96 12 12.01 20.73 6.96",
            }
line {
        x1: "12",
        x2: "12",
        y1: "22.08",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Paperclip;

impl IconShape for Paperclip {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Pause;

impl IconShape for Pause {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "16",
        width: "4",
        x: "6",
        y: "4",
            }
rect {
        height: "16",
        width: "4",
        x: "14",
        y: "4",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PauseCircle;

impl IconShape for PauseCircle {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PenTool;

impl IconShape for PenTool {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M12 19l7-7 3 3-7 7-3-3z",
            }
path {
        d: "M18 13l-1.5-7.5L2 2l3.5 14.5L13 18l5-5z",
            }
path {
        d: "M2 2l7.586 7.586",
            }
circle {
        cx: "11",
        cy: "11",
        r: "2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Percent;

impl IconShape for Percent {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Phone;

impl IconShape for Phone {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PhoneCall;

impl IconShape for PhoneCall {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M15.05 5A5 5 0 0 1 19 8.95M15.05 1A9 9 0 0 1 23 8.94m-1 7.98v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PhoneForwarded;

impl IconShape for PhoneForwarded {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "19 1 23 5 19 9",
            }
line {
        x1: "15",
        x2: "23",
        y1: "5",
        y2: "5",
            }
path {
        d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PhoneIncoming;

impl IconShape for PhoneIncoming {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "16 2 16 8 22 8",
            }
line {
        x1: "23",
        x2: "16",
        y1: "1",
        y2: "8",
            }
path {
        d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PhoneMissed;

impl IconShape for PhoneMissed {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "23",
        x2: "17",
        y1: "1",
        y2: "7",
            }
line {
        x1: "17",
        x2: "23",
        y1: "1",
        y2: "7",
            }
path {
        d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PhoneOff;

impl IconShape for PhoneOff {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M10.68 13.31a16 16 0 0 0 3.41 2.6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7 2 2 0 0 1 1.72 2v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.42 19.42 0 0 1-3.33-2.67m-2.67-3.34a19.79 19.79 0 0 1-3.07-8.63A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91",
            }
line {
        x1: "23",
        x2: "1",
        y1: "1",
        y2: "23",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PhoneOutgoing;

impl IconShape for PhoneOutgoing {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "23 7 23 1 17 1",
            }
line {
        x1: "16",
        x2: "23",
        y1: "8",
        y2: "1",
            }
path {
        d: "M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PieChart;

impl IconShape for PieChart {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21.21 15.89A10 10 0 1 1 8 2.83",
            }
path {
        d: "M22 12A10 10 0 0 0 12 2v10z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Play;

impl IconShape for Play {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "5 3 19 12 5 21 5 3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PlayCircle;

impl IconShape for PlayCircle {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
polygon {
        points: "10 8 16 12 10 16 10 8",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Plus;

impl IconShape for Plus {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "12",
        x2: "12",
        y1: "5",
        y2: "19",
            }
line {
        x1: "5",
        x2: "19",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PlusCircle;

impl IconShape for PlusCircle {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
line {
        x1: "12",
        x2: "12",
        y1: "8",
        y2: "16",
            }
line {
        x1: "8",
        x2: "16",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct PlusSquare;

impl IconShape for PlusSquare {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "18",
        rx: "2",
        ry: "2",
        width: "18",
        x: "3",
        y: "3",
            }
line {
        x1: "12",
        x2: "12",
        y1: "8",
        y2: "16",
            }
line {
        x1: "8",
        x2: "16",
        y1: "12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Pocket;

impl IconShape for Pocket {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M4 3h16a2 2 0 0 1 2 2v6a10 10 0 0 1-10 10A10 10 0 0 1 2 11V5a2 2 0 0 1 2-2z",
            }
polyline {
        points: "8 10 12 14 16 10",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Power;

impl IconShape for Power {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M18.36 6.64a9 9 0 1 1-12.73 0",
            }
line {
        x1: "12",
        x2: "12",
        y1: "2",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Printer;

impl IconShape for Printer {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "6 9 6 2 18 2 18 9",
            }
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",
            }
rect {
        height: "8",
        width: "12",
        x: "6",
        y: "14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Radio;

impl IconShape for Radio {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "2",
            }
path {
        d: "M16.24 7.76a6 6 0 0 1 0 8.49m-8.48-.01a6 6 0 0 1 0-8.49m11.31-2.82a10 10 0 0 1 0 14.14m-14.14 0a10 10 0 0 1 0-14.14",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct RefreshCcw;

impl IconShape for RefreshCcw {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "1 4 1 10 7 10",
            }
polyline {
        points: "23 20 23 14 17 14",
            }
path {
        d: "M20.49 9A9 9 0 0 0 5.64 5.64L1 10m22 4l-4.64 4.36A9 9 0 0 1 3.51 15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct RefreshCw;

impl IconShape for RefreshCw {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "23 4 23 10 17 10",
            }
polyline {
        points: "1 20 1 14 7 14",
            }
path {
        d: "M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Repeat;

impl IconShape for Repeat {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "17 1 21 5 17 9",
            }
path {
        d: "M3 11V9a4 4 0 0 1 4-4h14",
            }
polyline {
        points: "7 23 3 19 7 15",
            }
path {
        d: "M21 13v2a4 4 0 0 1-4 4H3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Rewind;

impl IconShape for Rewind {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "11 19 2 12 11 5 11 19",
            }
polygon {
        points: "22 19 13 12 22 5 22 19",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct RotateCcw;

impl IconShape for RotateCcw {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "1 4 1 10 7 10",
            }
path {
        d: "M3.51 15a9 9 0 1 0 2.13-9.36L1 10",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct RotateCw;

impl IconShape for RotateCw {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "23 4 23 10 17 10",
            }
path {
        d: "M20.49 15a9 9 0 1 1-2.12-9.36L23 10",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Rss;

impl IconShape for Rss {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Save;

impl IconShape for Save {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11l5 5v11a2 2 0 0 1-2 2z",
            }
polyline {
        points: "17 21 17 13 7 13 7 21",
            }
polyline {
        points: "7 3 7 8 15 8",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Scissors;

impl IconShape for Scissors {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "6",
        cy: "6",
        r: "3",
            }
circle {
        cx: "6",
        cy: "18",
        r: "3",
            }
line {
        x1: "20",
        x2: "8.12",
        y1: "4",
        y2: "15.88",
            }
line {
        x1: "14.47",
        x2: "20",
        y1: "14.48",
        y2: "20",
            }
line {
        x1: "8.12",
        x2: "12",
        y1: "8.12",
        y2: "12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Search;

impl IconShape for Search {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "11",
        cy: "11",
        r: "8",
            }
line {
        x1: "21",
        x2: "16.65",
        y1: "21",
        y2: "16.65",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Send;

impl IconShape for Send {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "22",
        x2: "11",
        y1: "2",
        y2: "13",
            }
polygon {
        points: "22 2 15 22 11 13 2 9 22 2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Server;

impl IconShape for Server {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Settings;

impl IconShape for Settings {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "3",
            }
path {
        d: "M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Share;

impl IconShape for Share {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8",
            }
polyline {
        points: "16 6 12 2 8 6",
            }
line {
        x1: "12",
        x2: "12",
        y1: "2",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Share2;

impl IconShape for Share2 {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Shield;

impl IconShape for Shield {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ShieldOff;

impl IconShape for ShieldOff {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M19.69 14a6.9 6.9 0 0 0 .31-2V5l-8-3-3.16 1.18",
            }
path {
        d: "M4.73 4.73L4 5v7c0 6 8 10 8 10a20.29 20.29 0 0 0 5.62-4.38",
            }
line {
        x1: "1",
        x2: "23",
        y1: "1",
        y2: "23",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ShoppingBag;

impl IconShape for ShoppingBag {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M6 2L3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6l-3-4z",
            }
line {
        x1: "3",
        x2: "21",
        y1: "6",
        y2: "6",
            }
path {
        d: "M16 10a4 4 0 0 1-8 0",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ShoppingCart;

impl IconShape for ShoppingCart {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "9",
        cy: "21",
        r: "1",
            }
circle {
        cx: "20",
        cy: "21",
        r: "1",
            }
path {
        d: "M1 1h4l2.68 13.39a2 2 0 0 0 2 1.61h9.72a2 2 0 0 0 2-1.61L23 6H6",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Shuffle;

impl IconShape for Shuffle {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "16 3 21 3 21 8",
            }
line {
        x1: "4",
        x2: "21",
        y1: "20",
        y2: "3",
            }
polyline {
        points: "21 16 21 21 16 21",
            }
line {
        x1: "15",
        x2: "21",
        y1: "15",
        y2: "21",
            }
line {
        x1: "4",
        x2: "9",
        y1: "4",
        y2: "9",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Sidebar;

impl IconShape for Sidebar {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "18",
        rx: "2",
        ry: "2",
        width: "18",
        x: "3",
        y: "3",
            }
line {
        x1: "9",
        x2: "9",
        y1: "3",
        y2: "21",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct SkipBack;

impl IconShape for SkipBack {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "19 20 9 12 19 4 19 20",
            }
line {
        x1: "5",
        x2: "5",
        y1: "19",
        y2: "5",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct SkipForward;

impl IconShape for SkipForward {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "5 4 15 12 5 20 5 4",
            }
line {
        x1: "19",
        x2: "19",
        y1: "5",
        y2: "19",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Slack;

impl IconShape for Slack {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M14.5 10c-.83 0-1.5-.67-1.5-1.5v-5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5v5c0 .83-.67 1.5-1.5 1.5z",
            }
path {
        d: "M20.5 10H19V8.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z",
            }
path {
        d: "M9.5 14c.83 0 1.5.67 1.5 1.5v5c0 .83-.67 1.5-1.5 1.5S8 21.33 8 20.5v-5c0-.83.67-1.5 1.5-1.5z",
            }
path {
        d: "M3.5 14H5v1.5c0 .83-.67 1.5-1.5 1.5S2 16.33 2 15.5 2.67 14 3.5 14z",
            }
path {
        d: "M14 14.5c0-.83.67-1.5 1.5-1.5h5c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5h-5c-.83 0-1.5-.67-1.5-1.5z",
            }
path {
        d: "M15.5 19H14v1.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z",
            }
path {
        d: "M10 9.5C10 8.67 9.33 8 8.5 8h-5C2.67 8 2 8.67 2 9.5S2.67 11 3.5 11h5c.83 0 1.5-.67 1.5-1.5z",
            }
path {
        d: "M8.5 5H10V3.5C10 2.67 9.33 2 8.5 2S7 2.67 7 3.5 7.67 5 8.5 5z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Slash;

impl IconShape for Slash {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
line {
        x1: "4.93",
        x2: "19.07",
        y1: "4.93",
        y2: "19.07",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Sliders;

impl IconShape for Sliders {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "4",
        x2: "4",
        y1: "21",
        y2: "14",
            }
line {
        x1: "4",
        x2: "4",
        y1: "10",
        y2: "3",
            }
line {
        x1: "12",
        x2: "12",
        y1: "21",
        y2: "12",
            }
line {
        x1: "12",
        x2: "12",
        y1: "8",
        y2: "3",
            }
line {
        x1: "20",
        x2: "20",
        y1: "21",
        y2: "16",
            }
line {
        x1: "20",
        x2: "20",
        y1: "12",
        y2: "3",
            }
line {
        x1: "1",
        x2: "7",
        y1: "14",
        y2: "14",
            }
line {
        x1: "9",
        x2: "15",
        y1: "8",
        y2: "8",
            }
line {
        x1: "17",
        x2: "23",
        y1: "16",
        y2: "16",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Smartphone;

impl IconShape for Smartphone {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "20",
        rx: "2",
        ry: "2",
        width: "14",
        x: "5",
        y: "2",
            }
line {
        x1: "12",
        x2: "12.01",
        y1: "18",
        y2: "18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Smile;

impl IconShape for Smile {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Speaker;

impl IconShape for Speaker {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "20",
        rx: "2",
        ry: "2",
        width: "16",
        x: "4",
        y: "2",
            }
circle {
        cx: "12",
        cy: "14",
        r: "4",
            }
line {
        x1: "12",
        x2: "12.01",
        y1: "6",
        y2: "6",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Square;

impl IconShape for Square {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "18",
        rx: "2",
        ry: "2",
        width: "18",
        x: "3",
        y: "3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Star;

impl IconShape for Star {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct StopCircle;

impl IconShape for StopCircle {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
rect {
        height: "6",
        width: "6",
        x: "9",
        y: "9",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Sun;

impl IconShape for Sun {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "5",
            }
line {
        x1: "12",
        x2: "12",
        y1: "1",
        y2: "3",
            }
line {
        x1: "12",
        x2: "12",
        y1: "21",
        y2: "23",
            }
line {
        x1: "4.22",
        x2: "5.64",
        y1: "4.22",
        y2: "5.64",
            }
line {
        x1: "18.36",
        x2: "19.78",
        y1: "18.36",
        y2: "19.78",
            }
line {
        x1: "1",
        x2: "3",
        y1: "12",
        y2: "12",
            }
line {
        x1: "21",
        x2: "23",
        y1: "12",
        y2: "12",
            }
line {
        x1: "4.22",
        x2: "5.64",
        y1: "19.78",
        y2: "18.36",
            }
line {
        x1: "18.36",
        x2: "19.78",
        y1: "5.64",
        y2: "4.22",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Sunrise;

impl IconShape for Sunrise {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M17 18a5 5 0 0 0-10 0",
            }
line {
        x1: "12",
        x2: "12",
        y1: "2",
        y2: "9",
            }
line {
        x1: "4.22",
        x2: "5.64",
        y1: "10.22",
        y2: "11.64",
            }
line {
        x1: "1",
        x2: "3",
        y1: "18",
        y2: "18",
            }
line {
        x1: "21",
        x2: "23",
        y1: "18",
        y2: "18",
            }
line {
        x1: "18.36",
        x2: "19.78",
        y1: "11.64",
        y2: "10.22",
            }
line {
        x1: "23",
        x2: "1",
        y1: "22",
        y2: "22",
            }
polyline {
        points: "8 6 12 2 16 6",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Sunset;

impl IconShape for Sunset {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M17 18a5 5 0 0 0-10 0",
            }
line {
        x1: "12",
        x2: "12",
        y1: "9",
        y2: "2",
            }
line {
        x1: "4.22",
        x2: "5.64",
        y1: "10.22",
        y2: "11.64",
            }
line {
        x1: "1",
        x2: "3",
        y1: "18",
        y2: "18",
            }
line {
        x1: "21",
        x2: "23",
        y1: "18",
        y2: "18",
            }
line {
        x1: "18.36",
        x2: "19.78",
        y1: "11.64",
        y2: "10.22",
            }
line {
        x1: "23",
        x2: "1",
        y1: "22",
        y2: "22",
            }
polyline {
        points: "16 5 12 9 8 5",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Table;

impl IconShape for Table {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Tablet;

impl IconShape for Tablet {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Tag;

impl IconShape for Tag {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z",
            }
line {
        x1: "7",
        x2: "7.01",
        y1: "7",
        y2: "7",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Target;

impl IconShape for Target {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Terminal;

impl IconShape for Terminal {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "4 17 10 11 4 5",
            }
line {
        x1: "12",
        x2: "20",
        y1: "19",
        y2: "19",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Thermometer;

impl IconShape for Thermometer {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M14 14.76V3.5a2.5 2.5 0 0 0-5 0v11.26a4.5 4.5 0 1 0 5 0z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ThumbsDown;

impl IconShape for ThumbsDown {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M10 15v4a3 3 0 0 0 3 3l4-9V2H5.72a2 2 0 0 0-2 1.7l-1.38 9a2 2 0 0 0 2 2.3zm7-13h2.67A2.31 2.31 0 0 1 22 4v7a2.31 2.31 0 0 1-2.33 2H17",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ThumbsUp;

impl IconShape for ThumbsUp {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M14 9V5a3 3 0 0 0-3-3l-4 9v11h11.28a2 2 0 0 0 2-1.7l1.38-9a2 2 0 0 0-2-2.3zM7 22H4a2 2 0 0 1-2-2v-7a2 2 0 0 1 2-2h3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ToggleLeft;

impl IconShape for ToggleLeft {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "14",
        rx: "7",
        ry: "7",
        width: "22",
        x: "1",
        y: "5",
            }
circle {
        cx: "8",
        cy: "12",
        r: "3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ToggleRight;

impl IconShape for ToggleRight {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "14",
        rx: "7",
        ry: "7",
        width: "22",
        x: "1",
        y: "5",
            }
circle {
        cx: "16",
        cy: "12",
        r: "3",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Tool;

impl IconShape for Tool {
    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.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Trash;

impl IconShape for Trash {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "3 6 5 6 21 6",
            }
path {
        d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Trash2;

impl IconShape for Trash2 {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "3 6 5 6 21 6",
            }
path {
        d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2",
            }
line {
        x1: "10",
        x2: "10",
        y1: "11",
        y2: "17",
            }
line {
        x1: "14",
        x2: "14",
        y1: "11",
        y2: "17",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Trello;

impl IconShape for Trello {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct TrendingDown;

impl IconShape for TrendingDown {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "23 18 13.5 8.5 8.5 13.5 1 6",
            }
polyline {
        points: "17 18 23 18 23 12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct TrendingUp;

impl IconShape for TrendingUp {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "23 6 13.5 15.5 8.5 10.5 1 18",
            }
polyline {
        points: "17 6 23 6 23 12",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Triangle;

impl IconShape for Triangle {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Truck;

impl IconShape for Truck {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "13",
        width: "15",
        x: "1",
        y: "3",
            }
polygon {
        points: "16 8 20 8 23 11 23 16 16 16 16 8",
            }
circle {
        cx: "5.5",
        cy: "18.5",
        r: "2.5",
            }
circle {
        cx: "18.5",
        cy: "18.5",
        r: "2.5",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Tv;

impl IconShape for Tv {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "15",
        rx: "2",
        ry: "2",
        width: "20",
        x: "2",
        y: "7",
            }
polyline {
        points: "17 2 12 7 7 2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Twitch;

impl IconShape for Twitch {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21 2H3v16h5v4l4-4h5l4-4V2zm-10 9V7m5 4V7",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Twitter;

impl IconShape for Twitter {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M23 3a10.9 10.9 0 0 1-3.14 1.53 4.48 4.48 0 0 0-7.86 3v1A10.66 10.66 0 0 1 3 4s-4 9 5 13a11.64 11.64 0 0 1-7 2c9 5 20 0 20-11.5a4.5 4.5 0 0 0-.08-.83A7.72 7.72 0 0 0 23 3z",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Umbrella;

impl IconShape for Umbrella {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M23 12a11.05 11.05 0 0 0-22 0zm-5 7a3 3 0 0 1-6 0v-7",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Underline;

impl IconShape for Underline {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M6 3v7a6 6 0 0 0 6 6 6 6 0 0 0 6-6V3",
            }
line {
        x1: "4",
        x2: "20",
        y1: "21",
        y2: "21",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Unlock;

impl IconShape for Unlock {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Upload;

impl IconShape for Upload {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4",
            }
polyline {
        points: "17 8 12 3 7 8",
            }
line {
        x1: "12",
        x2: "12",
        y1: "3",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct UploadCloud;

impl IconShape for UploadCloud {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "16 16 12 12 8 16",
            }
line {
        x1: "12",
        x2: "12",
        y1: "12",
        y2: "21",
            }
path {
        d: "M20.39 18.39A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.3",
            }
polyline {
        points: "16 16 12 12 8 16",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct User;

impl IconShape for User {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2",
            }
circle {
        cx: "12",
        cy: "7",
        r: "4",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct UserCheck;

impl IconShape for UserCheck {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2",
            }
circle {
        cx: "8.5",
        cy: "7",
        r: "4",
            }
polyline {
        points: "17 11 19 13 23 9",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct UserMinus;

impl IconShape for UserMinus {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2",
            }
circle {
        cx: "8.5",
        cy: "7",
        r: "4",
            }
line {
        x1: "23",
        x2: "17",
        y1: "11",
        y2: "11",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct UserPlus;

impl IconShape for UserPlus {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2",
            }
circle {
        cx: "8.5",
        cy: "7",
        r: "4",
            }
line {
        x1: "20",
        x2: "20",
        y1: "8",
        y2: "14",
            }
line {
        x1: "23",
        x2: "17",
        y1: "11",
        y2: "11",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct UserX;

impl IconShape for UserX {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2",
            }
circle {
        cx: "8.5",
        cy: "7",
        r: "4",
            }
line {
        x1: "18",
        x2: "23",
        y1: "8",
        y2: "13",
            }
line {
        x1: "23",
        x2: "18",
        y1: "8",
        y2: "13",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Users;

impl IconShape for Users {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2",
            }
circle {
        cx: "9",
        cy: "7",
        r: "4",
            }
path {
        d: "M23 21v-2a4 4 0 0 0-3-3.87",
            }
path {
        d: "M16 3.13a4 4 0 0 1 0 7.75",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Video;

impl IconShape for Video {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "23 7 16 12 23 17 23 7",
            }
rect {
        height: "14",
        rx: "2",
        ry: "2",
        width: "15",
        x: "1",
        y: "5",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct VideoOff;

impl IconShape for VideoOff {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M16 16v1a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h2m5.66 0H14a2 2 0 0 1 2 2v3.34l1 1L23 7v10",
            }
line {
        x1: "1",
        x2: "23",
        y1: "1",
        y2: "23",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Voicemail;

impl IconShape for Voicemail {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "5.5",
        cy: "11.5",
        r: "4.5",
            }
circle {
        cx: "18.5",
        cy: "11.5",
        r: "4.5",
            }
line {
        x1: "5.5",
        x2: "18.5",
        y1: "16",
        y2: "16",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Volume;

impl IconShape for Volume {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Volume1;

impl IconShape for Volume1 {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5",
            }
path {
        d: "M15.54 8.46a5 5 0 0 1 0 7.07",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Volume2;

impl IconShape for Volume2 {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5",
            }
path {
        d: "M19.07 4.93a10 10 0 0 1 0 14.14M15.54 8.46a5 5 0 0 1 0 7.07",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct VolumeX;

impl IconShape for VolumeX {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "11 5 6 9 2 9 2 15 6 15 11 19 11 5",
            }
line {
        x1: "23",
        x2: "17",
        y1: "9",
        y2: "15",
            }
line {
        x1: "17",
        x2: "23",
        y1: "9",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Watch;

impl IconShape for Watch {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "7",
            }
polyline {
        points: "12 9 12 12 13.5 13.5",
            }
path {
        d: "M16.51 17.35l-.35 3.83a2 2 0 0 1-2 1.82H9.83a2 2 0 0 1-2-1.82l-.35-3.83m.01-10.7l.35-3.83A2 2 0 0 1 9.83 1h4.35a2 2 0 0 1 2 1.82l.35 3.83",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Wifi;

impl IconShape for Wifi {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M5 12.55a11 11 0 0 1 14.08 0",
            }
path {
        d: "M1.42 9a16 16 0 0 1 21.16 0",
            }
path {
        d: "M8.53 16.11a6 6 0 0 1 6.95 0",
            }
line {
        x1: "12",
        x2: "12.01",
        y1: "20",
        y2: "20",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct WifiOff;

impl IconShape for WifiOff {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "1",
        x2: "23",
        y1: "1",
        y2: "23",
            }
path {
        d: "M16.72 11.06A10.94 10.94 0 0 1 19 12.55",
            }
path {
        d: "M5 12.55a10.94 10.94 0 0 1 5.17-2.39",
            }
path {
        d: "M10.71 5.05A16 16 0 0 1 22.58 9",
            }
path {
        d: "M1.42 9a15.91 15.91 0 0 1 4.7-2.88",
            }
path {
        d: "M8.53 16.11a6 6 0 0 1 6.95 0",
            }
line {
        x1: "12",
        x2: "12.01",
        y1: "20",
        y2: "20",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Wind;

impl IconShape for Wind {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M9.59 4.59A2 2 0 1 1 11 8H2m10.59 11.41A2 2 0 1 0 14 16H2m15.73-8.27A2.5 2.5 0 1 1 19.5 12H2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct X;

impl IconShape for X {
    fn child_elements(&self) -> Element {
        rsx!(line {
        x1: "18",
        x2: "6",
        y1: "6",
        y2: "18",
            }
line {
        x1: "6",
        x2: "18",
        y1: "6",
        y2: "18",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct XCircle;

impl IconShape for XCircle {
    fn child_elements(&self) -> Element {
        rsx!(circle {
        cx: "12",
        cy: "12",
        r: "10",
            }
line {
        x1: "15",
        x2: "9",
        y1: "9",
        y2: "15",
            }
line {
        x1: "9",
        x2: "15",
        y1: "9",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct XOctagon;

impl IconShape for XOctagon {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2",
            }
line {
        x1: "15",
        x2: "9",
        y1: "9",
        y2: "15",
            }
line {
        x1: "9",
        x2: "15",
        y1: "9",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct XSquare;

impl IconShape for XSquare {
    fn child_elements(&self) -> Element {
        rsx!(rect {
        height: "18",
        rx: "2",
        ry: "2",
        width: "18",
        x: "3",
        y: "3",
            }
line {
        x1: "9",
        x2: "15",
        y1: "9",
        y2: "15",
            }
line {
        x1: "15",
        x2: "9",
        y1: "9",
        y2: "15",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Youtube;

impl IconShape for Youtube {
    fn child_elements(&self) -> Element {
        rsx!(path {
        d: "M22.54 6.42a2.78 2.78 0 0 0-1.94-2C18.88 4 12 4 12 4s-6.88 0-8.6.46a2.78 2.78 0 0 0-1.94 2A29 29 0 0 0 1 11.75a29 29 0 0 0 .46 5.33A2.78 2.78 0 0 0 3.4 19c1.72.46 8.6.46 8.6.46s6.88 0 8.6-.46a2.78 2.78 0 0 0 1.94-2 29 29 0 0 0 .46-5.25 29 29 0 0 0-.46-5.33z",
            }
polygon {
        points: "9.75 15.02 15.5 11.75 9.75 8.48 9.75 15.02",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct Zap;

impl IconShape for Zap {
    fn child_elements(&self) -> Element {
        rsx!(polygon {
        points: "13 2 3 14 12 14 11 22 21 10 12 10 13 2",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ZapOff;

impl IconShape for ZapOff {
    fn child_elements(&self) -> Element {
        rsx!(polyline {
        points: "12.41 6.75 13 2 10.57 4.92",
            }
polyline {
        points: "18.57 12.91 21 10 15.66 10",
            }
polyline {
        points: "8 8 3 14 12 14 11 22 16 16",
            }
line {
        x1: "1",
        x2: "23",
        y1: "1",
        y2: "23",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ZoomIn;

impl IconShape for ZoomIn {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}

#[derive(Default, Copy, Clone, PartialEq, Eq)]
pub struct ZoomOut;

impl IconShape for ZoomOut {
    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",
            })
    }

    const WIDTH: Option<&'static str> = Some("24");
    const HEIGHT: Option<&'static str> = Some("24");
    const FILL: Option<&'static str> = Some("none");
    const STROKE: Option<&'static str> = Some("currentColor");
    const STROKE_WIDTH: Option<&'static str> = Some("2");
    const STROKE_LINE_CAP: Option<&'static str> = Some("round");
    const STROKE_LINE_JOIN: Option<&'static str> = Some("round");
    const VIEW_BOX: Option<&'static str> = Some("0 0 24 24");

}