phosphor_lustre - v1.0.0

phosphor

Functions

acorn_bold

</> 
pub fn acorn_bold(attrs: List(Attribute(a))) -> Element(a)

acorn_duotone

</> 
pub fn acorn_duotone(attrs: List(Attribute(a))) -> Element(a)

acorn_fill

</> 
pub fn acorn_fill(attrs: List(Attribute(a))) -> Element(a)

acorn_light

</> 
pub fn acorn_light(attrs: List(Attribute(a))) -> Element(a)

acorn_regular

</> 
pub fn acorn_regular(attrs: List(Attribute(a))) -> Element(a)

acorn_thin

</> 
pub fn acorn_thin(attrs: List(Attribute(a))) -> Element(a)

address_book_bold

</> 
pub fn address_book_bold(attrs: List(Attribute(a))) -> Element(a)

address_book_duotone

</> 
pub fn address_book_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

address_book_fill

</> 
pub fn address_book_fill(attrs: List(Attribute(a))) -> Element(a)

address_book_light

</> 
pub fn address_book_light(
  attrs: List(Attribute(a)),
) -> Element(a)

address_book_regular

</> 
pub fn address_book_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

address_book_tabs_bold

</> 
pub fn address_book_tabs_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

address_book_tabs_duotone

</> 
pub fn address_book_tabs_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

address_book_tabs_fill

</> 
pub fn address_book_tabs_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

address_book_tabs_light

</> 
pub fn address_book_tabs_light(
  attrs: List(Attribute(a)),
) -> Element(a)

address_book_tabs_regular

</> 
pub fn address_book_tabs_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

address_book_tabs_thin

</> 
pub fn address_book_tabs_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

address_book_thin

</> 
pub fn address_book_thin(attrs: List(Attribute(a))) -> Element(a)

air_traffic_control_bold

</> 
pub fn air_traffic_control_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

air_traffic_control_duotone

</> 
pub fn air_traffic_control_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

air_traffic_control_fill

</> 
pub fn air_traffic_control_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

air_traffic_control_light

</> 
pub fn air_traffic_control_light(
  attrs: List(Attribute(a)),
) -> Element(a)

air_traffic_control_regular

</> 
pub fn air_traffic_control_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

air_traffic_control_thin

</> 
pub fn air_traffic_control_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_bold

</> 
pub fn airplane_bold(attrs: List(Attribute(a))) -> Element(a)

airplane_duotone

</> 
pub fn airplane_duotone(attrs: List(Attribute(a))) -> Element(a)

airplane_fill

</> 
pub fn airplane_fill(attrs: List(Attribute(a))) -> Element(a)

airplane_in_flight_bold

</> 
pub fn airplane_in_flight_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_in_flight_duotone

</> 
pub fn airplane_in_flight_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_in_flight_fill

</> 
pub fn airplane_in_flight_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_in_flight_light

</> 
pub fn airplane_in_flight_light(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_in_flight_regular

</> 
pub fn airplane_in_flight_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_in_flight_thin

</> 
pub fn airplane_in_flight_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_landing_bold

</> 
pub fn airplane_landing_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_landing_duotone

</> 
pub fn airplane_landing_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_landing_fill

</> 
pub fn airplane_landing_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_landing_light

</> 
pub fn airplane_landing_light(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_landing_regular

</> 
pub fn airplane_landing_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_landing_thin

</> 
pub fn airplane_landing_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_light

</> 
pub fn airplane_light(attrs: List(Attribute(a))) -> Element(a)

airplane_regular

</> 
pub fn airplane_regular(attrs: List(Attribute(a))) -> Element(a)

airplane_takeoff_bold

</> 
pub fn airplane_takeoff_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_takeoff_duotone

</> 
pub fn airplane_takeoff_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_takeoff_fill

</> 
pub fn airplane_takeoff_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_takeoff_light

</> 
pub fn airplane_takeoff_light(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_takeoff_regular

</> 
pub fn airplane_takeoff_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_takeoff_thin

</> 
pub fn airplane_takeoff_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_taxiing_bold

</> 
pub fn airplane_taxiing_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_taxiing_duotone

</> 
pub fn airplane_taxiing_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_taxiing_fill

</> 
pub fn airplane_taxiing_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_taxiing_light

</> 
pub fn airplane_taxiing_light(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_taxiing_regular

</> 
pub fn airplane_taxiing_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_taxiing_thin

</> 
pub fn airplane_taxiing_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_thin

</> 
pub fn airplane_thin(attrs: List(Attribute(a))) -> Element(a)

airplane_tilt_bold

</> 
pub fn airplane_tilt_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_tilt_duotone

</> 
pub fn airplane_tilt_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_tilt_fill

</> 
pub fn airplane_tilt_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_tilt_light

</> 
pub fn airplane_tilt_light(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_tilt_regular

</> 
pub fn airplane_tilt_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

airplane_tilt_thin

</> 
pub fn airplane_tilt_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

airplay_bold

</> 
pub fn airplay_bold(attrs: List(Attribute(a))) -> Element(a)

airplay_duotone

</> 
pub fn airplay_duotone(attrs: List(Attribute(a))) -> Element(a)

airplay_fill

</> 
pub fn airplay_fill(attrs: List(Attribute(a))) -> Element(a)

airplay_light

</> 
pub fn airplay_light(attrs: List(Attribute(a))) -> Element(a)

airplay_regular

</> 
pub fn airplay_regular(attrs: List(Attribute(a))) -> Element(a)

airplay_thin

</> 
pub fn airplay_thin(attrs: List(Attribute(a))) -> Element(a)

alarm_bold

</> 
pub fn alarm_bold(attrs: List(Attribute(a))) -> Element(a)

alarm_duotone

</> 
pub fn alarm_duotone(attrs: List(Attribute(a))) -> Element(a)

alarm_fill

</> 
pub fn alarm_fill(attrs: List(Attribute(a))) -> Element(a)

alarm_light

</> 
pub fn alarm_light(attrs: List(Attribute(a))) -> Element(a)

alarm_regular

</> 
pub fn alarm_regular(attrs: List(Attribute(a))) -> Element(a)

alarm_thin

</> 
pub fn alarm_thin(attrs: List(Attribute(a))) -> Element(a)

alien_bold

</> 
pub fn alien_bold(attrs: List(Attribute(a))) -> Element(a)

alien_duotone

</> 
pub fn alien_duotone(attrs: List(Attribute(a))) -> Element(a)

alien_fill

</> 
pub fn alien_fill(attrs: List(Attribute(a))) -> Element(a)

alien_light

</> 
pub fn alien_light(attrs: List(Attribute(a))) -> Element(a)

alien_regular

</> 
pub fn alien_regular(attrs: List(Attribute(a))) -> Element(a)

alien_thin

</> 
pub fn alien_thin(attrs: List(Attribute(a))) -> Element(a)

align_bottom_bold

</> 
pub fn align_bottom_bold(attrs: List(Attribute(a))) -> Element(a)

align_bottom_duotone

</> 
pub fn align_bottom_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_bottom_fill

</> 
pub fn align_bottom_fill(attrs: List(Attribute(a))) -> Element(a)

align_bottom_light

</> 
pub fn align_bottom_light(
  attrs: List(Attribute(a)),
) -> Element(a)

align_bottom_regular

</> 
pub fn align_bottom_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_bottom_simple_bold

</> 
pub fn align_bottom_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

align_bottom_simple_duotone

</> 
pub fn align_bottom_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_bottom_simple_fill

</> 
pub fn align_bottom_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

align_bottom_simple_light

</> 
pub fn align_bottom_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

align_bottom_simple_regular

</> 
pub fn align_bottom_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_bottom_simple_thin

</> 
pub fn align_bottom_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

align_bottom_thin

</> 
pub fn align_bottom_thin(attrs: List(Attribute(a))) -> Element(a)

align_center_horizontal_bold

</> 
pub fn align_center_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_duotone

</> 
pub fn align_center_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_fill

</> 
pub fn align_center_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_light

</> 
pub fn align_center_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_regular

</> 
pub fn align_center_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_simple_bold

</> 
pub fn align_center_horizontal_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_simple_duotone

</> 
pub fn align_center_horizontal_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_simple_fill

</> 
pub fn align_center_horizontal_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_simple_light

</> 
pub fn align_center_horizontal_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_simple_regular

</> 
pub fn align_center_horizontal_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_simple_thin

</> 
pub fn align_center_horizontal_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_horizontal_thin

</> 
pub fn align_center_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_bold

</> 
pub fn align_center_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_duotone

</> 
pub fn align_center_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_fill

</> 
pub fn align_center_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_light

</> 
pub fn align_center_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_regular

</> 
pub fn align_center_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_simple_bold

</> 
pub fn align_center_vertical_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_simple_duotone

</> 
pub fn align_center_vertical_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_simple_fill

</> 
pub fn align_center_vertical_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_simple_light

</> 
pub fn align_center_vertical_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_simple_regular

</> 
pub fn align_center_vertical_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_simple_thin

</> 
pub fn align_center_vertical_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

align_center_vertical_thin

</> 
pub fn align_center_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

align_left_bold

</> 
pub fn align_left_bold(attrs: List(Attribute(a))) -> Element(a)

align_left_duotone

</> 
pub fn align_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_left_fill

</> 
pub fn align_left_fill(attrs: List(Attribute(a))) -> Element(a)

align_left_light

</> 
pub fn align_left_light(attrs: List(Attribute(a))) -> Element(a)

align_left_regular

</> 
pub fn align_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_left_simple_bold

</> 
pub fn align_left_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

align_left_simple_duotone

</> 
pub fn align_left_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_left_simple_fill

</> 
pub fn align_left_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

align_left_simple_light

</> 
pub fn align_left_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

align_left_simple_regular

</> 
pub fn align_left_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_left_simple_thin

</> 
pub fn align_left_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

align_left_thin

</> 
pub fn align_left_thin(attrs: List(Attribute(a))) -> Element(a)

align_right_bold

</> 
pub fn align_right_bold(attrs: List(Attribute(a))) -> Element(a)

align_right_duotone

</> 
pub fn align_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_right_fill

</> 
pub fn align_right_fill(attrs: List(Attribute(a))) -> Element(a)

align_right_light

</> 
pub fn align_right_light(attrs: List(Attribute(a))) -> Element(a)

align_right_regular

</> 
pub fn align_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_right_simple_bold

</> 
pub fn align_right_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

align_right_simple_duotone

</> 
pub fn align_right_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_right_simple_fill

</> 
pub fn align_right_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

align_right_simple_light

</> 
pub fn align_right_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

align_right_simple_regular

</> 
pub fn align_right_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_right_simple_thin

</> 
pub fn align_right_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

align_right_thin

</> 
pub fn align_right_thin(attrs: List(Attribute(a))) -> Element(a)

align_top_bold

</> 
pub fn align_top_bold(attrs: List(Attribute(a))) -> Element(a)

align_top_duotone

</> 
pub fn align_top_duotone(attrs: List(Attribute(a))) -> Element(a)

align_top_fill

</> 
pub fn align_top_fill(attrs: List(Attribute(a))) -> Element(a)

align_top_light

</> 
pub fn align_top_light(attrs: List(Attribute(a))) -> Element(a)

align_top_regular

</> 
pub fn align_top_regular(attrs: List(Attribute(a))) -> Element(a)

align_top_simple_bold

</> 
pub fn align_top_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

align_top_simple_duotone

</> 
pub fn align_top_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

align_top_simple_fill

</> 
pub fn align_top_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

align_top_simple_light

</> 
pub fn align_top_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

align_top_simple_regular

</> 
pub fn align_top_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

align_top_simple_thin

</> 
pub fn align_top_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

align_top_thin

</> 
pub fn align_top_thin(attrs: List(Attribute(a))) -> Element(a)

amazon_logo_bold

</> 
pub fn amazon_logo_bold(attrs: List(Attribute(a))) -> Element(a)

amazon_logo_duotone

</> 
pub fn amazon_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

amazon_logo_fill

</> 
pub fn amazon_logo_fill(attrs: List(Attribute(a))) -> Element(a)

amazon_logo_light

</> 
pub fn amazon_logo_light(attrs: List(Attribute(a))) -> Element(a)

amazon_logo_regular

</> 
pub fn amazon_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

amazon_logo_thin

</> 
pub fn amazon_logo_thin(attrs: List(Attribute(a))) -> Element(a)

ambulance_bold

</> 
pub fn ambulance_bold(attrs: List(Attribute(a))) -> Element(a)

ambulance_duotone

</> 
pub fn ambulance_duotone(attrs: List(Attribute(a))) -> Element(a)

ambulance_fill

</> 
pub fn ambulance_fill(attrs: List(Attribute(a))) -> Element(a)

ambulance_light

</> 
pub fn ambulance_light(attrs: List(Attribute(a))) -> Element(a)

ambulance_regular

</> 
pub fn ambulance_regular(attrs: List(Attribute(a))) -> Element(a)

ambulance_thin

</> 
pub fn ambulance_thin(attrs: List(Attribute(a))) -> Element(a)

anchor_bold

</> 
pub fn anchor_bold(attrs: List(Attribute(a))) -> Element(a)

anchor_duotone

</> 
pub fn anchor_duotone(attrs: List(Attribute(a))) -> Element(a)

anchor_fill

</> 
pub fn anchor_fill(attrs: List(Attribute(a))) -> Element(a)

anchor_light

</> 
pub fn anchor_light(attrs: List(Attribute(a))) -> Element(a)

anchor_regular

</> 
pub fn anchor_regular(attrs: List(Attribute(a))) -> Element(a)

anchor_simple_bold

</> 
pub fn anchor_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

anchor_simple_duotone

</> 
pub fn anchor_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

anchor_simple_fill

</> 
pub fn anchor_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

anchor_simple_light

</> 
pub fn anchor_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

anchor_simple_regular

</> 
pub fn anchor_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

anchor_simple_thin

</> 
pub fn anchor_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

anchor_thin

</> 
pub fn anchor_thin(attrs: List(Attribute(a))) -> Element(a)

android_logo_bold

</> 
pub fn android_logo_bold(attrs: List(Attribute(a))) -> Element(a)

android_logo_duotone

</> 
pub fn android_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

android_logo_fill

</> 
pub fn android_logo_fill(attrs: List(Attribute(a))) -> Element(a)

android_logo_light

</> 
pub fn android_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

android_logo_regular

</> 
pub fn android_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

android_logo_thin

</> 
pub fn android_logo_thin(attrs: List(Attribute(a))) -> Element(a)

angle_bold

</> 
pub fn angle_bold(attrs: List(Attribute(a))) -> Element(a)

angle_duotone

</> 
pub fn angle_duotone(attrs: List(Attribute(a))) -> Element(a)

angle_fill

</> 
pub fn angle_fill(attrs: List(Attribute(a))) -> Element(a)

angle_light

</> 
pub fn angle_light(attrs: List(Attribute(a))) -> Element(a)

angle_regular

</> 
pub fn angle_regular(attrs: List(Attribute(a))) -> Element(a)

angle_thin

</> 
pub fn angle_thin(attrs: List(Attribute(a))) -> Element(a)

angular_logo_bold

</> 
pub fn angular_logo_bold(attrs: List(Attribute(a))) -> Element(a)

angular_logo_duotone

</> 
pub fn angular_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

angular_logo_fill

</> 
pub fn angular_logo_fill(attrs: List(Attribute(a))) -> Element(a)

angular_logo_light

</> 
pub fn angular_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

angular_logo_regular

</> 
pub fn angular_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

angular_logo_thin

</> 
pub fn angular_logo_thin(attrs: List(Attribute(a))) -> Element(a)

aperture_bold

</> 
pub fn aperture_bold(attrs: List(Attribute(a))) -> Element(a)

aperture_duotone

</> 
pub fn aperture_duotone(attrs: List(Attribute(a))) -> Element(a)

aperture_fill

</> 
pub fn aperture_fill(attrs: List(Attribute(a))) -> Element(a)

aperture_light

</> 
pub fn aperture_light(attrs: List(Attribute(a))) -> Element(a)

aperture_regular

</> 
pub fn aperture_regular(attrs: List(Attribute(a))) -> Element(a)

aperture_thin

</> 
pub fn aperture_thin(attrs: List(Attribute(a))) -> Element(a)

app_store_logo_bold

</> 
pub fn app_store_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

app_store_logo_duotone

</> 
pub fn app_store_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

app_store_logo_fill

</> 
pub fn app_store_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

app_store_logo_light

</> 
pub fn app_store_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

app_store_logo_regular

</> 
pub fn app_store_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

app_store_logo_thin

</> 
pub fn app_store_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

app_window_bold

</> 
pub fn app_window_bold(attrs: List(Attribute(a))) -> Element(a)

app_window_duotone

</> 
pub fn app_window_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

app_window_fill

</> 
pub fn app_window_fill(attrs: List(Attribute(a))) -> Element(a)

app_window_light

</> 
pub fn app_window_light(attrs: List(Attribute(a))) -> Element(a)

app_window_regular

</> 
pub fn app_window_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

app_window_thin

</> 
pub fn app_window_thin(attrs: List(Attribute(a))) -> Element(a)

apple_logo_bold

</> 
pub fn apple_logo_bold(attrs: List(Attribute(a))) -> Element(a)

apple_logo_duotone

</> 
pub fn apple_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

apple_logo_fill

</> 
pub fn apple_logo_fill(attrs: List(Attribute(a))) -> Element(a)

apple_logo_light

</> 
pub fn apple_logo_light(attrs: List(Attribute(a))) -> Element(a)

apple_logo_regular

</> 
pub fn apple_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

apple_logo_thin

</> 
pub fn apple_logo_thin(attrs: List(Attribute(a))) -> Element(a)

apple_podcasts_logo_bold

</> 
pub fn apple_podcasts_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

apple_podcasts_logo_duotone

</> 
pub fn apple_podcasts_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

apple_podcasts_logo_fill

</> 
pub fn apple_podcasts_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

apple_podcasts_logo_light

</> 
pub fn apple_podcasts_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

apple_podcasts_logo_regular

</> 
pub fn apple_podcasts_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

apple_podcasts_logo_thin

</> 
pub fn apple_podcasts_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

approximate_equals_bold

</> 
pub fn approximate_equals_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

approximate_equals_duotone

</> 
pub fn approximate_equals_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

approximate_equals_fill

</> 
pub fn approximate_equals_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

approximate_equals_light

</> 
pub fn approximate_equals_light(
  attrs: List(Attribute(a)),
) -> Element(a)

approximate_equals_regular

</> 
pub fn approximate_equals_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

approximate_equals_thin

</> 
pub fn approximate_equals_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

archive_bold

</> 
pub fn archive_bold(attrs: List(Attribute(a))) -> Element(a)

archive_duotone

</> 
pub fn archive_duotone(attrs: List(Attribute(a))) -> Element(a)

archive_fill

</> 
pub fn archive_fill(attrs: List(Attribute(a))) -> Element(a)

archive_light

</> 
pub fn archive_light(attrs: List(Attribute(a))) -> Element(a)

archive_regular

</> 
pub fn archive_regular(attrs: List(Attribute(a))) -> Element(a)

archive_thin

</> 
pub fn archive_thin(attrs: List(Attribute(a))) -> Element(a)

armchair_bold

</> 
pub fn armchair_bold(attrs: List(Attribute(a))) -> Element(a)

armchair_duotone

</> 
pub fn armchair_duotone(attrs: List(Attribute(a))) -> Element(a)

armchair_fill

</> 
pub fn armchair_fill(attrs: List(Attribute(a))) -> Element(a)

armchair_light

</> 
pub fn armchair_light(attrs: List(Attribute(a))) -> Element(a)

armchair_regular

</> 
pub fn armchair_regular(attrs: List(Attribute(a))) -> Element(a)

armchair_thin

</> 
pub fn armchair_thin(attrs: List(Attribute(a))) -> Element(a)

arrow_arc_left_bold

</> 
pub fn arrow_arc_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_left_duotone

</> 
pub fn arrow_arc_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_left_fill

</> 
pub fn arrow_arc_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_left_light

</> 
pub fn arrow_arc_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_left_regular

</> 
pub fn arrow_arc_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_left_thin

</> 
pub fn arrow_arc_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_right_bold

</> 
pub fn arrow_arc_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_right_duotone

</> 
pub fn arrow_arc_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_right_fill

</> 
pub fn arrow_arc_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_right_light

</> 
pub fn arrow_arc_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_right_regular

</> 
pub fn arrow_arc_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_arc_right_thin

</> 
pub fn arrow_arc_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_left_bold

</> 
pub fn arrow_bend_double_up_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_left_duotone

</> 
pub fn arrow_bend_double_up_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_left_fill

</> 
pub fn arrow_bend_double_up_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_left_light

</> 
pub fn arrow_bend_double_up_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_left_regular

</> 
pub fn arrow_bend_double_up_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_left_thin

</> 
pub fn arrow_bend_double_up_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_right_bold

</> 
pub fn arrow_bend_double_up_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_right_duotone

</> 
pub fn arrow_bend_double_up_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_right_fill

</> 
pub fn arrow_bend_double_up_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_right_light

</> 
pub fn arrow_bend_double_up_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_right_regular

</> 
pub fn arrow_bend_double_up_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_double_up_right_thin

</> 
pub fn arrow_bend_double_up_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_left_bold

</> 
pub fn arrow_bend_down_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_left_duotone

</> 
pub fn arrow_bend_down_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_left_fill

</> 
pub fn arrow_bend_down_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_left_light

</> 
pub fn arrow_bend_down_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_left_regular

</> 
pub fn arrow_bend_down_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_left_thin

</> 
pub fn arrow_bend_down_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_right_bold

</> 
pub fn arrow_bend_down_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_right_duotone

</> 
pub fn arrow_bend_down_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_right_fill

</> 
pub fn arrow_bend_down_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_right_light

</> 
pub fn arrow_bend_down_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_right_regular

</> 
pub fn arrow_bend_down_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_down_right_thin

</> 
pub fn arrow_bend_down_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_down_bold

</> 
pub fn arrow_bend_left_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_down_duotone

</> 
pub fn arrow_bend_left_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_down_fill

</> 
pub fn arrow_bend_left_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_down_light

</> 
pub fn arrow_bend_left_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_down_regular

</> 
pub fn arrow_bend_left_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_down_thin

</> 
pub fn arrow_bend_left_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_up_bold

</> 
pub fn arrow_bend_left_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_up_duotone

</> 
pub fn arrow_bend_left_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_up_fill

</> 
pub fn arrow_bend_left_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_up_light

</> 
pub fn arrow_bend_left_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_up_regular

</> 
pub fn arrow_bend_left_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_left_up_thin

</> 
pub fn arrow_bend_left_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_down_bold

</> 
pub fn arrow_bend_right_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_down_duotone

</> 
pub fn arrow_bend_right_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_down_fill

</> 
pub fn arrow_bend_right_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_down_light

</> 
pub fn arrow_bend_right_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_down_regular

</> 
pub fn arrow_bend_right_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_down_thin

</> 
pub fn arrow_bend_right_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_up_bold

</> 
pub fn arrow_bend_right_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_up_duotone

</> 
pub fn arrow_bend_right_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_up_fill

</> 
pub fn arrow_bend_right_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_up_light

</> 
pub fn arrow_bend_right_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_up_regular

</> 
pub fn arrow_bend_right_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_right_up_thin

</> 
pub fn arrow_bend_right_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_left_bold

</> 
pub fn arrow_bend_up_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_left_duotone

</> 
pub fn arrow_bend_up_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_left_fill

</> 
pub fn arrow_bend_up_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_left_light

</> 
pub fn arrow_bend_up_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_left_regular

</> 
pub fn arrow_bend_up_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_left_thin

</> 
pub fn arrow_bend_up_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_right_bold

</> 
pub fn arrow_bend_up_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_right_duotone

</> 
pub fn arrow_bend_up_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_right_fill

</> 
pub fn arrow_bend_up_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_right_light

</> 
pub fn arrow_bend_up_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_right_regular

</> 
pub fn arrow_bend_up_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_bend_up_right_thin

</> 
pub fn arrow_bend_up_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_bold

</> 
pub fn arrow_circle_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_duotone

</> 
pub fn arrow_circle_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_fill

</> 
pub fn arrow_circle_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_left_bold

</> 
pub fn arrow_circle_down_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_left_duotone

</> 
pub fn arrow_circle_down_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_left_fill

</> 
pub fn arrow_circle_down_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_left_light

</> 
pub fn arrow_circle_down_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_left_regular

</> 
pub fn arrow_circle_down_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_left_thin

</> 
pub fn arrow_circle_down_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_light

</> 
pub fn arrow_circle_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_regular

</> 
pub fn arrow_circle_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_right_bold

</> 
pub fn arrow_circle_down_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_right_duotone

</> 
pub fn arrow_circle_down_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_right_fill

</> 
pub fn arrow_circle_down_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_right_light

</> 
pub fn arrow_circle_down_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_right_regular

</> 
pub fn arrow_circle_down_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_right_thin

</> 
pub fn arrow_circle_down_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_down_thin

</> 
pub fn arrow_circle_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_left_bold

</> 
pub fn arrow_circle_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_left_duotone

</> 
pub fn arrow_circle_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_left_fill

</> 
pub fn arrow_circle_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_left_light

</> 
pub fn arrow_circle_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_left_regular

</> 
pub fn arrow_circle_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_left_thin

</> 
pub fn arrow_circle_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_right_bold

</> 
pub fn arrow_circle_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_right_duotone

</> 
pub fn arrow_circle_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_right_fill

</> 
pub fn arrow_circle_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_right_light

</> 
pub fn arrow_circle_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_right_regular

</> 
pub fn arrow_circle_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_right_thin

</> 
pub fn arrow_circle_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_bold

</> 
pub fn arrow_circle_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_duotone

</> 
pub fn arrow_circle_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_fill

</> 
pub fn arrow_circle_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_left_bold

</> 
pub fn arrow_circle_up_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_left_duotone

</> 
pub fn arrow_circle_up_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_left_fill

</> 
pub fn arrow_circle_up_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_left_light

</> 
pub fn arrow_circle_up_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_left_regular

</> 
pub fn arrow_circle_up_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_left_thin

</> 
pub fn arrow_circle_up_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_light

</> 
pub fn arrow_circle_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_regular

</> 
pub fn arrow_circle_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_right_bold

</> 
pub fn arrow_circle_up_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_right_duotone

</> 
pub fn arrow_circle_up_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_right_fill

</> 
pub fn arrow_circle_up_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_right_light

</> 
pub fn arrow_circle_up_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_right_regular

</> 
pub fn arrow_circle_up_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_right_thin

</> 
pub fn arrow_circle_up_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_circle_up_thin

</> 
pub fn arrow_circle_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_clockwise_bold

</> 
pub fn arrow_clockwise_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_clockwise_duotone

</> 
pub fn arrow_clockwise_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_clockwise_fill

</> 
pub fn arrow_clockwise_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_clockwise_light

</> 
pub fn arrow_clockwise_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_clockwise_regular

</> 
pub fn arrow_clockwise_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_clockwise_thin

</> 
pub fn arrow_clockwise_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_counter_clockwise_bold

</> 
pub fn arrow_counter_clockwise_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_counter_clockwise_duotone

</> 
pub fn arrow_counter_clockwise_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_counter_clockwise_fill

</> 
pub fn arrow_counter_clockwise_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_counter_clockwise_light

</> 
pub fn arrow_counter_clockwise_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_counter_clockwise_regular

</> 
pub fn arrow_counter_clockwise_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_counter_clockwise_thin

</> 
pub fn arrow_counter_clockwise_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_bold

</> 
pub fn arrow_down_bold(attrs: List(Attribute(a))) -> Element(a)

arrow_down_duotone

</> 
pub fn arrow_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_fill

</> 
pub fn arrow_down_fill(attrs: List(Attribute(a))) -> Element(a)

arrow_down_left_bold

</> 
pub fn arrow_down_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_left_duotone

</> 
pub fn arrow_down_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_left_fill

</> 
pub fn arrow_down_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_left_light

</> 
pub fn arrow_down_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_left_regular

</> 
pub fn arrow_down_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_left_thin

</> 
pub fn arrow_down_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_light

</> 
pub fn arrow_down_light(attrs: List(Attribute(a))) -> Element(a)

arrow_down_regular

</> 
pub fn arrow_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_right_bold

</> 
pub fn arrow_down_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_right_duotone

</> 
pub fn arrow_down_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_right_fill

</> 
pub fn arrow_down_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_right_light

</> 
pub fn arrow_down_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_right_regular

</> 
pub fn arrow_down_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_right_thin

</> 
pub fn arrow_down_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_down_thin

</> 
pub fn arrow_down_thin(attrs: List(Attribute(a))) -> Element(a)

arrow_elbow_down_left_bold

</> 
pub fn arrow_elbow_down_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_left_duotone

</> 
pub fn arrow_elbow_down_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_left_fill

</> 
pub fn arrow_elbow_down_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_left_light

</> 
pub fn arrow_elbow_down_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_left_regular

</> 
pub fn arrow_elbow_down_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_left_thin

</> 
pub fn arrow_elbow_down_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_right_bold

</> 
pub fn arrow_elbow_down_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_right_duotone

</> 
pub fn arrow_elbow_down_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_right_fill

</> 
pub fn arrow_elbow_down_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_right_light

</> 
pub fn arrow_elbow_down_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_right_regular

</> 
pub fn arrow_elbow_down_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_down_right_thin

</> 
pub fn arrow_elbow_down_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_bold

</> 
pub fn arrow_elbow_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_down_bold

</> 
pub fn arrow_elbow_left_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_down_duotone

</> 
pub fn arrow_elbow_left_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_down_fill

</> 
pub fn arrow_elbow_left_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_down_light

</> 
pub fn arrow_elbow_left_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_down_regular

</> 
pub fn arrow_elbow_left_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_down_thin

</> 
pub fn arrow_elbow_left_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_duotone

</> 
pub fn arrow_elbow_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_fill

</> 
pub fn arrow_elbow_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_light

</> 
pub fn arrow_elbow_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_regular

</> 
pub fn arrow_elbow_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_thin

</> 
pub fn arrow_elbow_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_up_bold

</> 
pub fn arrow_elbow_left_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_up_duotone

</> 
pub fn arrow_elbow_left_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_up_fill

</> 
pub fn arrow_elbow_left_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_up_light

</> 
pub fn arrow_elbow_left_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_up_regular

</> 
pub fn arrow_elbow_left_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_left_up_thin

</> 
pub fn arrow_elbow_left_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_bold

</> 
pub fn arrow_elbow_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_down_bold

</> 
pub fn arrow_elbow_right_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_down_duotone

</> 
pub fn arrow_elbow_right_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_down_fill

</> 
pub fn arrow_elbow_right_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_down_light

</> 
pub fn arrow_elbow_right_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_down_regular

</> 
pub fn arrow_elbow_right_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_down_thin

</> 
pub fn arrow_elbow_right_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_duotone

</> 
pub fn arrow_elbow_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_fill

</> 
pub fn arrow_elbow_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_light

</> 
pub fn arrow_elbow_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_regular

</> 
pub fn arrow_elbow_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_thin

</> 
pub fn arrow_elbow_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_up_bold

</> 
pub fn arrow_elbow_right_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_up_duotone

</> 
pub fn arrow_elbow_right_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_up_fill

</> 
pub fn arrow_elbow_right_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_up_light

</> 
pub fn arrow_elbow_right_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_up_regular

</> 
pub fn arrow_elbow_right_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_right_up_thin

</> 
pub fn arrow_elbow_right_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_left_bold

</> 
pub fn arrow_elbow_up_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_left_duotone

</> 
pub fn arrow_elbow_up_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_left_fill

</> 
pub fn arrow_elbow_up_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_left_light

</> 
pub fn arrow_elbow_up_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_left_regular

</> 
pub fn arrow_elbow_up_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_left_thin

</> 
pub fn arrow_elbow_up_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_right_bold

</> 
pub fn arrow_elbow_up_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_right_duotone

</> 
pub fn arrow_elbow_up_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_right_fill

</> 
pub fn arrow_elbow_up_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_right_light

</> 
pub fn arrow_elbow_up_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_right_regular

</> 
pub fn arrow_elbow_up_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_elbow_up_right_thin

</> 
pub fn arrow_elbow_up_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_down_bold

</> 
pub fn arrow_fat_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_down_duotone

</> 
pub fn arrow_fat_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_down_fill

</> 
pub fn arrow_fat_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_down_light

</> 
pub fn arrow_fat_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_down_regular

</> 
pub fn arrow_fat_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_down_thin

</> 
pub fn arrow_fat_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_left_bold

</> 
pub fn arrow_fat_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_left_duotone

</> 
pub fn arrow_fat_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_left_fill

</> 
pub fn arrow_fat_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_left_light

</> 
pub fn arrow_fat_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_left_regular

</> 
pub fn arrow_fat_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_left_thin

</> 
pub fn arrow_fat_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_down_bold

</> 
pub fn arrow_fat_line_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_down_duotone

</> 
pub fn arrow_fat_line_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_down_fill

</> 
pub fn arrow_fat_line_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_down_light

</> 
pub fn arrow_fat_line_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_down_regular

</> 
pub fn arrow_fat_line_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_down_thin

</> 
pub fn arrow_fat_line_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_left_bold

</> 
pub fn arrow_fat_line_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_left_duotone

</> 
pub fn arrow_fat_line_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_left_fill

</> 
pub fn arrow_fat_line_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_left_light

</> 
pub fn arrow_fat_line_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_left_regular

</> 
pub fn arrow_fat_line_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_left_thin

</> 
pub fn arrow_fat_line_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_right_bold

</> 
pub fn arrow_fat_line_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_right_duotone

</> 
pub fn arrow_fat_line_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_right_fill

</> 
pub fn arrow_fat_line_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_right_light

</> 
pub fn arrow_fat_line_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_right_regular

</> 
pub fn arrow_fat_line_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_right_thin

</> 
pub fn arrow_fat_line_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_up_bold

</> 
pub fn arrow_fat_line_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_up_duotone

</> 
pub fn arrow_fat_line_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_up_fill

</> 
pub fn arrow_fat_line_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_up_light

</> 
pub fn arrow_fat_line_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_up_regular

</> 
pub fn arrow_fat_line_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_line_up_thin

</> 
pub fn arrow_fat_line_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_down_bold

</> 
pub fn arrow_fat_lines_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_down_duotone

</> 
pub fn arrow_fat_lines_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_down_fill

</> 
pub fn arrow_fat_lines_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_down_light

</> 
pub fn arrow_fat_lines_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_down_regular

</> 
pub fn arrow_fat_lines_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_down_thin

</> 
pub fn arrow_fat_lines_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_left_bold

</> 
pub fn arrow_fat_lines_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_left_duotone

</> 
pub fn arrow_fat_lines_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_left_fill

</> 
pub fn arrow_fat_lines_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_left_light

</> 
pub fn arrow_fat_lines_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_left_regular

</> 
pub fn arrow_fat_lines_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_left_thin

</> 
pub fn arrow_fat_lines_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_right_bold

</> 
pub fn arrow_fat_lines_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_right_duotone

</> 
pub fn arrow_fat_lines_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_right_fill

</> 
pub fn arrow_fat_lines_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_right_light

</> 
pub fn arrow_fat_lines_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_right_regular

</> 
pub fn arrow_fat_lines_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_right_thin

</> 
pub fn arrow_fat_lines_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_up_bold

</> 
pub fn arrow_fat_lines_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_up_duotone

</> 
pub fn arrow_fat_lines_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_up_fill

</> 
pub fn arrow_fat_lines_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_up_light

</> 
pub fn arrow_fat_lines_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_up_regular

</> 
pub fn arrow_fat_lines_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_lines_up_thin

</> 
pub fn arrow_fat_lines_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_right_bold

</> 
pub fn arrow_fat_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_right_duotone

</> 
pub fn arrow_fat_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_right_fill

</> 
pub fn arrow_fat_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_right_light

</> 
pub fn arrow_fat_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_right_regular

</> 
pub fn arrow_fat_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_right_thin

</> 
pub fn arrow_fat_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_up_bold

</> 
pub fn arrow_fat_up_bold(attrs: List(Attribute(a))) -> Element(a)

arrow_fat_up_duotone

</> 
pub fn arrow_fat_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_up_fill

</> 
pub fn arrow_fat_up_fill(attrs: List(Attribute(a))) -> Element(a)

arrow_fat_up_light

</> 
pub fn arrow_fat_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_up_regular

</> 
pub fn arrow_fat_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_fat_up_thin

</> 
pub fn arrow_fat_up_thin(attrs: List(Attribute(a))) -> Element(a)

arrow_left_bold

</> 
pub fn arrow_left_bold(attrs: List(Attribute(a))) -> Element(a)

arrow_left_duotone

</> 
pub fn arrow_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_left_fill

</> 
pub fn arrow_left_fill(attrs: List(Attribute(a))) -> Element(a)

arrow_left_light

</> 
pub fn arrow_left_light(attrs: List(Attribute(a))) -> Element(a)

arrow_left_regular

</> 
pub fn arrow_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_left_thin

</> 
pub fn arrow_left_thin(attrs: List(Attribute(a))) -> Element(a)

arrow_line_down_bold

</> 
pub fn arrow_line_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_duotone

</> 
pub fn arrow_line_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_fill

</> 
pub fn arrow_line_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_left_bold

</> 
pub fn arrow_line_down_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_left_duotone

</> 
pub fn arrow_line_down_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_left_fill

</> 
pub fn arrow_line_down_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_left_light

</> 
pub fn arrow_line_down_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_left_regular

</> 
pub fn arrow_line_down_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_left_thin

</> 
pub fn arrow_line_down_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_light

</> 
pub fn arrow_line_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_regular

</> 
pub fn arrow_line_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_right_bold

</> 
pub fn arrow_line_down_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_right_duotone

</> 
pub fn arrow_line_down_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_right_fill

</> 
pub fn arrow_line_down_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_right_light

</> 
pub fn arrow_line_down_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_right_regular

</> 
pub fn arrow_line_down_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_right_thin

</> 
pub fn arrow_line_down_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_down_thin

</> 
pub fn arrow_line_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_left_bold

</> 
pub fn arrow_line_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_left_duotone

</> 
pub fn arrow_line_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_left_fill

</> 
pub fn arrow_line_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_left_light

</> 
pub fn arrow_line_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_left_regular

</> 
pub fn arrow_line_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_left_thin

</> 
pub fn arrow_line_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_right_bold

</> 
pub fn arrow_line_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_right_duotone

</> 
pub fn arrow_line_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_right_fill

</> 
pub fn arrow_line_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_right_light

</> 
pub fn arrow_line_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_right_regular

</> 
pub fn arrow_line_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_right_thin

</> 
pub fn arrow_line_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_bold

</> 
pub fn arrow_line_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_duotone

</> 
pub fn arrow_line_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_fill

</> 
pub fn arrow_line_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_left_bold

</> 
pub fn arrow_line_up_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_left_duotone

</> 
pub fn arrow_line_up_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_left_fill

</> 
pub fn arrow_line_up_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_left_light

</> 
pub fn arrow_line_up_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_left_regular

</> 
pub fn arrow_line_up_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_left_thin

</> 
pub fn arrow_line_up_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_light

</> 
pub fn arrow_line_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_regular

</> 
pub fn arrow_line_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_right_bold

</> 
pub fn arrow_line_up_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_right_duotone

</> 
pub fn arrow_line_up_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_right_fill

</> 
pub fn arrow_line_up_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_right_light

</> 
pub fn arrow_line_up_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_right_regular

</> 
pub fn arrow_line_up_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_right_thin

</> 
pub fn arrow_line_up_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_line_up_thin

</> 
pub fn arrow_line_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_right_bold

</> 
pub fn arrow_right_bold(attrs: List(Attribute(a))) -> Element(a)

arrow_right_duotone

</> 
pub fn arrow_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_right_fill

</> 
pub fn arrow_right_fill(attrs: List(Attribute(a))) -> Element(a)

arrow_right_light

</> 
pub fn arrow_right_light(attrs: List(Attribute(a))) -> Element(a)

arrow_right_regular

</> 
pub fn arrow_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_right_thin

</> 
pub fn arrow_right_thin(attrs: List(Attribute(a))) -> Element(a)

arrow_square_down_bold

</> 
pub fn arrow_square_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_duotone

</> 
pub fn arrow_square_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_fill

</> 
pub fn arrow_square_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_left_bold

</> 
pub fn arrow_square_down_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_left_duotone

</> 
pub fn arrow_square_down_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_left_fill

</> 
pub fn arrow_square_down_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_left_light

</> 
pub fn arrow_square_down_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_left_regular

</> 
pub fn arrow_square_down_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_left_thin

</> 
pub fn arrow_square_down_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_light

</> 
pub fn arrow_square_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_regular

</> 
pub fn arrow_square_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_right_bold

</> 
pub fn arrow_square_down_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_right_duotone

</> 
pub fn arrow_square_down_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_right_fill

</> 
pub fn arrow_square_down_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_right_light

</> 
pub fn arrow_square_down_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_right_regular

</> 
pub fn arrow_square_down_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_right_thin

</> 
pub fn arrow_square_down_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_down_thin

</> 
pub fn arrow_square_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_in_bold

</> 
pub fn arrow_square_in_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_in_duotone

</> 
pub fn arrow_square_in_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_in_fill

</> 
pub fn arrow_square_in_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_in_light

</> 
pub fn arrow_square_in_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_in_regular

</> 
pub fn arrow_square_in_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_in_thin

</> 
pub fn arrow_square_in_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_left_bold

</> 
pub fn arrow_square_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_left_duotone

</> 
pub fn arrow_square_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_left_fill

</> 
pub fn arrow_square_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_left_light

</> 
pub fn arrow_square_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_left_regular

</> 
pub fn arrow_square_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_left_thin

</> 
pub fn arrow_square_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_out_bold

</> 
pub fn arrow_square_out_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_out_duotone

</> 
pub fn arrow_square_out_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_out_fill

</> 
pub fn arrow_square_out_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_out_light

</> 
pub fn arrow_square_out_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_out_regular

</> 
pub fn arrow_square_out_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_out_thin

</> 
pub fn arrow_square_out_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_right_bold

</> 
pub fn arrow_square_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_right_duotone

</> 
pub fn arrow_square_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_right_fill

</> 
pub fn arrow_square_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_right_light

</> 
pub fn arrow_square_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_right_regular

</> 
pub fn arrow_square_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_right_thin

</> 
pub fn arrow_square_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_bold

</> 
pub fn arrow_square_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_duotone

</> 
pub fn arrow_square_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_fill

</> 
pub fn arrow_square_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_left_bold

</> 
pub fn arrow_square_up_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_left_duotone

</> 
pub fn arrow_square_up_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_left_fill

</> 
pub fn arrow_square_up_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_left_light

</> 
pub fn arrow_square_up_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_left_regular

</> 
pub fn arrow_square_up_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_left_thin

</> 
pub fn arrow_square_up_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_light

</> 
pub fn arrow_square_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_regular

</> 
pub fn arrow_square_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_right_bold

</> 
pub fn arrow_square_up_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_right_duotone

</> 
pub fn arrow_square_up_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_right_fill

</> 
pub fn arrow_square_up_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_right_light

</> 
pub fn arrow_square_up_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_right_regular

</> 
pub fn arrow_square_up_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_right_thin

</> 
pub fn arrow_square_up_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_square_up_thin

</> 
pub fn arrow_square_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_left_bold

</> 
pub fn arrow_u_down_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_left_duotone

</> 
pub fn arrow_u_down_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_left_fill

</> 
pub fn arrow_u_down_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_left_light

</> 
pub fn arrow_u_down_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_left_regular

</> 
pub fn arrow_u_down_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_left_thin

</> 
pub fn arrow_u_down_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_right_bold

</> 
pub fn arrow_u_down_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_right_duotone

</> 
pub fn arrow_u_down_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_right_fill

</> 
pub fn arrow_u_down_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_right_light

</> 
pub fn arrow_u_down_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_right_regular

</> 
pub fn arrow_u_down_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_down_right_thin

</> 
pub fn arrow_u_down_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_down_bold

</> 
pub fn arrow_u_left_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_down_duotone

</> 
pub fn arrow_u_left_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_down_fill

</> 
pub fn arrow_u_left_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_down_light

</> 
pub fn arrow_u_left_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_down_regular

</> 
pub fn arrow_u_left_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_down_thin

</> 
pub fn arrow_u_left_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_up_bold

</> 
pub fn arrow_u_left_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_up_duotone

</> 
pub fn arrow_u_left_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_up_fill

</> 
pub fn arrow_u_left_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_up_light

</> 
pub fn arrow_u_left_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_up_regular

</> 
pub fn arrow_u_left_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_left_up_thin

</> 
pub fn arrow_u_left_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_down_bold

</> 
pub fn arrow_u_right_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_down_duotone

</> 
pub fn arrow_u_right_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_down_fill

</> 
pub fn arrow_u_right_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_down_light

</> 
pub fn arrow_u_right_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_down_regular

</> 
pub fn arrow_u_right_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_down_thin

</> 
pub fn arrow_u_right_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_up_bold

</> 
pub fn arrow_u_right_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_up_duotone

</> 
pub fn arrow_u_right_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_up_fill

</> 
pub fn arrow_u_right_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_up_light

</> 
pub fn arrow_u_right_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_up_regular

</> 
pub fn arrow_u_right_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_right_up_thin

</> 
pub fn arrow_u_right_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_left_bold

</> 
pub fn arrow_u_up_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_left_duotone

</> 
pub fn arrow_u_up_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_left_fill

</> 
pub fn arrow_u_up_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_left_light

</> 
pub fn arrow_u_up_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_left_regular

</> 
pub fn arrow_u_up_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_left_thin

</> 
pub fn arrow_u_up_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_right_bold

</> 
pub fn arrow_u_up_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_right_duotone

</> 
pub fn arrow_u_up_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_right_fill

</> 
pub fn arrow_u_up_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_right_light

</> 
pub fn arrow_u_up_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_right_regular

</> 
pub fn arrow_u_up_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_u_up_right_thin

</> 
pub fn arrow_u_up_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_bold

</> 
pub fn arrow_up_bold(attrs: List(Attribute(a))) -> Element(a)

arrow_up_duotone

</> 
pub fn arrow_up_duotone(attrs: List(Attribute(a))) -> Element(a)

arrow_up_fill

</> 
pub fn arrow_up_fill(attrs: List(Attribute(a))) -> Element(a)

arrow_up_left_bold

</> 
pub fn arrow_up_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_left_duotone

</> 
pub fn arrow_up_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_left_fill

</> 
pub fn arrow_up_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_left_light

</> 
pub fn arrow_up_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_left_regular

</> 
pub fn arrow_up_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_left_thin

</> 
pub fn arrow_up_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_light

</> 
pub fn arrow_up_light(attrs: List(Attribute(a))) -> Element(a)

arrow_up_regular

</> 
pub fn arrow_up_regular(attrs: List(Attribute(a))) -> Element(a)

arrow_up_right_bold

</> 
pub fn arrow_up_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_right_duotone

</> 
pub fn arrow_up_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_right_fill

</> 
pub fn arrow_up_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_right_light

</> 
pub fn arrow_up_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_right_regular

</> 
pub fn arrow_up_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_right_thin

</> 
pub fn arrow_up_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrow_up_thin

</> 
pub fn arrow_up_thin(attrs: List(Attribute(a))) -> Element(a)

arrows_clockwise_bold

</> 
pub fn arrows_clockwise_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_clockwise_duotone

</> 
pub fn arrows_clockwise_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_clockwise_fill

</> 
pub fn arrows_clockwise_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_clockwise_light

</> 
pub fn arrows_clockwise_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_clockwise_regular

</> 
pub fn arrows_clockwise_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_clockwise_thin

</> 
pub fn arrows_clockwise_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_counter_clockwise_bold

</> 
pub fn arrows_counter_clockwise_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_counter_clockwise_duotone

</> 
pub fn arrows_counter_clockwise_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_counter_clockwise_fill

</> 
pub fn arrows_counter_clockwise_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_counter_clockwise_light

</> 
pub fn arrows_counter_clockwise_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_counter_clockwise_regular

</> 
pub fn arrows_counter_clockwise_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_counter_clockwise_thin

</> 
pub fn arrows_counter_clockwise_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_down_up_bold

</> 
pub fn arrows_down_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_down_up_duotone

</> 
pub fn arrows_down_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_down_up_fill

</> 
pub fn arrows_down_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_down_up_light

</> 
pub fn arrows_down_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_down_up_regular

</> 
pub fn arrows_down_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_down_up_thin

</> 
pub fn arrows_down_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_horizontal_bold

</> 
pub fn arrows_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_horizontal_duotone

</> 
pub fn arrows_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_horizontal_fill

</> 
pub fn arrows_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_horizontal_light

</> 
pub fn arrows_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_horizontal_regular

</> 
pub fn arrows_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_horizontal_thin

</> 
pub fn arrows_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_bold

</> 
pub fn arrows_in_bold(attrs: List(Attribute(a))) -> Element(a)

arrows_in_cardinal_bold

</> 
pub fn arrows_in_cardinal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_cardinal_duotone

</> 
pub fn arrows_in_cardinal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_cardinal_fill

</> 
pub fn arrows_in_cardinal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_cardinal_light

</> 
pub fn arrows_in_cardinal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_cardinal_regular

</> 
pub fn arrows_in_cardinal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_cardinal_thin

</> 
pub fn arrows_in_cardinal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_duotone

</> 
pub fn arrows_in_duotone(attrs: List(Attribute(a))) -> Element(a)

arrows_in_fill

</> 
pub fn arrows_in_fill(attrs: List(Attribute(a))) -> Element(a)

arrows_in_light

</> 
pub fn arrows_in_light(attrs: List(Attribute(a))) -> Element(a)

arrows_in_line_horizontal_bold

</> 
pub fn arrows_in_line_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_horizontal_duotone

</> 
pub fn arrows_in_line_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_horizontal_fill

</> 
pub fn arrows_in_line_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_horizontal_light

</> 
pub fn arrows_in_line_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_horizontal_regular

</> 
pub fn arrows_in_line_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_horizontal_thin

</> 
pub fn arrows_in_line_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_vertical_bold

</> 
pub fn arrows_in_line_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_vertical_duotone

</> 
pub fn arrows_in_line_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_vertical_fill

</> 
pub fn arrows_in_line_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_vertical_light

</> 
pub fn arrows_in_line_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_vertical_regular

</> 
pub fn arrows_in_line_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_line_vertical_thin

</> 
pub fn arrows_in_line_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_regular

</> 
pub fn arrows_in_regular(attrs: List(Attribute(a))) -> Element(a)

arrows_in_simple_bold

</> 
pub fn arrows_in_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_simple_duotone

</> 
pub fn arrows_in_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_simple_fill

</> 
pub fn arrows_in_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_simple_light

</> 
pub fn arrows_in_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_simple_regular

</> 
pub fn arrows_in_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_simple_thin

</> 
pub fn arrows_in_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_in_thin

</> 
pub fn arrows_in_thin(attrs: List(Attribute(a))) -> Element(a)

arrows_left_right_bold

</> 
pub fn arrows_left_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_left_right_duotone

</> 
pub fn arrows_left_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_left_right_fill

</> 
pub fn arrows_left_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_left_right_light

</> 
pub fn arrows_left_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_left_right_regular

</> 
pub fn arrows_left_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_left_right_thin

</> 
pub fn arrows_left_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_merge_bold

</> 
pub fn arrows_merge_bold(attrs: List(Attribute(a))) -> Element(a)

arrows_merge_duotone

</> 
pub fn arrows_merge_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_merge_fill

</> 
pub fn arrows_merge_fill(attrs: List(Attribute(a))) -> Element(a)

arrows_merge_light

</> 
pub fn arrows_merge_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_merge_regular

</> 
pub fn arrows_merge_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_merge_thin

</> 
pub fn arrows_merge_thin(attrs: List(Attribute(a))) -> Element(a)

arrows_out_bold

</> 
pub fn arrows_out_bold(attrs: List(Attribute(a))) -> Element(a)

arrows_out_cardinal_bold

</> 
pub fn arrows_out_cardinal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_cardinal_duotone

</> 
pub fn arrows_out_cardinal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_cardinal_fill

</> 
pub fn arrows_out_cardinal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_cardinal_light

</> 
pub fn arrows_out_cardinal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_cardinal_regular

</> 
pub fn arrows_out_cardinal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_cardinal_thin

</> 
pub fn arrows_out_cardinal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_duotone

</> 
pub fn arrows_out_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_fill

</> 
pub fn arrows_out_fill(attrs: List(Attribute(a))) -> Element(a)

arrows_out_light

</> 
pub fn arrows_out_light(attrs: List(Attribute(a))) -> Element(a)

arrows_out_line_horizontal_bold

</> 
pub fn arrows_out_line_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_horizontal_duotone

</> 
pub fn arrows_out_line_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_horizontal_fill

</> 
pub fn arrows_out_line_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_horizontal_light

</> 
pub fn arrows_out_line_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_horizontal_regular

</> 
pub fn arrows_out_line_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_horizontal_thin

</> 
pub fn arrows_out_line_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_vertical_bold

</> 
pub fn arrows_out_line_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_vertical_duotone

</> 
pub fn arrows_out_line_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_vertical_fill

</> 
pub fn arrows_out_line_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_vertical_light

</> 
pub fn arrows_out_line_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_vertical_regular

</> 
pub fn arrows_out_line_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_line_vertical_thin

</> 
pub fn arrows_out_line_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_regular

</> 
pub fn arrows_out_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_simple_bold

</> 
pub fn arrows_out_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_simple_duotone

</> 
pub fn arrows_out_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_simple_fill

</> 
pub fn arrows_out_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_simple_light

</> 
pub fn arrows_out_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_simple_regular

</> 
pub fn arrows_out_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_simple_thin

</> 
pub fn arrows_out_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_out_thin

</> 
pub fn arrows_out_thin(attrs: List(Attribute(a))) -> Element(a)

arrows_split_bold

</> 
pub fn arrows_split_bold(attrs: List(Attribute(a))) -> Element(a)

arrows_split_duotone

</> 
pub fn arrows_split_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_split_fill

</> 
pub fn arrows_split_fill(attrs: List(Attribute(a))) -> Element(a)

arrows_split_light

</> 
pub fn arrows_split_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_split_regular

</> 
pub fn arrows_split_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_split_thin

</> 
pub fn arrows_split_thin(attrs: List(Attribute(a))) -> Element(a)

arrows_vertical_bold

</> 
pub fn arrows_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_vertical_duotone

</> 
pub fn arrows_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_vertical_fill

</> 
pub fn arrows_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_vertical_light

</> 
pub fn arrows_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_vertical_regular

</> 
pub fn arrows_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

arrows_vertical_thin

</> 
pub fn arrows_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

article_bold

</> 
pub fn article_bold(attrs: List(Attribute(a))) -> Element(a)

article_duotone

</> 
pub fn article_duotone(attrs: List(Attribute(a))) -> Element(a)

article_fill

</> 
pub fn article_fill(attrs: List(Attribute(a))) -> Element(a)

article_light

</> 
pub fn article_light(attrs: List(Attribute(a))) -> Element(a)

article_medium_bold

</> 
pub fn article_medium_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

article_medium_duotone

</> 
pub fn article_medium_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

article_medium_fill

</> 
pub fn article_medium_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

article_medium_light

</> 
pub fn article_medium_light(
  attrs: List(Attribute(a)),
) -> Element(a)

article_medium_regular

</> 
pub fn article_medium_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

article_medium_thin

</> 
pub fn article_medium_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

article_ny_times_bold

</> 
pub fn article_ny_times_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

article_ny_times_duotone

</> 
pub fn article_ny_times_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

article_ny_times_fill

</> 
pub fn article_ny_times_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

article_ny_times_light

</> 
pub fn article_ny_times_light(
  attrs: List(Attribute(a)),
) -> Element(a)

article_ny_times_regular

</> 
pub fn article_ny_times_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

article_ny_times_thin

</> 
pub fn article_ny_times_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

article_regular

</> 
pub fn article_regular(attrs: List(Attribute(a))) -> Element(a)

article_thin

</> 
pub fn article_thin(attrs: List(Attribute(a))) -> Element(a)

asclepius_bold

</> 
pub fn asclepius_bold(attrs: List(Attribute(a))) -> Element(a)

asclepius_duotone

</> 
pub fn asclepius_duotone(attrs: List(Attribute(a))) -> Element(a)

asclepius_fill

</> 
pub fn asclepius_fill(attrs: List(Attribute(a))) -> Element(a)

asclepius_light

</> 
pub fn asclepius_light(attrs: List(Attribute(a))) -> Element(a)

asclepius_regular

</> 
pub fn asclepius_regular(attrs: List(Attribute(a))) -> Element(a)

asclepius_thin

</> 
pub fn asclepius_thin(attrs: List(Attribute(a))) -> Element(a)

asterisk_bold

</> 
pub fn asterisk_bold(attrs: List(Attribute(a))) -> Element(a)

asterisk_duotone

</> 
pub fn asterisk_duotone(attrs: List(Attribute(a))) -> Element(a)

asterisk_fill

</> 
pub fn asterisk_fill(attrs: List(Attribute(a))) -> Element(a)

asterisk_light

</> 
pub fn asterisk_light(attrs: List(Attribute(a))) -> Element(a)

asterisk_regular

</> 
pub fn asterisk_regular(attrs: List(Attribute(a))) -> Element(a)

asterisk_simple_bold

</> 
pub fn asterisk_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

asterisk_simple_duotone

</> 
pub fn asterisk_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

asterisk_simple_fill

</> 
pub fn asterisk_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

asterisk_simple_light

</> 
pub fn asterisk_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

asterisk_simple_regular

</> 
pub fn asterisk_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

asterisk_simple_thin

</> 
pub fn asterisk_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

asterisk_thin

</> 
pub fn asterisk_thin(attrs: List(Attribute(a))) -> Element(a)

at_bold

</> 
pub fn at_bold(attrs: List(Attribute(a))) -> Element(a)

at_duotone

</> 
pub fn at_duotone(attrs: List(Attribute(a))) -> Element(a)

at_fill

</> 
pub fn at_fill(attrs: List(Attribute(a))) -> Element(a)

at_light

</> 
pub fn at_light(attrs: List(Attribute(a))) -> Element(a)

at_regular

</> 
pub fn at_regular(attrs: List(Attribute(a))) -> Element(a)

at_thin

</> 
pub fn at_thin(attrs: List(Attribute(a))) -> Element(a)

atom_bold

</> 
pub fn atom_bold(attrs: List(Attribute(a))) -> Element(a)

atom_duotone

</> 
pub fn atom_duotone(attrs: List(Attribute(a))) -> Element(a)

atom_fill

</> 
pub fn atom_fill(attrs: List(Attribute(a))) -> Element(a)

atom_light

</> 
pub fn atom_light(attrs: List(Attribute(a))) -> Element(a)

atom_regular

</> 
pub fn atom_regular(attrs: List(Attribute(a))) -> Element(a)

atom_thin

</> 
pub fn atom_thin(attrs: List(Attribute(a))) -> Element(a)

avocado_bold

</> 
pub fn avocado_bold(attrs: List(Attribute(a))) -> Element(a)

avocado_duotone

</> 
pub fn avocado_duotone(attrs: List(Attribute(a))) -> Element(a)

avocado_fill

</> 
pub fn avocado_fill(attrs: List(Attribute(a))) -> Element(a)

avocado_light

</> 
pub fn avocado_light(attrs: List(Attribute(a))) -> Element(a)

avocado_regular

</> 
pub fn avocado_regular(attrs: List(Attribute(a))) -> Element(a)

avocado_thin

</> 
pub fn avocado_thin(attrs: List(Attribute(a))) -> Element(a)

axe_bold

</> 
pub fn axe_bold(attrs: List(Attribute(a))) -> Element(a)

axe_duotone

</> 
pub fn axe_duotone(attrs: List(Attribute(a))) -> Element(a)

axe_fill

</> 
pub fn axe_fill(attrs: List(Attribute(a))) -> Element(a)

axe_light

</> 
pub fn axe_light(attrs: List(Attribute(a))) -> Element(a)

axe_regular

</> 
pub fn axe_regular(attrs: List(Attribute(a))) -> Element(a)

axe_thin

</> 
pub fn axe_thin(attrs: List(Attribute(a))) -> Element(a)

baby_bold

</> 
pub fn baby_bold(attrs: List(Attribute(a))) -> Element(a)

baby_carriage_bold

</> 
pub fn baby_carriage_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

baby_carriage_duotone

</> 
pub fn baby_carriage_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

baby_carriage_fill

</> 
pub fn baby_carriage_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

baby_carriage_light

</> 
pub fn baby_carriage_light(
  attrs: List(Attribute(a)),
) -> Element(a)

baby_carriage_regular

</> 
pub fn baby_carriage_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

baby_carriage_thin

</> 
pub fn baby_carriage_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

baby_duotone

</> 
pub fn baby_duotone(attrs: List(Attribute(a))) -> Element(a)

baby_fill

</> 
pub fn baby_fill(attrs: List(Attribute(a))) -> Element(a)

baby_light

</> 
pub fn baby_light(attrs: List(Attribute(a))) -> Element(a)

baby_regular

</> 
pub fn baby_regular(attrs: List(Attribute(a))) -> Element(a)

baby_thin

</> 
pub fn baby_thin(attrs: List(Attribute(a))) -> Element(a)

backpack_bold

</> 
pub fn backpack_bold(attrs: List(Attribute(a))) -> Element(a)

backpack_duotone

</> 
pub fn backpack_duotone(attrs: List(Attribute(a))) -> Element(a)

backpack_fill

</> 
pub fn backpack_fill(attrs: List(Attribute(a))) -> Element(a)

backpack_light

</> 
pub fn backpack_light(attrs: List(Attribute(a))) -> Element(a)

backpack_regular

</> 
pub fn backpack_regular(attrs: List(Attribute(a))) -> Element(a)

backpack_thin

</> 
pub fn backpack_thin(attrs: List(Attribute(a))) -> Element(a)

backspace_bold

</> 
pub fn backspace_bold(attrs: List(Attribute(a))) -> Element(a)

backspace_duotone

</> 
pub fn backspace_duotone(attrs: List(Attribute(a))) -> Element(a)

backspace_fill

</> 
pub fn backspace_fill(attrs: List(Attribute(a))) -> Element(a)

backspace_light

</> 
pub fn backspace_light(attrs: List(Attribute(a))) -> Element(a)

backspace_regular

</> 
pub fn backspace_regular(attrs: List(Attribute(a))) -> Element(a)

backspace_thin

</> 
pub fn backspace_thin(attrs: List(Attribute(a))) -> Element(a)

bag_bold

</> 
pub fn bag_bold(attrs: List(Attribute(a))) -> Element(a)

bag_duotone

</> 
pub fn bag_duotone(attrs: List(Attribute(a))) -> Element(a)

bag_fill

</> 
pub fn bag_fill(attrs: List(Attribute(a))) -> Element(a)

bag_light

</> 
pub fn bag_light(attrs: List(Attribute(a))) -> Element(a)

bag_regular

</> 
pub fn bag_regular(attrs: List(Attribute(a))) -> Element(a)

bag_simple_bold

</> 
pub fn bag_simple_bold(attrs: List(Attribute(a))) -> Element(a)

bag_simple_duotone

</> 
pub fn bag_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bag_simple_fill

</> 
pub fn bag_simple_fill(attrs: List(Attribute(a))) -> Element(a)

bag_simple_light

</> 
pub fn bag_simple_light(attrs: List(Attribute(a))) -> Element(a)

bag_simple_regular

</> 
pub fn bag_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bag_simple_thin

</> 
pub fn bag_simple_thin(attrs: List(Attribute(a))) -> Element(a)

bag_thin

</> 
pub fn bag_thin(attrs: List(Attribute(a))) -> Element(a)

balloon_bold

</> 
pub fn balloon_bold(attrs: List(Attribute(a))) -> Element(a)

balloon_duotone

</> 
pub fn balloon_duotone(attrs: List(Attribute(a))) -> Element(a)

balloon_fill

</> 
pub fn balloon_fill(attrs: List(Attribute(a))) -> Element(a)

balloon_light

</> 
pub fn balloon_light(attrs: List(Attribute(a))) -> Element(a)

balloon_regular

</> 
pub fn balloon_regular(attrs: List(Attribute(a))) -> Element(a)

balloon_thin

</> 
pub fn balloon_thin(attrs: List(Attribute(a))) -> Element(a)

bandaids_bold

</> 
pub fn bandaids_bold(attrs: List(Attribute(a))) -> Element(a)

bandaids_duotone

</> 
pub fn bandaids_duotone(attrs: List(Attribute(a))) -> Element(a)

bandaids_fill

</> 
pub fn bandaids_fill(attrs: List(Attribute(a))) -> Element(a)

bandaids_light

</> 
pub fn bandaids_light(attrs: List(Attribute(a))) -> Element(a)

bandaids_regular

</> 
pub fn bandaids_regular(attrs: List(Attribute(a))) -> Element(a)

bandaids_thin

</> 
pub fn bandaids_thin(attrs: List(Attribute(a))) -> Element(a)

bank_bold

</> 
pub fn bank_bold(attrs: List(Attribute(a))) -> Element(a)

bank_duotone

</> 
pub fn bank_duotone(attrs: List(Attribute(a))) -> Element(a)

bank_fill

</> 
pub fn bank_fill(attrs: List(Attribute(a))) -> Element(a)

bank_light

</> 
pub fn bank_light(attrs: List(Attribute(a))) -> Element(a)

bank_regular

</> 
pub fn bank_regular(attrs: List(Attribute(a))) -> Element(a)

bank_thin

</> 
pub fn bank_thin(attrs: List(Attribute(a))) -> Element(a)

barbell_bold

</> 
pub fn barbell_bold(attrs: List(Attribute(a))) -> Element(a)

barbell_duotone

</> 
pub fn barbell_duotone(attrs: List(Attribute(a))) -> Element(a)

barbell_fill

</> 
pub fn barbell_fill(attrs: List(Attribute(a))) -> Element(a)

barbell_light

</> 
pub fn barbell_light(attrs: List(Attribute(a))) -> Element(a)

barbell_regular

</> 
pub fn barbell_regular(attrs: List(Attribute(a))) -> Element(a)

barbell_thin

</> 
pub fn barbell_thin(attrs: List(Attribute(a))) -> Element(a)

barcode_bold

</> 
pub fn barcode_bold(attrs: List(Attribute(a))) -> Element(a)

barcode_duotone

</> 
pub fn barcode_duotone(attrs: List(Attribute(a))) -> Element(a)

barcode_fill

</> 
pub fn barcode_fill(attrs: List(Attribute(a))) -> Element(a)

barcode_light

</> 
pub fn barcode_light(attrs: List(Attribute(a))) -> Element(a)

barcode_regular

</> 
pub fn barcode_regular(attrs: List(Attribute(a))) -> Element(a)

barcode_thin

</> 
pub fn barcode_thin(attrs: List(Attribute(a))) -> Element(a)

barn_bold

</> 
pub fn barn_bold(attrs: List(Attribute(a))) -> Element(a)

barn_duotone

</> 
pub fn barn_duotone(attrs: List(Attribute(a))) -> Element(a)

barn_fill

</> 
pub fn barn_fill(attrs: List(Attribute(a))) -> Element(a)

barn_light

</> 
pub fn barn_light(attrs: List(Attribute(a))) -> Element(a)

barn_regular

</> 
pub fn barn_regular(attrs: List(Attribute(a))) -> Element(a)

barn_thin

</> 
pub fn barn_thin(attrs: List(Attribute(a))) -> Element(a)

barricade_bold

</> 
pub fn barricade_bold(attrs: List(Attribute(a))) -> Element(a)

barricade_duotone

</> 
pub fn barricade_duotone(attrs: List(Attribute(a))) -> Element(a)

barricade_fill

</> 
pub fn barricade_fill(attrs: List(Attribute(a))) -> Element(a)

barricade_light

</> 
pub fn barricade_light(attrs: List(Attribute(a))) -> Element(a)

barricade_regular

</> 
pub fn barricade_regular(attrs: List(Attribute(a))) -> Element(a)

barricade_thin

</> 
pub fn barricade_thin(attrs: List(Attribute(a))) -> Element(a)

baseball_bold

</> 
pub fn baseball_bold(attrs: List(Attribute(a))) -> Element(a)

baseball_cap_bold

</> 
pub fn baseball_cap_bold(attrs: List(Attribute(a))) -> Element(a)

baseball_cap_duotone

</> 
pub fn baseball_cap_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

baseball_cap_fill

</> 
pub fn baseball_cap_fill(attrs: List(Attribute(a))) -> Element(a)

baseball_cap_light

</> 
pub fn baseball_cap_light(
  attrs: List(Attribute(a)),
) -> Element(a)

baseball_cap_regular

</> 
pub fn baseball_cap_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

baseball_cap_thin

</> 
pub fn baseball_cap_thin(attrs: List(Attribute(a))) -> Element(a)

baseball_duotone

</> 
pub fn baseball_duotone(attrs: List(Attribute(a))) -> Element(a)

baseball_fill

</> 
pub fn baseball_fill(attrs: List(Attribute(a))) -> Element(a)

baseball_helmet_bold

</> 
pub fn baseball_helmet_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

baseball_helmet_duotone

</> 
pub fn baseball_helmet_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

baseball_helmet_fill

</> 
pub fn baseball_helmet_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

baseball_helmet_light

</> 
pub fn baseball_helmet_light(
  attrs: List(Attribute(a)),
) -> Element(a)

baseball_helmet_regular

</> 
pub fn baseball_helmet_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

baseball_helmet_thin

</> 
pub fn baseball_helmet_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

baseball_light

</> 
pub fn baseball_light(attrs: List(Attribute(a))) -> Element(a)

baseball_regular

</> 
pub fn baseball_regular(attrs: List(Attribute(a))) -> Element(a)

baseball_thin

</> 
pub fn baseball_thin(attrs: List(Attribute(a))) -> Element(a)

basket_bold

</> 
pub fn basket_bold(attrs: List(Attribute(a))) -> Element(a)

basket_duotone

</> 
pub fn basket_duotone(attrs: List(Attribute(a))) -> Element(a)

basket_fill

</> 
pub fn basket_fill(attrs: List(Attribute(a))) -> Element(a)

basket_light

</> 
pub fn basket_light(attrs: List(Attribute(a))) -> Element(a)

basket_regular

</> 
pub fn basket_regular(attrs: List(Attribute(a))) -> Element(a)

basket_thin

</> 
pub fn basket_thin(attrs: List(Attribute(a))) -> Element(a)

basketball_bold

</> 
pub fn basketball_bold(attrs: List(Attribute(a))) -> Element(a)

basketball_duotone

</> 
pub fn basketball_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

basketball_fill

</> 
pub fn basketball_fill(attrs: List(Attribute(a))) -> Element(a)

basketball_light

</> 
pub fn basketball_light(attrs: List(Attribute(a))) -> Element(a)

basketball_regular

</> 
pub fn basketball_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

basketball_thin

</> 
pub fn basketball_thin(attrs: List(Attribute(a))) -> Element(a)

bathtub_bold

</> 
pub fn bathtub_bold(attrs: List(Attribute(a))) -> Element(a)

bathtub_duotone

</> 
pub fn bathtub_duotone(attrs: List(Attribute(a))) -> Element(a)

bathtub_fill

</> 
pub fn bathtub_fill(attrs: List(Attribute(a))) -> Element(a)

bathtub_light

</> 
pub fn bathtub_light(attrs: List(Attribute(a))) -> Element(a)

bathtub_regular

</> 
pub fn bathtub_regular(attrs: List(Attribute(a))) -> Element(a)

bathtub_thin

</> 
pub fn bathtub_thin(attrs: List(Attribute(a))) -> Element(a)

battery_charging_bold

</> 
pub fn battery_charging_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_duotone

</> 
pub fn battery_charging_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_fill

</> 
pub fn battery_charging_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_light

</> 
pub fn battery_charging_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_regular

</> 
pub fn battery_charging_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_thin

</> 
pub fn battery_charging_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_vertical_bold

</> 
pub fn battery_charging_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_vertical_duotone

</> 
pub fn battery_charging_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_vertical_fill

</> 
pub fn battery_charging_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_vertical_light

</> 
pub fn battery_charging_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_vertical_regular

</> 
pub fn battery_charging_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_charging_vertical_thin

</> 
pub fn battery_charging_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_empty_bold

</> 
pub fn battery_empty_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_empty_duotone

</> 
pub fn battery_empty_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_empty_fill

</> 
pub fn battery_empty_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_empty_light

</> 
pub fn battery_empty_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_empty_regular

</> 
pub fn battery_empty_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_empty_thin

</> 
pub fn battery_empty_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_full_bold

</> 
pub fn battery_full_bold(attrs: List(Attribute(a))) -> Element(a)

battery_full_duotone

</> 
pub fn battery_full_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_full_fill

</> 
pub fn battery_full_fill(attrs: List(Attribute(a))) -> Element(a)

battery_full_light

</> 
pub fn battery_full_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_full_regular

</> 
pub fn battery_full_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_full_thin

</> 
pub fn battery_full_thin(attrs: List(Attribute(a))) -> Element(a)

battery_high_bold

</> 
pub fn battery_high_bold(attrs: List(Attribute(a))) -> Element(a)

battery_high_duotone

</> 
pub fn battery_high_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_high_fill

</> 
pub fn battery_high_fill(attrs: List(Attribute(a))) -> Element(a)

battery_high_light

</> 
pub fn battery_high_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_high_regular

</> 
pub fn battery_high_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_high_thin

</> 
pub fn battery_high_thin(attrs: List(Attribute(a))) -> Element(a)

battery_low_bold

</> 
pub fn battery_low_bold(attrs: List(Attribute(a))) -> Element(a)

battery_low_duotone

</> 
pub fn battery_low_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_low_fill

</> 
pub fn battery_low_fill(attrs: List(Attribute(a))) -> Element(a)

battery_low_light

</> 
pub fn battery_low_light(attrs: List(Attribute(a))) -> Element(a)

battery_low_regular

</> 
pub fn battery_low_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_low_thin

</> 
pub fn battery_low_thin(attrs: List(Attribute(a))) -> Element(a)

battery_medium_bold

</> 
pub fn battery_medium_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_medium_duotone

</> 
pub fn battery_medium_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_medium_fill

</> 
pub fn battery_medium_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_medium_light

</> 
pub fn battery_medium_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_medium_regular

</> 
pub fn battery_medium_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_medium_thin

</> 
pub fn battery_medium_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_plus_bold

</> 
pub fn battery_plus_bold(attrs: List(Attribute(a))) -> Element(a)

battery_plus_duotone

</> 
pub fn battery_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_plus_fill

</> 
pub fn battery_plus_fill(attrs: List(Attribute(a))) -> Element(a)

battery_plus_light

</> 
pub fn battery_plus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_plus_regular

</> 
pub fn battery_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_plus_thin

</> 
pub fn battery_plus_thin(attrs: List(Attribute(a))) -> Element(a)

battery_plus_vertical_bold

</> 
pub fn battery_plus_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_plus_vertical_duotone

</> 
pub fn battery_plus_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_plus_vertical_fill

</> 
pub fn battery_plus_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_plus_vertical_light

</> 
pub fn battery_plus_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_plus_vertical_regular

</> 
pub fn battery_plus_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_plus_vertical_thin

</> 
pub fn battery_plus_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_empty_bold

</> 
pub fn battery_vertical_empty_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_empty_duotone

</> 
pub fn battery_vertical_empty_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_empty_fill

</> 
pub fn battery_vertical_empty_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_empty_light

</> 
pub fn battery_vertical_empty_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_empty_regular

</> 
pub fn battery_vertical_empty_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_empty_thin

</> 
pub fn battery_vertical_empty_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_full_bold

</> 
pub fn battery_vertical_full_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_full_duotone

</> 
pub fn battery_vertical_full_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_full_fill

</> 
pub fn battery_vertical_full_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_full_light

</> 
pub fn battery_vertical_full_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_full_regular

</> 
pub fn battery_vertical_full_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_full_thin

</> 
pub fn battery_vertical_full_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_high_bold

</> 
pub fn battery_vertical_high_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_high_duotone

</> 
pub fn battery_vertical_high_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_high_fill

</> 
pub fn battery_vertical_high_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_high_light

</> 
pub fn battery_vertical_high_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_high_regular

</> 
pub fn battery_vertical_high_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_high_thin

</> 
pub fn battery_vertical_high_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_low_bold

</> 
pub fn battery_vertical_low_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_low_duotone

</> 
pub fn battery_vertical_low_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_low_fill

</> 
pub fn battery_vertical_low_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_low_light

</> 
pub fn battery_vertical_low_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_low_regular

</> 
pub fn battery_vertical_low_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_low_thin

</> 
pub fn battery_vertical_low_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_medium_bold

</> 
pub fn battery_vertical_medium_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_medium_duotone

</> 
pub fn battery_vertical_medium_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_medium_fill

</> 
pub fn battery_vertical_medium_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_medium_light

</> 
pub fn battery_vertical_medium_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_medium_regular

</> 
pub fn battery_vertical_medium_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_vertical_medium_thin

</> 
pub fn battery_vertical_medium_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_bold

</> 
pub fn battery_warning_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_duotone

</> 
pub fn battery_warning_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_fill

</> 
pub fn battery_warning_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_light

</> 
pub fn battery_warning_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_regular

</> 
pub fn battery_warning_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_thin

</> 
pub fn battery_warning_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_vertical_bold

</> 
pub fn battery_warning_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_vertical_duotone

</> 
pub fn battery_warning_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_vertical_fill

</> 
pub fn battery_warning_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_vertical_light

</> 
pub fn battery_warning_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_vertical_regular

</> 
pub fn battery_warning_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

battery_warning_vertical_thin

</> 
pub fn battery_warning_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

beach_ball_bold

</> 
pub fn beach_ball_bold(attrs: List(Attribute(a))) -> Element(a)

beach_ball_duotone

</> 
pub fn beach_ball_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

beach_ball_fill

</> 
pub fn beach_ball_fill(attrs: List(Attribute(a))) -> Element(a)

beach_ball_light

</> 
pub fn beach_ball_light(attrs: List(Attribute(a))) -> Element(a)

beach_ball_regular

</> 
pub fn beach_ball_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

beach_ball_thin

</> 
pub fn beach_ball_thin(attrs: List(Attribute(a))) -> Element(a)

beanie_bold

</> 
pub fn beanie_bold(attrs: List(Attribute(a))) -> Element(a)

beanie_duotone

</> 
pub fn beanie_duotone(attrs: List(Attribute(a))) -> Element(a)

beanie_fill

</> 
pub fn beanie_fill(attrs: List(Attribute(a))) -> Element(a)

beanie_light

</> 
pub fn beanie_light(attrs: List(Attribute(a))) -> Element(a)

beanie_regular

</> 
pub fn beanie_regular(attrs: List(Attribute(a))) -> Element(a)

beanie_thin

</> 
pub fn beanie_thin(attrs: List(Attribute(a))) -> Element(a)

bed_bold

</> 
pub fn bed_bold(attrs: List(Attribute(a))) -> Element(a)

bed_duotone

</> 
pub fn bed_duotone(attrs: List(Attribute(a))) -> Element(a)

bed_fill

</> 
pub fn bed_fill(attrs: List(Attribute(a))) -> Element(a)

bed_light

</> 
pub fn bed_light(attrs: List(Attribute(a))) -> Element(a)

bed_regular

</> 
pub fn bed_regular(attrs: List(Attribute(a))) -> Element(a)

bed_thin

</> 
pub fn bed_thin(attrs: List(Attribute(a))) -> Element(a)

beer_bottle_bold

</> 
pub fn beer_bottle_bold(attrs: List(Attribute(a))) -> Element(a)

beer_bottle_duotone

</> 
pub fn beer_bottle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

beer_bottle_fill

</> 
pub fn beer_bottle_fill(attrs: List(Attribute(a))) -> Element(a)

beer_bottle_light

</> 
pub fn beer_bottle_light(attrs: List(Attribute(a))) -> Element(a)

beer_bottle_regular

</> 
pub fn beer_bottle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

beer_bottle_thin

</> 
pub fn beer_bottle_thin(attrs: List(Attribute(a))) -> Element(a)

beer_stein_bold

</> 
pub fn beer_stein_bold(attrs: List(Attribute(a))) -> Element(a)

beer_stein_duotone

</> 
pub fn beer_stein_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

beer_stein_fill

</> 
pub fn beer_stein_fill(attrs: List(Attribute(a))) -> Element(a)

beer_stein_light

</> 
pub fn beer_stein_light(attrs: List(Attribute(a))) -> Element(a)

beer_stein_regular

</> 
pub fn beer_stein_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

beer_stein_thin

</> 
pub fn beer_stein_thin(attrs: List(Attribute(a))) -> Element(a)

behance_logo_bold

</> 
pub fn behance_logo_bold(attrs: List(Attribute(a))) -> Element(a)

behance_logo_duotone

</> 
pub fn behance_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

behance_logo_fill

</> 
pub fn behance_logo_fill(attrs: List(Attribute(a))) -> Element(a)

behance_logo_light

</> 
pub fn behance_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

behance_logo_regular

</> 
pub fn behance_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

behance_logo_thin

</> 
pub fn behance_logo_thin(attrs: List(Attribute(a))) -> Element(a)

bell_bold

</> 
pub fn bell_bold(attrs: List(Attribute(a))) -> Element(a)

bell_duotone

</> 
pub fn bell_duotone(attrs: List(Attribute(a))) -> Element(a)

bell_fill

</> 
pub fn bell_fill(attrs: List(Attribute(a))) -> Element(a)

bell_light

</> 
pub fn bell_light(attrs: List(Attribute(a))) -> Element(a)

bell_regular

</> 
pub fn bell_regular(attrs: List(Attribute(a))) -> Element(a)

bell_ringing_bold

</> 
pub fn bell_ringing_bold(attrs: List(Attribute(a))) -> Element(a)

bell_ringing_duotone

</> 
pub fn bell_ringing_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_ringing_fill

</> 
pub fn bell_ringing_fill(attrs: List(Attribute(a))) -> Element(a)

bell_ringing_light

</> 
pub fn bell_ringing_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_ringing_regular

</> 
pub fn bell_ringing_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_ringing_thin

</> 
pub fn bell_ringing_thin(attrs: List(Attribute(a))) -> Element(a)

bell_simple_bold

</> 
pub fn bell_simple_bold(attrs: List(Attribute(a))) -> Element(a)

bell_simple_duotone

</> 
pub fn bell_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_fill

</> 
pub fn bell_simple_fill(attrs: List(Attribute(a))) -> Element(a)

bell_simple_light

</> 
pub fn bell_simple_light(attrs: List(Attribute(a))) -> Element(a)

bell_simple_regular

</> 
pub fn bell_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_ringing_bold

</> 
pub fn bell_simple_ringing_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_ringing_duotone

</> 
pub fn bell_simple_ringing_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_ringing_fill

</> 
pub fn bell_simple_ringing_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_ringing_light

</> 
pub fn bell_simple_ringing_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_ringing_regular

</> 
pub fn bell_simple_ringing_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_ringing_thin

</> 
pub fn bell_simple_ringing_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_slash_bold

</> 
pub fn bell_simple_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_slash_duotone

</> 
pub fn bell_simple_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_slash_fill

</> 
pub fn bell_simple_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_slash_light

</> 
pub fn bell_simple_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_slash_regular

</> 
pub fn bell_simple_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_slash_thin

</> 
pub fn bell_simple_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_thin

</> 
pub fn bell_simple_thin(attrs: List(Attribute(a))) -> Element(a)

bell_simple_z_bold

</> 
pub fn bell_simple_z_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_z_duotone

</> 
pub fn bell_simple_z_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_z_fill

</> 
pub fn bell_simple_z_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_z_light

</> 
pub fn bell_simple_z_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_z_regular

</> 
pub fn bell_simple_z_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_simple_z_thin

</> 
pub fn bell_simple_z_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_slash_bold

</> 
pub fn bell_slash_bold(attrs: List(Attribute(a))) -> Element(a)

bell_slash_duotone

</> 
pub fn bell_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_slash_fill

</> 
pub fn bell_slash_fill(attrs: List(Attribute(a))) -> Element(a)

bell_slash_light

</> 
pub fn bell_slash_light(attrs: List(Attribute(a))) -> Element(a)

bell_slash_regular

</> 
pub fn bell_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bell_slash_thin

</> 
pub fn bell_slash_thin(attrs: List(Attribute(a))) -> Element(a)

bell_thin

</> 
pub fn bell_thin(attrs: List(Attribute(a))) -> Element(a)

bell_z_bold

</> 
pub fn bell_z_bold(attrs: List(Attribute(a))) -> Element(a)

bell_z_duotone

</> 
pub fn bell_z_duotone(attrs: List(Attribute(a))) -> Element(a)

bell_z_fill

</> 
pub fn bell_z_fill(attrs: List(Attribute(a))) -> Element(a)

bell_z_light

</> 
pub fn bell_z_light(attrs: List(Attribute(a))) -> Element(a)

bell_z_regular

</> 
pub fn bell_z_regular(attrs: List(Attribute(a))) -> Element(a)

bell_z_thin

</> 
pub fn bell_z_thin(attrs: List(Attribute(a))) -> Element(a)

belt_bold

</> 
pub fn belt_bold(attrs: List(Attribute(a))) -> Element(a)

belt_duotone

</> 
pub fn belt_duotone(attrs: List(Attribute(a))) -> Element(a)

belt_fill

</> 
pub fn belt_fill(attrs: List(Attribute(a))) -> Element(a)

belt_light

</> 
pub fn belt_light(attrs: List(Attribute(a))) -> Element(a)

belt_regular

</> 
pub fn belt_regular(attrs: List(Attribute(a))) -> Element(a)

belt_thin

</> 
pub fn belt_thin(attrs: List(Attribute(a))) -> Element(a)

bezier_curve_bold

</> 
pub fn bezier_curve_bold(attrs: List(Attribute(a))) -> Element(a)

bezier_curve_duotone

</> 
pub fn bezier_curve_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bezier_curve_fill

</> 
pub fn bezier_curve_fill(attrs: List(Attribute(a))) -> Element(a)

bezier_curve_light

</> 
pub fn bezier_curve_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bezier_curve_regular

</> 
pub fn bezier_curve_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bezier_curve_thin

</> 
pub fn bezier_curve_thin(attrs: List(Attribute(a))) -> Element(a)

bicycle_bold

</> 
pub fn bicycle_bold(attrs: List(Attribute(a))) -> Element(a)

bicycle_duotone

</> 
pub fn bicycle_duotone(attrs: List(Attribute(a))) -> Element(a)

bicycle_fill

</> 
pub fn bicycle_fill(attrs: List(Attribute(a))) -> Element(a)

bicycle_light

</> 
pub fn bicycle_light(attrs: List(Attribute(a))) -> Element(a)

bicycle_regular

</> 
pub fn bicycle_regular(attrs: List(Attribute(a))) -> Element(a)

bicycle_thin

</> 
pub fn bicycle_thin(attrs: List(Attribute(a))) -> Element(a)

binary_bold

</> 
pub fn binary_bold(attrs: List(Attribute(a))) -> Element(a)

binary_duotone

</> 
pub fn binary_duotone(attrs: List(Attribute(a))) -> Element(a)

binary_fill

</> 
pub fn binary_fill(attrs: List(Attribute(a))) -> Element(a)

binary_light

</> 
pub fn binary_light(attrs: List(Attribute(a))) -> Element(a)

binary_regular

</> 
pub fn binary_regular(attrs: List(Attribute(a))) -> Element(a)

binary_thin

</> 
pub fn binary_thin(attrs: List(Attribute(a))) -> Element(a)

binoculars_bold

</> 
pub fn binoculars_bold(attrs: List(Attribute(a))) -> Element(a)

binoculars_duotone

</> 
pub fn binoculars_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

binoculars_fill

</> 
pub fn binoculars_fill(attrs: List(Attribute(a))) -> Element(a)

binoculars_light

</> 
pub fn binoculars_light(attrs: List(Attribute(a))) -> Element(a)

binoculars_regular

</> 
pub fn binoculars_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

binoculars_thin

</> 
pub fn binoculars_thin(attrs: List(Attribute(a))) -> Element(a)

biohazard_bold

</> 
pub fn biohazard_bold(attrs: List(Attribute(a))) -> Element(a)

biohazard_duotone

</> 
pub fn biohazard_duotone(attrs: List(Attribute(a))) -> Element(a)

biohazard_fill

</> 
pub fn biohazard_fill(attrs: List(Attribute(a))) -> Element(a)

biohazard_light

</> 
pub fn biohazard_light(attrs: List(Attribute(a))) -> Element(a)

biohazard_regular

</> 
pub fn biohazard_regular(attrs: List(Attribute(a))) -> Element(a)

biohazard_thin

</> 
pub fn biohazard_thin(attrs: List(Attribute(a))) -> Element(a)

bird_bold

</> 
pub fn bird_bold(attrs: List(Attribute(a))) -> Element(a)

bird_duotone

</> 
pub fn bird_duotone(attrs: List(Attribute(a))) -> Element(a)

bird_fill

</> 
pub fn bird_fill(attrs: List(Attribute(a))) -> Element(a)

bird_light

</> 
pub fn bird_light(attrs: List(Attribute(a))) -> Element(a)

bird_regular

</> 
pub fn bird_regular(attrs: List(Attribute(a))) -> Element(a)

bird_thin

</> 
pub fn bird_thin(attrs: List(Attribute(a))) -> Element(a)

blueprint_bold

</> 
pub fn blueprint_bold(attrs: List(Attribute(a))) -> Element(a)

blueprint_duotone

</> 
pub fn blueprint_duotone(attrs: List(Attribute(a))) -> Element(a)

blueprint_fill

</> 
pub fn blueprint_fill(attrs: List(Attribute(a))) -> Element(a)

blueprint_light

</> 
pub fn blueprint_light(attrs: List(Attribute(a))) -> Element(a)

blueprint_regular

</> 
pub fn blueprint_regular(attrs: List(Attribute(a))) -> Element(a)

blueprint_thin

</> 
pub fn blueprint_thin(attrs: List(Attribute(a))) -> Element(a)

bluetooth_bold

</> 
pub fn bluetooth_bold(attrs: List(Attribute(a))) -> Element(a)

bluetooth_connected_bold

</> 
pub fn bluetooth_connected_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_connected_duotone

</> 
pub fn bluetooth_connected_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_connected_fill

</> 
pub fn bluetooth_connected_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_connected_light

</> 
pub fn bluetooth_connected_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_connected_regular

</> 
pub fn bluetooth_connected_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_connected_thin

</> 
pub fn bluetooth_connected_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_duotone

</> 
pub fn bluetooth_duotone(attrs: List(Attribute(a))) -> Element(a)

bluetooth_fill

</> 
pub fn bluetooth_fill(attrs: List(Attribute(a))) -> Element(a)

bluetooth_light

</> 
pub fn bluetooth_light(attrs: List(Attribute(a))) -> Element(a)

bluetooth_regular

</> 
pub fn bluetooth_regular(attrs: List(Attribute(a))) -> Element(a)

bluetooth_slash_bold

</> 
pub fn bluetooth_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_slash_duotone

</> 
pub fn bluetooth_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_slash_fill

</> 
pub fn bluetooth_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_slash_light

</> 
pub fn bluetooth_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_slash_regular

</> 
pub fn bluetooth_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_slash_thin

</> 
pub fn bluetooth_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_thin

</> 
pub fn bluetooth_thin(attrs: List(Attribute(a))) -> Element(a)

bluetooth_x_bold

</> 
pub fn bluetooth_x_bold(attrs: List(Attribute(a))) -> Element(a)

bluetooth_x_duotone

</> 
pub fn bluetooth_x_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_x_fill

</> 
pub fn bluetooth_x_fill(attrs: List(Attribute(a))) -> Element(a)

bluetooth_x_light

</> 
pub fn bluetooth_x_light(attrs: List(Attribute(a))) -> Element(a)

bluetooth_x_regular

</> 
pub fn bluetooth_x_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bluetooth_x_thin

</> 
pub fn bluetooth_x_thin(attrs: List(Attribute(a))) -> Element(a)

boat_bold

</> 
pub fn boat_bold(attrs: List(Attribute(a))) -> Element(a)

boat_duotone

</> 
pub fn boat_duotone(attrs: List(Attribute(a))) -> Element(a)

boat_fill

</> 
pub fn boat_fill(attrs: List(Attribute(a))) -> Element(a)

boat_light

</> 
pub fn boat_light(attrs: List(Attribute(a))) -> Element(a)

boat_regular

</> 
pub fn boat_regular(attrs: List(Attribute(a))) -> Element(a)

boat_thin

</> 
pub fn boat_thin(attrs: List(Attribute(a))) -> Element(a)

bomb_bold

</> 
pub fn bomb_bold(attrs: List(Attribute(a))) -> Element(a)

bomb_duotone

</> 
pub fn bomb_duotone(attrs: List(Attribute(a))) -> Element(a)

bomb_fill

</> 
pub fn bomb_fill(attrs: List(Attribute(a))) -> Element(a)

bomb_light

</> 
pub fn bomb_light(attrs: List(Attribute(a))) -> Element(a)

bomb_regular

</> 
pub fn bomb_regular(attrs: List(Attribute(a))) -> Element(a)

bomb_thin

</> 
pub fn bomb_thin(attrs: List(Attribute(a))) -> Element(a)

bone_bold

</> 
pub fn bone_bold(attrs: List(Attribute(a))) -> Element(a)

bone_duotone

</> 
pub fn bone_duotone(attrs: List(Attribute(a))) -> Element(a)

bone_fill

</> 
pub fn bone_fill(attrs: List(Attribute(a))) -> Element(a)

bone_light

</> 
pub fn bone_light(attrs: List(Attribute(a))) -> Element(a)

bone_regular

</> 
pub fn bone_regular(attrs: List(Attribute(a))) -> Element(a)

bone_thin

</> 
pub fn bone_thin(attrs: List(Attribute(a))) -> Element(a)

book_bold

</> 
pub fn book_bold(attrs: List(Attribute(a))) -> Element(a)

book_bookmark_bold

</> 
pub fn book_bookmark_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

book_bookmark_duotone

</> 
pub fn book_bookmark_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

book_bookmark_fill

</> 
pub fn book_bookmark_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

book_bookmark_light

</> 
pub fn book_bookmark_light(
  attrs: List(Attribute(a)),
) -> Element(a)

book_bookmark_regular

</> 
pub fn book_bookmark_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

book_bookmark_thin

</> 
pub fn book_bookmark_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

book_duotone

</> 
pub fn book_duotone(attrs: List(Attribute(a))) -> Element(a)

book_fill

</> 
pub fn book_fill(attrs: List(Attribute(a))) -> Element(a)

book_light

</> 
pub fn book_light(attrs: List(Attribute(a))) -> Element(a)

book_open_bold

</> 
pub fn book_open_bold(attrs: List(Attribute(a))) -> Element(a)

book_open_duotone

</> 
pub fn book_open_duotone(attrs: List(Attribute(a))) -> Element(a)

book_open_fill

</> 
pub fn book_open_fill(attrs: List(Attribute(a))) -> Element(a)

book_open_light

</> 
pub fn book_open_light(attrs: List(Attribute(a))) -> Element(a)

book_open_regular

</> 
pub fn book_open_regular(attrs: List(Attribute(a))) -> Element(a)

book_open_text_bold

</> 
pub fn book_open_text_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_text_duotone

</> 
pub fn book_open_text_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_text_fill

</> 
pub fn book_open_text_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_text_light

</> 
pub fn book_open_text_light(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_text_regular

</> 
pub fn book_open_text_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_text_thin

</> 
pub fn book_open_text_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_thin

</> 
pub fn book_open_thin(attrs: List(Attribute(a))) -> Element(a)

book_open_user_bold

</> 
pub fn book_open_user_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_user_duotone

</> 
pub fn book_open_user_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_user_fill

</> 
pub fn book_open_user_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_user_light

</> 
pub fn book_open_user_light(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_user_regular

</> 
pub fn book_open_user_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

book_open_user_thin

</> 
pub fn book_open_user_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

book_regular

</> 
pub fn book_regular(attrs: List(Attribute(a))) -> Element(a)

book_thin

</> 
pub fn book_thin(attrs: List(Attribute(a))) -> Element(a)

bookmark_bold

</> 
pub fn bookmark_bold(attrs: List(Attribute(a))) -> Element(a)

bookmark_duotone

</> 
pub fn bookmark_duotone(attrs: List(Attribute(a))) -> Element(a)

bookmark_fill

</> 
pub fn bookmark_fill(attrs: List(Attribute(a))) -> Element(a)

bookmark_light

</> 
pub fn bookmark_light(attrs: List(Attribute(a))) -> Element(a)

bookmark_regular

</> 
pub fn bookmark_regular(attrs: List(Attribute(a))) -> Element(a)

bookmark_simple_bold

</> 
pub fn bookmark_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmark_simple_duotone

</> 
pub fn bookmark_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmark_simple_fill

</> 
pub fn bookmark_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmark_simple_light

</> 
pub fn bookmark_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmark_simple_regular

</> 
pub fn bookmark_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmark_simple_thin

</> 
pub fn bookmark_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmark_thin

</> 
pub fn bookmark_thin(attrs: List(Attribute(a))) -> Element(a)

bookmarks_bold

</> 
pub fn bookmarks_bold(attrs: List(Attribute(a))) -> Element(a)

bookmarks_duotone

</> 
pub fn bookmarks_duotone(attrs: List(Attribute(a))) -> Element(a)

bookmarks_fill

</> 
pub fn bookmarks_fill(attrs: List(Attribute(a))) -> Element(a)

bookmarks_light

</> 
pub fn bookmarks_light(attrs: List(Attribute(a))) -> Element(a)

bookmarks_regular

</> 
pub fn bookmarks_regular(attrs: List(Attribute(a))) -> Element(a)

bookmarks_simple_bold

</> 
pub fn bookmarks_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmarks_simple_duotone

</> 
pub fn bookmarks_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmarks_simple_fill

</> 
pub fn bookmarks_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmarks_simple_light

</> 
pub fn bookmarks_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmarks_simple_regular

</> 
pub fn bookmarks_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmarks_simple_thin

</> 
pub fn bookmarks_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

bookmarks_thin

</> 
pub fn bookmarks_thin(attrs: List(Attribute(a))) -> Element(a)

books_bold

</> 
pub fn books_bold(attrs: List(Attribute(a))) -> Element(a)

books_duotone

</> 
pub fn books_duotone(attrs: List(Attribute(a))) -> Element(a)

books_fill

</> 
pub fn books_fill(attrs: List(Attribute(a))) -> Element(a)

books_light

</> 
pub fn books_light(attrs: List(Attribute(a))) -> Element(a)

books_regular

</> 
pub fn books_regular(attrs: List(Attribute(a))) -> Element(a)

books_thin

</> 
pub fn books_thin(attrs: List(Attribute(a))) -> Element(a)

boot_bold

</> 
pub fn boot_bold(attrs: List(Attribute(a))) -> Element(a)

boot_duotone

</> 
pub fn boot_duotone(attrs: List(Attribute(a))) -> Element(a)

boot_fill

</> 
pub fn boot_fill(attrs: List(Attribute(a))) -> Element(a)

boot_light

</> 
pub fn boot_light(attrs: List(Attribute(a))) -> Element(a)

boot_regular

</> 
pub fn boot_regular(attrs: List(Attribute(a))) -> Element(a)

boot_thin

</> 
pub fn boot_thin(attrs: List(Attribute(a))) -> Element(a)

boules_bold

</> 
pub fn boules_bold(attrs: List(Attribute(a))) -> Element(a)

boules_duotone

</> 
pub fn boules_duotone(attrs: List(Attribute(a))) -> Element(a)

boules_fill

</> 
pub fn boules_fill(attrs: List(Attribute(a))) -> Element(a)

boules_light

</> 
pub fn boules_light(attrs: List(Attribute(a))) -> Element(a)

boules_regular

</> 
pub fn boules_regular(attrs: List(Attribute(a))) -> Element(a)

boules_thin

</> 
pub fn boules_thin(attrs: List(Attribute(a))) -> Element(a)

bounding_box_bold

</> 
pub fn bounding_box_bold(attrs: List(Attribute(a))) -> Element(a)

bounding_box_duotone

</> 
pub fn bounding_box_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bounding_box_fill

</> 
pub fn bounding_box_fill(attrs: List(Attribute(a))) -> Element(a)

bounding_box_light

</> 
pub fn bounding_box_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bounding_box_regular

</> 
pub fn bounding_box_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bounding_box_thin

</> 
pub fn bounding_box_thin(attrs: List(Attribute(a))) -> Element(a)

bowl_food_bold

</> 
pub fn bowl_food_bold(attrs: List(Attribute(a))) -> Element(a)

bowl_food_duotone

</> 
pub fn bowl_food_duotone(attrs: List(Attribute(a))) -> Element(a)

bowl_food_fill

</> 
pub fn bowl_food_fill(attrs: List(Attribute(a))) -> Element(a)

bowl_food_light

</> 
pub fn bowl_food_light(attrs: List(Attribute(a))) -> Element(a)

bowl_food_regular

</> 
pub fn bowl_food_regular(attrs: List(Attribute(a))) -> Element(a)

bowl_food_thin

</> 
pub fn bowl_food_thin(attrs: List(Attribute(a))) -> Element(a)

bowl_steam_bold

</> 
pub fn bowl_steam_bold(attrs: List(Attribute(a))) -> Element(a)

bowl_steam_duotone

</> 
pub fn bowl_steam_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bowl_steam_fill

</> 
pub fn bowl_steam_fill(attrs: List(Attribute(a))) -> Element(a)

bowl_steam_light

</> 
pub fn bowl_steam_light(attrs: List(Attribute(a))) -> Element(a)

bowl_steam_regular

</> 
pub fn bowl_steam_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bowl_steam_thin

</> 
pub fn bowl_steam_thin(attrs: List(Attribute(a))) -> Element(a)

bowling_ball_bold

</> 
pub fn bowling_ball_bold(attrs: List(Attribute(a))) -> Element(a)

bowling_ball_duotone

</> 
pub fn bowling_ball_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bowling_ball_fill

</> 
pub fn bowling_ball_fill(attrs: List(Attribute(a))) -> Element(a)

bowling_ball_light

</> 
pub fn bowling_ball_light(
  attrs: List(Attribute(a)),
) -> Element(a)

bowling_ball_regular

</> 
pub fn bowling_ball_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bowling_ball_thin

</> 
pub fn bowling_ball_thin(attrs: List(Attribute(a))) -> Element(a)

box_arrow_down_bold

</> 
pub fn box_arrow_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

box_arrow_down_duotone

</> 
pub fn box_arrow_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

box_arrow_down_fill

</> 
pub fn box_arrow_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

box_arrow_down_light

</> 
pub fn box_arrow_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

box_arrow_down_regular

</> 
pub fn box_arrow_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

box_arrow_down_thin

</> 
pub fn box_arrow_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

box_arrow_up_bold

</> 
pub fn box_arrow_up_bold(attrs: List(Attribute(a))) -> Element(a)

box_arrow_up_duotone

</> 
pub fn box_arrow_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

box_arrow_up_fill

</> 
pub fn box_arrow_up_fill(attrs: List(Attribute(a))) -> Element(a)

box_arrow_up_light

</> 
pub fn box_arrow_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

box_arrow_up_regular

</> 
pub fn box_arrow_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

box_arrow_up_thin

</> 
pub fn box_arrow_up_thin(attrs: List(Attribute(a))) -> Element(a)

boxing_glove_bold

</> 
pub fn boxing_glove_bold(attrs: List(Attribute(a))) -> Element(a)

boxing_glove_duotone

</> 
pub fn boxing_glove_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

boxing_glove_fill

</> 
pub fn boxing_glove_fill(attrs: List(Attribute(a))) -> Element(a)

boxing_glove_light

</> 
pub fn boxing_glove_light(
  attrs: List(Attribute(a)),
) -> Element(a)

boxing_glove_regular

</> 
pub fn boxing_glove_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

boxing_glove_thin

</> 
pub fn boxing_glove_thin(attrs: List(Attribute(a))) -> Element(a)

brackets_angle_bold

</> 
pub fn brackets_angle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_angle_duotone

</> 
pub fn brackets_angle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_angle_fill

</> 
pub fn brackets_angle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_angle_light

</> 
pub fn brackets_angle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_angle_regular

</> 
pub fn brackets_angle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_angle_thin

</> 
pub fn brackets_angle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_curly_bold

</> 
pub fn brackets_curly_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_curly_duotone

</> 
pub fn brackets_curly_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_curly_fill

</> 
pub fn brackets_curly_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_curly_light

</> 
pub fn brackets_curly_light(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_curly_regular

</> 
pub fn brackets_curly_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_curly_thin

</> 
pub fn brackets_curly_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_round_bold

</> 
pub fn brackets_round_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_round_duotone

</> 
pub fn brackets_round_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_round_fill

</> 
pub fn brackets_round_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_round_light

</> 
pub fn brackets_round_light(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_round_regular

</> 
pub fn brackets_round_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_round_thin

</> 
pub fn brackets_round_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_square_bold

</> 
pub fn brackets_square_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_square_duotone

</> 
pub fn brackets_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_square_fill

</> 
pub fn brackets_square_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_square_light

</> 
pub fn brackets_square_light(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_square_regular

</> 
pub fn brackets_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

brackets_square_thin

</> 
pub fn brackets_square_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

brain_bold

</> 
pub fn brain_bold(attrs: List(Attribute(a))) -> Element(a)

brain_duotone

</> 
pub fn brain_duotone(attrs: List(Attribute(a))) -> Element(a)

brain_fill

</> 
pub fn brain_fill(attrs: List(Attribute(a))) -> Element(a)

brain_light

</> 
pub fn brain_light(attrs: List(Attribute(a))) -> Element(a)

brain_regular

</> 
pub fn brain_regular(attrs: List(Attribute(a))) -> Element(a)

brain_thin

</> 
pub fn brain_thin(attrs: List(Attribute(a))) -> Element(a)

brandy_bold

</> 
pub fn brandy_bold(attrs: List(Attribute(a))) -> Element(a)

brandy_duotone

</> 
pub fn brandy_duotone(attrs: List(Attribute(a))) -> Element(a)

brandy_fill

</> 
pub fn brandy_fill(attrs: List(Attribute(a))) -> Element(a)

brandy_light

</> 
pub fn brandy_light(attrs: List(Attribute(a))) -> Element(a)

brandy_regular

</> 
pub fn brandy_regular(attrs: List(Attribute(a))) -> Element(a)

brandy_thin

</> 
pub fn brandy_thin(attrs: List(Attribute(a))) -> Element(a)

bread_bold

</> 
pub fn bread_bold(attrs: List(Attribute(a))) -> Element(a)

bread_duotone

</> 
pub fn bread_duotone(attrs: List(Attribute(a))) -> Element(a)

bread_fill

</> 
pub fn bread_fill(attrs: List(Attribute(a))) -> Element(a)

bread_light

</> 
pub fn bread_light(attrs: List(Attribute(a))) -> Element(a)

bread_regular

</> 
pub fn bread_regular(attrs: List(Attribute(a))) -> Element(a)

bread_thin

</> 
pub fn bread_thin(attrs: List(Attribute(a))) -> Element(a)

bridge_bold

</> 
pub fn bridge_bold(attrs: List(Attribute(a))) -> Element(a)

bridge_duotone

</> 
pub fn bridge_duotone(attrs: List(Attribute(a))) -> Element(a)

bridge_fill

</> 
pub fn bridge_fill(attrs: List(Attribute(a))) -> Element(a)

bridge_light

</> 
pub fn bridge_light(attrs: List(Attribute(a))) -> Element(a)

bridge_regular

</> 
pub fn bridge_regular(attrs: List(Attribute(a))) -> Element(a)

bridge_thin

</> 
pub fn bridge_thin(attrs: List(Attribute(a))) -> Element(a)

briefcase_bold

</> 
pub fn briefcase_bold(attrs: List(Attribute(a))) -> Element(a)

briefcase_duotone

</> 
pub fn briefcase_duotone(attrs: List(Attribute(a))) -> Element(a)

briefcase_fill

</> 
pub fn briefcase_fill(attrs: List(Attribute(a))) -> Element(a)

briefcase_light

</> 
pub fn briefcase_light(attrs: List(Attribute(a))) -> Element(a)

briefcase_metal_bold

</> 
pub fn briefcase_metal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

briefcase_metal_duotone

</> 
pub fn briefcase_metal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

briefcase_metal_fill

</> 
pub fn briefcase_metal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

briefcase_metal_light

</> 
pub fn briefcase_metal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

briefcase_metal_regular

</> 
pub fn briefcase_metal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

briefcase_metal_thin

</> 
pub fn briefcase_metal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

briefcase_regular

</> 
pub fn briefcase_regular(attrs: List(Attribute(a))) -> Element(a)

briefcase_thin

</> 
pub fn briefcase_thin(attrs: List(Attribute(a))) -> Element(a)

broadcast_bold

</> 
pub fn broadcast_bold(attrs: List(Attribute(a))) -> Element(a)

broadcast_duotone

</> 
pub fn broadcast_duotone(attrs: List(Attribute(a))) -> Element(a)

broadcast_fill

</> 
pub fn broadcast_fill(attrs: List(Attribute(a))) -> Element(a)

broadcast_light

</> 
pub fn broadcast_light(attrs: List(Attribute(a))) -> Element(a)

broadcast_regular

</> 
pub fn broadcast_regular(attrs: List(Attribute(a))) -> Element(a)

broadcast_thin

</> 
pub fn broadcast_thin(attrs: List(Attribute(a))) -> Element(a)

broom_bold

</> 
pub fn broom_bold(attrs: List(Attribute(a))) -> Element(a)

broom_duotone

</> 
pub fn broom_duotone(attrs: List(Attribute(a))) -> Element(a)

broom_fill

</> 
pub fn broom_fill(attrs: List(Attribute(a))) -> Element(a)

broom_light

</> 
pub fn broom_light(attrs: List(Attribute(a))) -> Element(a)

broom_regular

</> 
pub fn broom_regular(attrs: List(Attribute(a))) -> Element(a)

broom_thin

</> 
pub fn broom_thin(attrs: List(Attribute(a))) -> Element(a)

browser_bold

</> 
pub fn browser_bold(attrs: List(Attribute(a))) -> Element(a)

browser_duotone

</> 
pub fn browser_duotone(attrs: List(Attribute(a))) -> Element(a)

browser_fill

</> 
pub fn browser_fill(attrs: List(Attribute(a))) -> Element(a)

browser_light

</> 
pub fn browser_light(attrs: List(Attribute(a))) -> Element(a)

browser_regular

</> 
pub fn browser_regular(attrs: List(Attribute(a))) -> Element(a)

browser_thin

</> 
pub fn browser_thin(attrs: List(Attribute(a))) -> Element(a)

browsers_bold

</> 
pub fn browsers_bold(attrs: List(Attribute(a))) -> Element(a)

browsers_duotone

</> 
pub fn browsers_duotone(attrs: List(Attribute(a))) -> Element(a)

browsers_fill

</> 
pub fn browsers_fill(attrs: List(Attribute(a))) -> Element(a)

browsers_light

</> 
pub fn browsers_light(attrs: List(Attribute(a))) -> Element(a)

browsers_regular

</> 
pub fn browsers_regular(attrs: List(Attribute(a))) -> Element(a)

browsers_thin

</> 
pub fn browsers_thin(attrs: List(Attribute(a))) -> Element(a)

bug_beetle_bold

</> 
pub fn bug_beetle_bold(attrs: List(Attribute(a))) -> Element(a)

bug_beetle_duotone

</> 
pub fn bug_beetle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

bug_beetle_fill

</> 
pub fn bug_beetle_fill(attrs: List(Attribute(a))) -> Element(a)

bug_beetle_light

</> 
pub fn bug_beetle_light(attrs: List(Attribute(a))) -> Element(a)

bug_beetle_regular

</> 
pub fn bug_beetle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

bug_beetle_thin

</> 
pub fn bug_beetle_thin(attrs: List(Attribute(a))) -> Element(a)

bug_bold

</> 
pub fn bug_bold(attrs: List(Attribute(a))) -> Element(a)

bug_droid_bold

</> 
pub fn bug_droid_bold(attrs: List(Attribute(a))) -> Element(a)

bug_droid_duotone

</> 
pub fn bug_droid_duotone(attrs: List(Attribute(a))) -> Element(a)

bug_droid_fill

</> 
pub fn bug_droid_fill(attrs: List(Attribute(a))) -> Element(a)

bug_droid_light

</> 
pub fn bug_droid_light(attrs: List(Attribute(a))) -> Element(a)

bug_droid_regular

</> 
pub fn bug_droid_regular(attrs: List(Attribute(a))) -> Element(a)

bug_droid_thin

</> 
pub fn bug_droid_thin(attrs: List(Attribute(a))) -> Element(a)

bug_duotone

</> 
pub fn bug_duotone(attrs: List(Attribute(a))) -> Element(a)

bug_fill

</> 
pub fn bug_fill(attrs: List(Attribute(a))) -> Element(a)

bug_light

</> 
pub fn bug_light(attrs: List(Attribute(a))) -> Element(a)

bug_regular

</> 
pub fn bug_regular(attrs: List(Attribute(a))) -> Element(a)

bug_thin

</> 
pub fn bug_thin(attrs: List(Attribute(a))) -> Element(a)

building_apartment_bold

</> 
pub fn building_apartment_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

building_apartment_duotone

</> 
pub fn building_apartment_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

building_apartment_fill

</> 
pub fn building_apartment_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

building_apartment_light

</> 
pub fn building_apartment_light(
  attrs: List(Attribute(a)),
) -> Element(a)

building_apartment_regular

</> 
pub fn building_apartment_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

building_apartment_thin

</> 
pub fn building_apartment_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

building_bold

</> 
pub fn building_bold(attrs: List(Attribute(a))) -> Element(a)

building_duotone

</> 
pub fn building_duotone(attrs: List(Attribute(a))) -> Element(a)

building_fill

</> 
pub fn building_fill(attrs: List(Attribute(a))) -> Element(a)

building_light

</> 
pub fn building_light(attrs: List(Attribute(a))) -> Element(a)

building_office_bold

</> 
pub fn building_office_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

building_office_duotone

</> 
pub fn building_office_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

building_office_fill

</> 
pub fn building_office_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

building_office_light

</> 
pub fn building_office_light(
  attrs: List(Attribute(a)),
) -> Element(a)

building_office_regular

</> 
pub fn building_office_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

building_office_thin

</> 
pub fn building_office_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

building_regular

</> 
pub fn building_regular(attrs: List(Attribute(a))) -> Element(a)

building_thin

</> 
pub fn building_thin(attrs: List(Attribute(a))) -> Element(a)

buildings_bold

</> 
pub fn buildings_bold(attrs: List(Attribute(a))) -> Element(a)

buildings_duotone

</> 
pub fn buildings_duotone(attrs: List(Attribute(a))) -> Element(a)

buildings_fill

</> 
pub fn buildings_fill(attrs: List(Attribute(a))) -> Element(a)

buildings_light

</> 
pub fn buildings_light(attrs: List(Attribute(a))) -> Element(a)

buildings_regular

</> 
pub fn buildings_regular(attrs: List(Attribute(a))) -> Element(a)

buildings_thin

</> 
pub fn buildings_thin(attrs: List(Attribute(a))) -> Element(a)

bulldozer_bold

</> 
pub fn bulldozer_bold(attrs: List(Attribute(a))) -> Element(a)

bulldozer_duotone

</> 
pub fn bulldozer_duotone(attrs: List(Attribute(a))) -> Element(a)

bulldozer_fill

</> 
pub fn bulldozer_fill(attrs: List(Attribute(a))) -> Element(a)

bulldozer_light

</> 
pub fn bulldozer_light(attrs: List(Attribute(a))) -> Element(a)

bulldozer_regular

</> 
pub fn bulldozer_regular(attrs: List(Attribute(a))) -> Element(a)

bulldozer_thin

</> 
pub fn bulldozer_thin(attrs: List(Attribute(a))) -> Element(a)

bus_bold

</> 
pub fn bus_bold(attrs: List(Attribute(a))) -> Element(a)

bus_duotone

</> 
pub fn bus_duotone(attrs: List(Attribute(a))) -> Element(a)

bus_fill

</> 
pub fn bus_fill(attrs: List(Attribute(a))) -> Element(a)

bus_light

</> 
pub fn bus_light(attrs: List(Attribute(a))) -> Element(a)

bus_regular

</> 
pub fn bus_regular(attrs: List(Attribute(a))) -> Element(a)

bus_thin

</> 
pub fn bus_thin(attrs: List(Attribute(a))) -> Element(a)

butterfly_bold

</> 
pub fn butterfly_bold(attrs: List(Attribute(a))) -> Element(a)

butterfly_duotone

</> 
pub fn butterfly_duotone(attrs: List(Attribute(a))) -> Element(a)

butterfly_fill

</> 
pub fn butterfly_fill(attrs: List(Attribute(a))) -> Element(a)

butterfly_light

</> 
pub fn butterfly_light(attrs: List(Attribute(a))) -> Element(a)

butterfly_regular

</> 
pub fn butterfly_regular(attrs: List(Attribute(a))) -> Element(a)

butterfly_thin

</> 
pub fn butterfly_thin(attrs: List(Attribute(a))) -> Element(a)

cable_car_bold

</> 
pub fn cable_car_bold(attrs: List(Attribute(a))) -> Element(a)

cable_car_duotone

</> 
pub fn cable_car_duotone(attrs: List(Attribute(a))) -> Element(a)

cable_car_fill

</> 
pub fn cable_car_fill(attrs: List(Attribute(a))) -> Element(a)

cable_car_light

</> 
pub fn cable_car_light(attrs: List(Attribute(a))) -> Element(a)

cable_car_regular

</> 
pub fn cable_car_regular(attrs: List(Attribute(a))) -> Element(a)

cable_car_thin

</> 
pub fn cable_car_thin(attrs: List(Attribute(a))) -> Element(a)

cactus_bold

</> 
pub fn cactus_bold(attrs: List(Attribute(a))) -> Element(a)

cactus_duotone

</> 
pub fn cactus_duotone(attrs: List(Attribute(a))) -> Element(a)

cactus_fill

</> 
pub fn cactus_fill(attrs: List(Attribute(a))) -> Element(a)

cactus_light

</> 
pub fn cactus_light(attrs: List(Attribute(a))) -> Element(a)

cactus_regular

</> 
pub fn cactus_regular(attrs: List(Attribute(a))) -> Element(a)

cactus_thin

</> 
pub fn cactus_thin(attrs: List(Attribute(a))) -> Element(a)

cake_bold

</> 
pub fn cake_bold(attrs: List(Attribute(a))) -> Element(a)

cake_duotone

</> 
pub fn cake_duotone(attrs: List(Attribute(a))) -> Element(a)

cake_fill

</> 
pub fn cake_fill(attrs: List(Attribute(a))) -> Element(a)

cake_light

</> 
pub fn cake_light(attrs: List(Attribute(a))) -> Element(a)

cake_regular

</> 
pub fn cake_regular(attrs: List(Attribute(a))) -> Element(a)

cake_thin

</> 
pub fn cake_thin(attrs: List(Attribute(a))) -> Element(a)

calculator_bold

</> 
pub fn calculator_bold(attrs: List(Attribute(a))) -> Element(a)

calculator_duotone

</> 
pub fn calculator_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calculator_fill

</> 
pub fn calculator_fill(attrs: List(Attribute(a))) -> Element(a)

calculator_light

</> 
pub fn calculator_light(attrs: List(Attribute(a))) -> Element(a)

calculator_regular

</> 
pub fn calculator_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calculator_thin

</> 
pub fn calculator_thin(attrs: List(Attribute(a))) -> Element(a)

calendar_blank_bold

</> 
pub fn calendar_blank_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_blank_duotone

</> 
pub fn calendar_blank_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_blank_fill

</> 
pub fn calendar_blank_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_blank_light

</> 
pub fn calendar_blank_light(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_blank_regular

</> 
pub fn calendar_blank_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_blank_thin

</> 
pub fn calendar_blank_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_bold

</> 
pub fn calendar_bold(attrs: List(Attribute(a))) -> Element(a)

calendar_check_bold

</> 
pub fn calendar_check_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_check_duotone

</> 
pub fn calendar_check_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_check_fill

</> 
pub fn calendar_check_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_check_light

</> 
pub fn calendar_check_light(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_check_regular

</> 
pub fn calendar_check_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_check_thin

</> 
pub fn calendar_check_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_dot_bold

</> 
pub fn calendar_dot_bold(attrs: List(Attribute(a))) -> Element(a)

calendar_dot_duotone

</> 
pub fn calendar_dot_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_dot_fill

</> 
pub fn calendar_dot_fill(attrs: List(Attribute(a))) -> Element(a)

calendar_dot_light

</> 
pub fn calendar_dot_light(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_dot_regular

</> 
pub fn calendar_dot_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_dot_thin

</> 
pub fn calendar_dot_thin(attrs: List(Attribute(a))) -> Element(a)

calendar_dots_bold

</> 
pub fn calendar_dots_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_dots_duotone

</> 
pub fn calendar_dots_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_dots_fill

</> 
pub fn calendar_dots_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_dots_light

</> 
pub fn calendar_dots_light(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_dots_regular

</> 
pub fn calendar_dots_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_dots_thin

</> 
pub fn calendar_dots_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_duotone

</> 
pub fn calendar_duotone(attrs: List(Attribute(a))) -> Element(a)

calendar_fill

</> 
pub fn calendar_fill(attrs: List(Attribute(a))) -> Element(a)

calendar_heart_bold

</> 
pub fn calendar_heart_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_heart_duotone

</> 
pub fn calendar_heart_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_heart_fill

</> 
pub fn calendar_heart_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_heart_light

</> 
pub fn calendar_heart_light(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_heart_regular

</> 
pub fn calendar_heart_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_heart_thin

</> 
pub fn calendar_heart_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_light

</> 
pub fn calendar_light(attrs: List(Attribute(a))) -> Element(a)

calendar_minus_bold

</> 
pub fn calendar_minus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_minus_duotone

</> 
pub fn calendar_minus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_minus_fill

</> 
pub fn calendar_minus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_minus_light

</> 
pub fn calendar_minus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_minus_regular

</> 
pub fn calendar_minus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_minus_thin

</> 
pub fn calendar_minus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_plus_bold

</> 
pub fn calendar_plus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_plus_duotone

</> 
pub fn calendar_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_plus_fill

</> 
pub fn calendar_plus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_plus_light

</> 
pub fn calendar_plus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_plus_regular

</> 
pub fn calendar_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_plus_thin

</> 
pub fn calendar_plus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_regular

</> 
pub fn calendar_regular(attrs: List(Attribute(a))) -> Element(a)

calendar_slash_bold

</> 
pub fn calendar_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_slash_duotone

</> 
pub fn calendar_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_slash_fill

</> 
pub fn calendar_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_slash_light

</> 
pub fn calendar_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_slash_regular

</> 
pub fn calendar_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_slash_thin

</> 
pub fn calendar_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_star_bold

</> 
pub fn calendar_star_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_star_duotone

</> 
pub fn calendar_star_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_star_fill

</> 
pub fn calendar_star_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_star_light

</> 
pub fn calendar_star_light(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_star_regular

</> 
pub fn calendar_star_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_star_thin

</> 
pub fn calendar_star_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_thin

</> 
pub fn calendar_thin(attrs: List(Attribute(a))) -> Element(a)

calendar_x_bold

</> 
pub fn calendar_x_bold(attrs: List(Attribute(a))) -> Element(a)

calendar_x_duotone

</> 
pub fn calendar_x_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_x_fill

</> 
pub fn calendar_x_fill(attrs: List(Attribute(a))) -> Element(a)

calendar_x_light

</> 
pub fn calendar_x_light(attrs: List(Attribute(a))) -> Element(a)

calendar_x_regular

</> 
pub fn calendar_x_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

calendar_x_thin

</> 
pub fn calendar_x_thin(attrs: List(Attribute(a))) -> Element(a)

call_bell_bold

</> 
pub fn call_bell_bold(attrs: List(Attribute(a))) -> Element(a)

call_bell_duotone

</> 
pub fn call_bell_duotone(attrs: List(Attribute(a))) -> Element(a)

call_bell_fill

</> 
pub fn call_bell_fill(attrs: List(Attribute(a))) -> Element(a)

call_bell_light

</> 
pub fn call_bell_light(attrs: List(Attribute(a))) -> Element(a)

call_bell_regular

</> 
pub fn call_bell_regular(attrs: List(Attribute(a))) -> Element(a)

call_bell_thin

</> 
pub fn call_bell_thin(attrs: List(Attribute(a))) -> Element(a)

camera_bold

</> 
pub fn camera_bold(attrs: List(Attribute(a))) -> Element(a)

camera_duotone

</> 
pub fn camera_duotone(attrs: List(Attribute(a))) -> Element(a)

camera_fill

</> 
pub fn camera_fill(attrs: List(Attribute(a))) -> Element(a)

camera_light

</> 
pub fn camera_light(attrs: List(Attribute(a))) -> Element(a)

camera_plus_bold

</> 
pub fn camera_plus_bold(attrs: List(Attribute(a))) -> Element(a)

camera_plus_duotone

</> 
pub fn camera_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_plus_fill

</> 
pub fn camera_plus_fill(attrs: List(Attribute(a))) -> Element(a)

camera_plus_light

</> 
pub fn camera_plus_light(attrs: List(Attribute(a))) -> Element(a)

camera_plus_regular

</> 
pub fn camera_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_plus_thin

</> 
pub fn camera_plus_thin(attrs: List(Attribute(a))) -> Element(a)

camera_regular

</> 
pub fn camera_regular(attrs: List(Attribute(a))) -> Element(a)

camera_rotate_bold

</> 
pub fn camera_rotate_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_rotate_duotone

</> 
pub fn camera_rotate_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_rotate_fill

</> 
pub fn camera_rotate_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_rotate_light

</> 
pub fn camera_rotate_light(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_rotate_regular

</> 
pub fn camera_rotate_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_rotate_thin

</> 
pub fn camera_rotate_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_slash_bold

</> 
pub fn camera_slash_bold(attrs: List(Attribute(a))) -> Element(a)

camera_slash_duotone

</> 
pub fn camera_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_slash_fill

</> 
pub fn camera_slash_fill(attrs: List(Attribute(a))) -> Element(a)

camera_slash_light

</> 
pub fn camera_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_slash_regular

</> 
pub fn camera_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

camera_slash_thin

</> 
pub fn camera_slash_thin(attrs: List(Attribute(a))) -> Element(a)

camera_thin

</> 
pub fn camera_thin(attrs: List(Attribute(a))) -> Element(a)

campfire_bold

</> 
pub fn campfire_bold(attrs: List(Attribute(a))) -> Element(a)

campfire_duotone

</> 
pub fn campfire_duotone(attrs: List(Attribute(a))) -> Element(a)

campfire_fill

</> 
pub fn campfire_fill(attrs: List(Attribute(a))) -> Element(a)

campfire_light

</> 
pub fn campfire_light(attrs: List(Attribute(a))) -> Element(a)

campfire_regular

</> 
pub fn campfire_regular(attrs: List(Attribute(a))) -> Element(a)

campfire_thin

</> 
pub fn campfire_thin(attrs: List(Attribute(a))) -> Element(a)

car_battery_bold

</> 
pub fn car_battery_bold(attrs: List(Attribute(a))) -> Element(a)

car_battery_duotone

</> 
pub fn car_battery_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

car_battery_fill

</> 
pub fn car_battery_fill(attrs: List(Attribute(a))) -> Element(a)

car_battery_light

</> 
pub fn car_battery_light(attrs: List(Attribute(a))) -> Element(a)

car_battery_regular

</> 
pub fn car_battery_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

car_battery_thin

</> 
pub fn car_battery_thin(attrs: List(Attribute(a))) -> Element(a)

car_bold

</> 
pub fn car_bold(attrs: List(Attribute(a))) -> Element(a)

car_duotone

</> 
pub fn car_duotone(attrs: List(Attribute(a))) -> Element(a)

car_fill

</> 
pub fn car_fill(attrs: List(Attribute(a))) -> Element(a)

car_light

</> 
pub fn car_light(attrs: List(Attribute(a))) -> Element(a)

car_profile_bold

</> 
pub fn car_profile_bold(attrs: List(Attribute(a))) -> Element(a)

car_profile_duotone

</> 
pub fn car_profile_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

car_profile_fill

</> 
pub fn car_profile_fill(attrs: List(Attribute(a))) -> Element(a)

car_profile_light

</> 
pub fn car_profile_light(attrs: List(Attribute(a))) -> Element(a)

car_profile_regular

</> 
pub fn car_profile_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

car_profile_thin

</> 
pub fn car_profile_thin(attrs: List(Attribute(a))) -> Element(a)

car_regular

</> 
pub fn car_regular(attrs: List(Attribute(a))) -> Element(a)

car_simple_bold

</> 
pub fn car_simple_bold(attrs: List(Attribute(a))) -> Element(a)

car_simple_duotone

</> 
pub fn car_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

car_simple_fill

</> 
pub fn car_simple_fill(attrs: List(Attribute(a))) -> Element(a)

car_simple_light

</> 
pub fn car_simple_light(attrs: List(Attribute(a))) -> Element(a)

car_simple_regular

</> 
pub fn car_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

car_simple_thin

</> 
pub fn car_simple_thin(attrs: List(Attribute(a))) -> Element(a)

car_thin

</> 
pub fn car_thin(attrs: List(Attribute(a))) -> Element(a)

cardholder_bold

</> 
pub fn cardholder_bold(attrs: List(Attribute(a))) -> Element(a)

cardholder_duotone

</> 
pub fn cardholder_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cardholder_fill

</> 
pub fn cardholder_fill(attrs: List(Attribute(a))) -> Element(a)

cardholder_light

</> 
pub fn cardholder_light(attrs: List(Attribute(a))) -> Element(a)

cardholder_regular

</> 
pub fn cardholder_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cardholder_thin

</> 
pub fn cardholder_thin(attrs: List(Attribute(a))) -> Element(a)

cards_bold

</> 
pub fn cards_bold(attrs: List(Attribute(a))) -> Element(a)

cards_duotone

</> 
pub fn cards_duotone(attrs: List(Attribute(a))) -> Element(a)

cards_fill

</> 
pub fn cards_fill(attrs: List(Attribute(a))) -> Element(a)

cards_light

</> 
pub fn cards_light(attrs: List(Attribute(a))) -> Element(a)

cards_regular

</> 
pub fn cards_regular(attrs: List(Attribute(a))) -> Element(a)

cards_thin

</> 
pub fn cards_thin(attrs: List(Attribute(a))) -> Element(a)

cards_three_bold

</> 
pub fn cards_three_bold(attrs: List(Attribute(a))) -> Element(a)

cards_three_duotone

</> 
pub fn cards_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cards_three_fill

</> 
pub fn cards_three_fill(attrs: List(Attribute(a))) -> Element(a)

cards_three_light

</> 
pub fn cards_three_light(attrs: List(Attribute(a))) -> Element(a)

cards_three_regular

</> 
pub fn cards_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cards_three_thin

</> 
pub fn cards_three_thin(attrs: List(Attribute(a))) -> Element(a)

caret_circle_double_down_bold

</> 
pub fn caret_circle_double_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_down_duotone

</> 
pub fn caret_circle_double_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_down_fill

</> 
pub fn caret_circle_double_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_down_light

</> 
pub fn caret_circle_double_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_down_regular

</> 
pub fn caret_circle_double_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_down_thin

</> 
pub fn caret_circle_double_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_left_bold

</> 
pub fn caret_circle_double_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_left_duotone

</> 
pub fn caret_circle_double_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_left_fill

</> 
pub fn caret_circle_double_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_left_light

</> 
pub fn caret_circle_double_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_left_regular

</> 
pub fn caret_circle_double_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_left_thin

</> 
pub fn caret_circle_double_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_right_bold

</> 
pub fn caret_circle_double_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_right_duotone

</> 
pub fn caret_circle_double_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_right_fill

</> 
pub fn caret_circle_double_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_right_light

</> 
pub fn caret_circle_double_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_right_regular

</> 
pub fn caret_circle_double_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_right_thin

</> 
pub fn caret_circle_double_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_up_bold

</> 
pub fn caret_circle_double_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_up_duotone

</> 
pub fn caret_circle_double_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_up_fill

</> 
pub fn caret_circle_double_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_up_light

</> 
pub fn caret_circle_double_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_up_regular

</> 
pub fn caret_circle_double_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_double_up_thin

</> 
pub fn caret_circle_double_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_down_bold

</> 
pub fn caret_circle_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_down_duotone

</> 
pub fn caret_circle_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_down_fill

</> 
pub fn caret_circle_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_down_light

</> 
pub fn caret_circle_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_down_regular

</> 
pub fn caret_circle_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_down_thin

</> 
pub fn caret_circle_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_left_bold

</> 
pub fn caret_circle_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_left_duotone

</> 
pub fn caret_circle_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_left_fill

</> 
pub fn caret_circle_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_left_light

</> 
pub fn caret_circle_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_left_regular

</> 
pub fn caret_circle_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_left_thin

</> 
pub fn caret_circle_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_right_bold

</> 
pub fn caret_circle_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_right_duotone

</> 
pub fn caret_circle_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_right_fill

</> 
pub fn caret_circle_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_right_light

</> 
pub fn caret_circle_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_right_regular

</> 
pub fn caret_circle_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_right_thin

</> 
pub fn caret_circle_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_bold

</> 
pub fn caret_circle_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_down_bold

</> 
pub fn caret_circle_up_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_down_duotone

</> 
pub fn caret_circle_up_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_down_fill

</> 
pub fn caret_circle_up_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_down_light

</> 
pub fn caret_circle_up_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_down_regular

</> 
pub fn caret_circle_up_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_down_thin

</> 
pub fn caret_circle_up_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_duotone

</> 
pub fn caret_circle_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_fill

</> 
pub fn caret_circle_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_light

</> 
pub fn caret_circle_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_regular

</> 
pub fn caret_circle_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_circle_up_thin

</> 
pub fn caret_circle_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_down_bold

</> 
pub fn caret_double_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_down_duotone

</> 
pub fn caret_double_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_down_fill

</> 
pub fn caret_double_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_down_light

</> 
pub fn caret_double_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_down_regular

</> 
pub fn caret_double_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_down_thin

</> 
pub fn caret_double_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_left_bold

</> 
pub fn caret_double_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_left_duotone

</> 
pub fn caret_double_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_left_fill

</> 
pub fn caret_double_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_left_light

</> 
pub fn caret_double_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_left_regular

</> 
pub fn caret_double_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_left_thin

</> 
pub fn caret_double_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_right_bold

</> 
pub fn caret_double_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_right_duotone

</> 
pub fn caret_double_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_right_fill

</> 
pub fn caret_double_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_right_light

</> 
pub fn caret_double_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_right_regular

</> 
pub fn caret_double_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_right_thin

</> 
pub fn caret_double_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_up_bold

</> 
pub fn caret_double_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_up_duotone

</> 
pub fn caret_double_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_up_fill

</> 
pub fn caret_double_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_up_light

</> 
pub fn caret_double_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_up_regular

</> 
pub fn caret_double_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_double_up_thin

</> 
pub fn caret_double_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_down_bold

</> 
pub fn caret_down_bold(attrs: List(Attribute(a))) -> Element(a)

caret_down_duotone

</> 
pub fn caret_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_down_fill

</> 
pub fn caret_down_fill(attrs: List(Attribute(a))) -> Element(a)

caret_down_light

</> 
pub fn caret_down_light(attrs: List(Attribute(a))) -> Element(a)

caret_down_regular

</> 
pub fn caret_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_down_thin

</> 
pub fn caret_down_thin(attrs: List(Attribute(a))) -> Element(a)

caret_left_bold

</> 
pub fn caret_left_bold(attrs: List(Attribute(a))) -> Element(a)

caret_left_duotone

</> 
pub fn caret_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_left_fill

</> 
pub fn caret_left_fill(attrs: List(Attribute(a))) -> Element(a)

caret_left_light

</> 
pub fn caret_left_light(attrs: List(Attribute(a))) -> Element(a)

caret_left_regular

</> 
pub fn caret_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_left_thin

</> 
pub fn caret_left_thin(attrs: List(Attribute(a))) -> Element(a)

caret_line_down_bold

</> 
pub fn caret_line_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_down_duotone

</> 
pub fn caret_line_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_down_fill

</> 
pub fn caret_line_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_down_light

</> 
pub fn caret_line_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_down_regular

</> 
pub fn caret_line_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_down_thin

</> 
pub fn caret_line_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_left_bold

</> 
pub fn caret_line_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_left_duotone

</> 
pub fn caret_line_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_left_fill

</> 
pub fn caret_line_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_left_light

</> 
pub fn caret_line_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_left_regular

</> 
pub fn caret_line_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_left_thin

</> 
pub fn caret_line_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_right_bold

</> 
pub fn caret_line_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_right_duotone

</> 
pub fn caret_line_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_right_fill

</> 
pub fn caret_line_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_right_light

</> 
pub fn caret_line_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_right_regular

</> 
pub fn caret_line_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_right_thin

</> 
pub fn caret_line_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_up_bold

</> 
pub fn caret_line_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_up_duotone

</> 
pub fn caret_line_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_up_fill

</> 
pub fn caret_line_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_up_light

</> 
pub fn caret_line_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_up_regular

</> 
pub fn caret_line_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_line_up_thin

</> 
pub fn caret_line_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_right_bold

</> 
pub fn caret_right_bold(attrs: List(Attribute(a))) -> Element(a)

caret_right_duotone

</> 
pub fn caret_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_right_fill

</> 
pub fn caret_right_fill(attrs: List(Attribute(a))) -> Element(a)

caret_right_light

</> 
pub fn caret_right_light(attrs: List(Attribute(a))) -> Element(a)

caret_right_regular

</> 
pub fn caret_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_right_thin

</> 
pub fn caret_right_thin(attrs: List(Attribute(a))) -> Element(a)

caret_up_bold

</> 
pub fn caret_up_bold(attrs: List(Attribute(a))) -> Element(a)

caret_up_down_bold

</> 
pub fn caret_up_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_up_down_duotone

</> 
pub fn caret_up_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_up_down_fill

</> 
pub fn caret_up_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_up_down_light

</> 
pub fn caret_up_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_up_down_regular

</> 
pub fn caret_up_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_up_down_thin

</> 
pub fn caret_up_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

caret_up_duotone

</> 
pub fn caret_up_duotone(attrs: List(Attribute(a))) -> Element(a)

caret_up_fill

</> 
pub fn caret_up_fill(attrs: List(Attribute(a))) -> Element(a)

caret_up_light

</> 
pub fn caret_up_light(attrs: List(Attribute(a))) -> Element(a)

caret_up_regular

</> 
pub fn caret_up_regular(attrs: List(Attribute(a))) -> Element(a)

caret_up_thin

</> 
pub fn caret_up_thin(attrs: List(Attribute(a))) -> Element(a)

carrot_bold

</> 
pub fn carrot_bold(attrs: List(Attribute(a))) -> Element(a)

carrot_duotone

</> 
pub fn carrot_duotone(attrs: List(Attribute(a))) -> Element(a)

carrot_fill

</> 
pub fn carrot_fill(attrs: List(Attribute(a))) -> Element(a)

carrot_light

</> 
pub fn carrot_light(attrs: List(Attribute(a))) -> Element(a)

carrot_regular

</> 
pub fn carrot_regular(attrs: List(Attribute(a))) -> Element(a)

carrot_thin

</> 
pub fn carrot_thin(attrs: List(Attribute(a))) -> Element(a)

cash_register_bold

</> 
pub fn cash_register_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cash_register_duotone

</> 
pub fn cash_register_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cash_register_fill

</> 
pub fn cash_register_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cash_register_light

</> 
pub fn cash_register_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cash_register_regular

</> 
pub fn cash_register_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cash_register_thin

</> 
pub fn cash_register_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cassette_tape_bold

</> 
pub fn cassette_tape_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cassette_tape_duotone

</> 
pub fn cassette_tape_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cassette_tape_fill

</> 
pub fn cassette_tape_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cassette_tape_light

</> 
pub fn cassette_tape_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cassette_tape_regular

</> 
pub fn cassette_tape_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cassette_tape_thin

</> 
pub fn cassette_tape_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

castle_turret_bold

</> 
pub fn castle_turret_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

castle_turret_duotone

</> 
pub fn castle_turret_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

castle_turret_fill

</> 
pub fn castle_turret_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

castle_turret_light

</> 
pub fn castle_turret_light(
  attrs: List(Attribute(a)),
) -> Element(a)

castle_turret_regular

</> 
pub fn castle_turret_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

castle_turret_thin

</> 
pub fn castle_turret_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cat_bold

</> 
pub fn cat_bold(attrs: List(Attribute(a))) -> Element(a)

cat_duotone

</> 
pub fn cat_duotone(attrs: List(Attribute(a))) -> Element(a)

cat_fill

</> 
pub fn cat_fill(attrs: List(Attribute(a))) -> Element(a)

cat_light

</> 
pub fn cat_light(attrs: List(Attribute(a))) -> Element(a)

cat_regular

</> 
pub fn cat_regular(attrs: List(Attribute(a))) -> Element(a)

cat_thin

</> 
pub fn cat_thin(attrs: List(Attribute(a))) -> Element(a)

cell_signal_full_bold

</> 
pub fn cell_signal_full_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_full_duotone

</> 
pub fn cell_signal_full_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_full_fill

</> 
pub fn cell_signal_full_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_full_light

</> 
pub fn cell_signal_full_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_full_regular

</> 
pub fn cell_signal_full_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_full_thin

</> 
pub fn cell_signal_full_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_high_bold

</> 
pub fn cell_signal_high_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_high_duotone

</> 
pub fn cell_signal_high_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_high_fill

</> 
pub fn cell_signal_high_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_high_light

</> 
pub fn cell_signal_high_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_high_regular

</> 
pub fn cell_signal_high_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_high_thin

</> 
pub fn cell_signal_high_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_low_bold

</> 
pub fn cell_signal_low_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_low_duotone

</> 
pub fn cell_signal_low_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_low_fill

</> 
pub fn cell_signal_low_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_low_light

</> 
pub fn cell_signal_low_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_low_regular

</> 
pub fn cell_signal_low_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_low_thin

</> 
pub fn cell_signal_low_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_medium_bold

</> 
pub fn cell_signal_medium_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_medium_duotone

</> 
pub fn cell_signal_medium_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_medium_fill

</> 
pub fn cell_signal_medium_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_medium_light

</> 
pub fn cell_signal_medium_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_medium_regular

</> 
pub fn cell_signal_medium_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_medium_thin

</> 
pub fn cell_signal_medium_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_none_bold

</> 
pub fn cell_signal_none_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_none_duotone

</> 
pub fn cell_signal_none_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_none_fill

</> 
pub fn cell_signal_none_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_none_light

</> 
pub fn cell_signal_none_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_none_regular

</> 
pub fn cell_signal_none_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_none_thin

</> 
pub fn cell_signal_none_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_slash_bold

</> 
pub fn cell_signal_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_slash_duotone

</> 
pub fn cell_signal_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_slash_fill

</> 
pub fn cell_signal_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_slash_light

</> 
pub fn cell_signal_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_slash_regular

</> 
pub fn cell_signal_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_slash_thin

</> 
pub fn cell_signal_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_x_bold

</> 
pub fn cell_signal_x_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_x_duotone

</> 
pub fn cell_signal_x_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_x_fill

</> 
pub fn cell_signal_x_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_x_light

</> 
pub fn cell_signal_x_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_x_regular

</> 
pub fn cell_signal_x_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_signal_x_thin

</> 
pub fn cell_signal_x_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_tower_bold

</> 
pub fn cell_tower_bold(attrs: List(Attribute(a))) -> Element(a)

cell_tower_duotone

</> 
pub fn cell_tower_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_tower_fill

</> 
pub fn cell_tower_fill(attrs: List(Attribute(a))) -> Element(a)

cell_tower_light

</> 
pub fn cell_tower_light(attrs: List(Attribute(a))) -> Element(a)

cell_tower_regular

</> 
pub fn cell_tower_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cell_tower_thin

</> 
pub fn cell_tower_thin(attrs: List(Attribute(a))) -> Element(a)

certificate_bold

</> 
pub fn certificate_bold(attrs: List(Attribute(a))) -> Element(a)

certificate_duotone

</> 
pub fn certificate_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

certificate_fill

</> 
pub fn certificate_fill(attrs: List(Attribute(a))) -> Element(a)

certificate_light

</> 
pub fn certificate_light(attrs: List(Attribute(a))) -> Element(a)

certificate_regular

</> 
pub fn certificate_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

certificate_thin

</> 
pub fn certificate_thin(attrs: List(Attribute(a))) -> Element(a)

chair_bold

</> 
pub fn chair_bold(attrs: List(Attribute(a))) -> Element(a)

chair_duotone

</> 
pub fn chair_duotone(attrs: List(Attribute(a))) -> Element(a)

chair_fill

</> 
pub fn chair_fill(attrs: List(Attribute(a))) -> Element(a)

chair_light

</> 
pub fn chair_light(attrs: List(Attribute(a))) -> Element(a)

chair_regular

</> 
pub fn chair_regular(attrs: List(Attribute(a))) -> Element(a)

chair_thin

</> 
pub fn chair_thin(attrs: List(Attribute(a))) -> Element(a)

chalkboard_bold

</> 
pub fn chalkboard_bold(attrs: List(Attribute(a))) -> Element(a)

chalkboard_duotone

</> 
pub fn chalkboard_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_fill

</> 
pub fn chalkboard_fill(attrs: List(Attribute(a))) -> Element(a)

chalkboard_light

</> 
pub fn chalkboard_light(attrs: List(Attribute(a))) -> Element(a)

chalkboard_regular

</> 
pub fn chalkboard_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_simple_bold

</> 
pub fn chalkboard_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_simple_duotone

</> 
pub fn chalkboard_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_simple_fill

</> 
pub fn chalkboard_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_simple_light

</> 
pub fn chalkboard_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_simple_regular

</> 
pub fn chalkboard_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_simple_thin

</> 
pub fn chalkboard_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_teacher_bold

</> 
pub fn chalkboard_teacher_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_teacher_duotone

</> 
pub fn chalkboard_teacher_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_teacher_fill

</> 
pub fn chalkboard_teacher_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_teacher_light

</> 
pub fn chalkboard_teacher_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_teacher_regular

</> 
pub fn chalkboard_teacher_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_teacher_thin

</> 
pub fn chalkboard_teacher_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chalkboard_thin

</> 
pub fn chalkboard_thin(attrs: List(Attribute(a))) -> Element(a)

champagne_bold

</> 
pub fn champagne_bold(attrs: List(Attribute(a))) -> Element(a)

champagne_duotone

</> 
pub fn champagne_duotone(attrs: List(Attribute(a))) -> Element(a)

champagne_fill

</> 
pub fn champagne_fill(attrs: List(Attribute(a))) -> Element(a)

champagne_light

</> 
pub fn champagne_light(attrs: List(Attribute(a))) -> Element(a)

champagne_regular

</> 
pub fn champagne_regular(attrs: List(Attribute(a))) -> Element(a)

champagne_thin

</> 
pub fn champagne_thin(attrs: List(Attribute(a))) -> Element(a)

charging_station_bold

</> 
pub fn charging_station_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

charging_station_duotone

</> 
pub fn charging_station_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

charging_station_fill

</> 
pub fn charging_station_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

charging_station_light

</> 
pub fn charging_station_light(
  attrs: List(Attribute(a)),
) -> Element(a)

charging_station_regular

</> 
pub fn charging_station_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

charging_station_thin

</> 
pub fn charging_station_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_bar_bold

</> 
pub fn chart_bar_bold(attrs: List(Attribute(a))) -> Element(a)

chart_bar_duotone

</> 
pub fn chart_bar_duotone(attrs: List(Attribute(a))) -> Element(a)

chart_bar_fill

</> 
pub fn chart_bar_fill(attrs: List(Attribute(a))) -> Element(a)

chart_bar_horizontal_bold

</> 
pub fn chart_bar_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_bar_horizontal_duotone

</> 
pub fn chart_bar_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_bar_horizontal_fill

</> 
pub fn chart_bar_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_bar_horizontal_light

</> 
pub fn chart_bar_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_bar_horizontal_regular

</> 
pub fn chart_bar_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_bar_horizontal_thin

</> 
pub fn chart_bar_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_bar_light

</> 
pub fn chart_bar_light(attrs: List(Attribute(a))) -> Element(a)

chart_bar_regular

</> 
pub fn chart_bar_regular(attrs: List(Attribute(a))) -> Element(a)

chart_bar_thin

</> 
pub fn chart_bar_thin(attrs: List(Attribute(a))) -> Element(a)

chart_donut_bold

</> 
pub fn chart_donut_bold(attrs: List(Attribute(a))) -> Element(a)

chart_donut_duotone

</> 
pub fn chart_donut_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_donut_fill

</> 
pub fn chart_donut_fill(attrs: List(Attribute(a))) -> Element(a)

chart_donut_light

</> 
pub fn chart_donut_light(attrs: List(Attribute(a))) -> Element(a)

chart_donut_regular

</> 
pub fn chart_donut_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_donut_thin

</> 
pub fn chart_donut_thin(attrs: List(Attribute(a))) -> Element(a)

chart_line_bold

</> 
pub fn chart_line_bold(attrs: List(Attribute(a))) -> Element(a)

chart_line_down_bold

</> 
pub fn chart_line_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_down_duotone

</> 
pub fn chart_line_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_down_fill

</> 
pub fn chart_line_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_down_light

</> 
pub fn chart_line_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_down_regular

</> 
pub fn chart_line_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_down_thin

</> 
pub fn chart_line_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_duotone

</> 
pub fn chart_line_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_fill

</> 
pub fn chart_line_fill(attrs: List(Attribute(a))) -> Element(a)

chart_line_light

</> 
pub fn chart_line_light(attrs: List(Attribute(a))) -> Element(a)

chart_line_regular

</> 
pub fn chart_line_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_thin

</> 
pub fn chart_line_thin(attrs: List(Attribute(a))) -> Element(a)

chart_line_up_bold

</> 
pub fn chart_line_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_up_duotone

</> 
pub fn chart_line_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_up_fill

</> 
pub fn chart_line_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_up_light

</> 
pub fn chart_line_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_up_regular

</> 
pub fn chart_line_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_line_up_thin

</> 
pub fn chart_line_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_pie_bold

</> 
pub fn chart_pie_bold(attrs: List(Attribute(a))) -> Element(a)

chart_pie_duotone

</> 
pub fn chart_pie_duotone(attrs: List(Attribute(a))) -> Element(a)

chart_pie_fill

</> 
pub fn chart_pie_fill(attrs: List(Attribute(a))) -> Element(a)

chart_pie_light

</> 
pub fn chart_pie_light(attrs: List(Attribute(a))) -> Element(a)

chart_pie_regular

</> 
pub fn chart_pie_regular(attrs: List(Attribute(a))) -> Element(a)

chart_pie_slice_bold

</> 
pub fn chart_pie_slice_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_pie_slice_duotone

</> 
pub fn chart_pie_slice_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_pie_slice_fill

</> 
pub fn chart_pie_slice_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_pie_slice_light

</> 
pub fn chart_pie_slice_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_pie_slice_regular

</> 
pub fn chart_pie_slice_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_pie_slice_thin

</> 
pub fn chart_pie_slice_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_pie_thin

</> 
pub fn chart_pie_thin(attrs: List(Attribute(a))) -> Element(a)

chart_polar_bold

</> 
pub fn chart_polar_bold(attrs: List(Attribute(a))) -> Element(a)

chart_polar_duotone

</> 
pub fn chart_polar_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_polar_fill

</> 
pub fn chart_polar_fill(attrs: List(Attribute(a))) -> Element(a)

chart_polar_light

</> 
pub fn chart_polar_light(attrs: List(Attribute(a))) -> Element(a)

chart_polar_regular

</> 
pub fn chart_polar_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_polar_thin

</> 
pub fn chart_polar_thin(attrs: List(Attribute(a))) -> Element(a)

chart_scatter_bold

</> 
pub fn chart_scatter_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_scatter_duotone

</> 
pub fn chart_scatter_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_scatter_fill

</> 
pub fn chart_scatter_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_scatter_light

</> 
pub fn chart_scatter_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_scatter_regular

</> 
pub fn chart_scatter_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chart_scatter_thin

</> 
pub fn chart_scatter_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_bold

</> 
pub fn chat_bold(attrs: List(Attribute(a))) -> Element(a)

chat_centered_bold

</> 
pub fn chat_centered_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_dots_bold

</> 
pub fn chat_centered_dots_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_dots_duotone

</> 
pub fn chat_centered_dots_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_dots_fill

</> 
pub fn chat_centered_dots_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_dots_light

</> 
pub fn chat_centered_dots_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_dots_regular

</> 
pub fn chat_centered_dots_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_dots_thin

</> 
pub fn chat_centered_dots_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_duotone

</> 
pub fn chat_centered_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_fill

</> 
pub fn chat_centered_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_light

</> 
pub fn chat_centered_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_regular

</> 
pub fn chat_centered_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_slash_bold

</> 
pub fn chat_centered_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_slash_duotone

</> 
pub fn chat_centered_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_slash_fill

</> 
pub fn chat_centered_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_slash_light

</> 
pub fn chat_centered_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_slash_regular

</> 
pub fn chat_centered_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_slash_thin

</> 
pub fn chat_centered_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_text_bold

</> 
pub fn chat_centered_text_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_text_duotone

</> 
pub fn chat_centered_text_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_text_fill

</> 
pub fn chat_centered_text_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_text_light

</> 
pub fn chat_centered_text_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_text_regular

</> 
pub fn chat_centered_text_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_text_thin

</> 
pub fn chat_centered_text_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_centered_thin

</> 
pub fn chat_centered_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_bold

</> 
pub fn chat_circle_bold(attrs: List(Attribute(a))) -> Element(a)

chat_circle_dots_bold

</> 
pub fn chat_circle_dots_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_dots_duotone

</> 
pub fn chat_circle_dots_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_dots_fill

</> 
pub fn chat_circle_dots_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_dots_light

</> 
pub fn chat_circle_dots_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_dots_regular

</> 
pub fn chat_circle_dots_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_dots_thin

</> 
pub fn chat_circle_dots_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_duotone

</> 
pub fn chat_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_fill

</> 
pub fn chat_circle_fill(attrs: List(Attribute(a))) -> Element(a)

chat_circle_light

</> 
pub fn chat_circle_light(attrs: List(Attribute(a))) -> Element(a)

chat_circle_regular

</> 
pub fn chat_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_slash_bold

</> 
pub fn chat_circle_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_slash_duotone

</> 
pub fn chat_circle_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_slash_fill

</> 
pub fn chat_circle_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_slash_light

</> 
pub fn chat_circle_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_slash_regular

</> 
pub fn chat_circle_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_slash_thin

</> 
pub fn chat_circle_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_text_bold

</> 
pub fn chat_circle_text_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_text_duotone

</> 
pub fn chat_circle_text_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_text_fill

</> 
pub fn chat_circle_text_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_text_light

</> 
pub fn chat_circle_text_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_text_regular

</> 
pub fn chat_circle_text_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_text_thin

</> 
pub fn chat_circle_text_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_circle_thin

</> 
pub fn chat_circle_thin(attrs: List(Attribute(a))) -> Element(a)

chat_dots_bold

</> 
pub fn chat_dots_bold(attrs: List(Attribute(a))) -> Element(a)

chat_dots_duotone

</> 
pub fn chat_dots_duotone(attrs: List(Attribute(a))) -> Element(a)

chat_dots_fill

</> 
pub fn chat_dots_fill(attrs: List(Attribute(a))) -> Element(a)

chat_dots_light

</> 
pub fn chat_dots_light(attrs: List(Attribute(a))) -> Element(a)

chat_dots_regular

</> 
pub fn chat_dots_regular(attrs: List(Attribute(a))) -> Element(a)

chat_dots_thin

</> 
pub fn chat_dots_thin(attrs: List(Attribute(a))) -> Element(a)

chat_duotone

</> 
pub fn chat_duotone(attrs: List(Attribute(a))) -> Element(a)

chat_fill

</> 
pub fn chat_fill(attrs: List(Attribute(a))) -> Element(a)

chat_light

</> 
pub fn chat_light(attrs: List(Attribute(a))) -> Element(a)

chat_regular

</> 
pub fn chat_regular(attrs: List(Attribute(a))) -> Element(a)

chat_slash_bold

</> 
pub fn chat_slash_bold(attrs: List(Attribute(a))) -> Element(a)

chat_slash_duotone

</> 
pub fn chat_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_slash_fill

</> 
pub fn chat_slash_fill(attrs: List(Attribute(a))) -> Element(a)

chat_slash_light

</> 
pub fn chat_slash_light(attrs: List(Attribute(a))) -> Element(a)

chat_slash_regular

</> 
pub fn chat_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_slash_thin

</> 
pub fn chat_slash_thin(attrs: List(Attribute(a))) -> Element(a)

chat_teardrop_bold

</> 
pub fn chat_teardrop_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_dots_bold

</> 
pub fn chat_teardrop_dots_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_dots_duotone

</> 
pub fn chat_teardrop_dots_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_dots_fill

</> 
pub fn chat_teardrop_dots_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_dots_light

</> 
pub fn chat_teardrop_dots_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_dots_regular

</> 
pub fn chat_teardrop_dots_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_dots_thin

</> 
pub fn chat_teardrop_dots_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_duotone

</> 
pub fn chat_teardrop_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_fill

</> 
pub fn chat_teardrop_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_light

</> 
pub fn chat_teardrop_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_regular

</> 
pub fn chat_teardrop_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_slash_bold

</> 
pub fn chat_teardrop_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_slash_duotone

</> 
pub fn chat_teardrop_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_slash_fill

</> 
pub fn chat_teardrop_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_slash_light

</> 
pub fn chat_teardrop_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_slash_regular

</> 
pub fn chat_teardrop_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_slash_thin

</> 
pub fn chat_teardrop_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_text_bold

</> 
pub fn chat_teardrop_text_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_text_duotone

</> 
pub fn chat_teardrop_text_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_text_fill

</> 
pub fn chat_teardrop_text_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_text_light

</> 
pub fn chat_teardrop_text_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_text_regular

</> 
pub fn chat_teardrop_text_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_text_thin

</> 
pub fn chat_teardrop_text_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_teardrop_thin

</> 
pub fn chat_teardrop_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chat_text_bold

</> 
pub fn chat_text_bold(attrs: List(Attribute(a))) -> Element(a)

chat_text_duotone

</> 
pub fn chat_text_duotone(attrs: List(Attribute(a))) -> Element(a)

chat_text_fill

</> 
pub fn chat_text_fill(attrs: List(Attribute(a))) -> Element(a)

chat_text_light

</> 
pub fn chat_text_light(attrs: List(Attribute(a))) -> Element(a)

chat_text_regular

</> 
pub fn chat_text_regular(attrs: List(Attribute(a))) -> Element(a)

chat_text_thin

</> 
pub fn chat_text_thin(attrs: List(Attribute(a))) -> Element(a)

chat_thin

</> 
pub fn chat_thin(attrs: List(Attribute(a))) -> Element(a)

chats_bold

</> 
pub fn chats_bold(attrs: List(Attribute(a))) -> Element(a)

chats_circle_bold

</> 
pub fn chats_circle_bold(attrs: List(Attribute(a))) -> Element(a)

chats_circle_duotone

</> 
pub fn chats_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chats_circle_fill

</> 
pub fn chats_circle_fill(attrs: List(Attribute(a))) -> Element(a)

chats_circle_light

</> 
pub fn chats_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chats_circle_regular

</> 
pub fn chats_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chats_circle_thin

</> 
pub fn chats_circle_thin(attrs: List(Attribute(a))) -> Element(a)

chats_duotone

</> 
pub fn chats_duotone(attrs: List(Attribute(a))) -> Element(a)

chats_fill

</> 
pub fn chats_fill(attrs: List(Attribute(a))) -> Element(a)

chats_light

</> 
pub fn chats_light(attrs: List(Attribute(a))) -> Element(a)

chats_regular

</> 
pub fn chats_regular(attrs: List(Attribute(a))) -> Element(a)

chats_teardrop_bold

</> 
pub fn chats_teardrop_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

chats_teardrop_duotone

</> 
pub fn chats_teardrop_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

chats_teardrop_fill

</> 
pub fn chats_teardrop_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

chats_teardrop_light

</> 
pub fn chats_teardrop_light(
  attrs: List(Attribute(a)),
) -> Element(a)

chats_teardrop_regular

</> 
pub fn chats_teardrop_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

chats_teardrop_thin

</> 
pub fn chats_teardrop_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

chats_thin

</> 
pub fn chats_thin(attrs: List(Attribute(a))) -> Element(a)

check_bold

</> 
pub fn check_bold(attrs: List(Attribute(a))) -> Element(a)

check_circle_bold

</> 
pub fn check_circle_bold(attrs: List(Attribute(a))) -> Element(a)

check_circle_duotone

</> 
pub fn check_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

check_circle_fill

</> 
pub fn check_circle_fill(attrs: List(Attribute(a))) -> Element(a)

check_circle_light

</> 
pub fn check_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

check_circle_regular

</> 
pub fn check_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

check_circle_thin

</> 
pub fn check_circle_thin(attrs: List(Attribute(a))) -> Element(a)

check_duotone

</> 
pub fn check_duotone(attrs: List(Attribute(a))) -> Element(a)

check_fat_bold

</> 
pub fn check_fat_bold(attrs: List(Attribute(a))) -> Element(a)

check_fat_duotone

</> 
pub fn check_fat_duotone(attrs: List(Attribute(a))) -> Element(a)

check_fat_fill

</> 
pub fn check_fat_fill(attrs: List(Attribute(a))) -> Element(a)

check_fat_light

</> 
pub fn check_fat_light(attrs: List(Attribute(a))) -> Element(a)

check_fat_regular

</> 
pub fn check_fat_regular(attrs: List(Attribute(a))) -> Element(a)

check_fat_thin

</> 
pub fn check_fat_thin(attrs: List(Attribute(a))) -> Element(a)

check_fill

</> 
pub fn check_fill(attrs: List(Attribute(a))) -> Element(a)

check_light

</> 
pub fn check_light(attrs: List(Attribute(a))) -> Element(a)

check_regular

</> 
pub fn check_regular(attrs: List(Attribute(a))) -> Element(a)

check_square_bold

</> 
pub fn check_square_bold(attrs: List(Attribute(a))) -> Element(a)

check_square_duotone

</> 
pub fn check_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

check_square_fill

</> 
pub fn check_square_fill(attrs: List(Attribute(a))) -> Element(a)

check_square_light

</> 
pub fn check_square_light(
  attrs: List(Attribute(a)),
) -> Element(a)

check_square_offset_bold

</> 
pub fn check_square_offset_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

check_square_offset_duotone

</> 
pub fn check_square_offset_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

check_square_offset_fill

</> 
pub fn check_square_offset_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

check_square_offset_light

</> 
pub fn check_square_offset_light(
  attrs: List(Attribute(a)),
) -> Element(a)

check_square_offset_regular

</> 
pub fn check_square_offset_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

check_square_offset_thin

</> 
pub fn check_square_offset_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

check_square_regular

</> 
pub fn check_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

check_square_thin

</> 
pub fn check_square_thin(attrs: List(Attribute(a))) -> Element(a)

check_thin

</> 
pub fn check_thin(attrs: List(Attribute(a))) -> Element(a)

checkerboard_bold

</> 
pub fn checkerboard_bold(attrs: List(Attribute(a))) -> Element(a)

checkerboard_duotone

</> 
pub fn checkerboard_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

checkerboard_fill

</> 
pub fn checkerboard_fill(attrs: List(Attribute(a))) -> Element(a)

checkerboard_light

</> 
pub fn checkerboard_light(
  attrs: List(Attribute(a)),
) -> Element(a)

checkerboard_regular

</> 
pub fn checkerboard_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

checkerboard_thin

</> 
pub fn checkerboard_thin(attrs: List(Attribute(a))) -> Element(a)

checks_bold

</> 
pub fn checks_bold(attrs: List(Attribute(a))) -> Element(a)

checks_duotone

</> 
pub fn checks_duotone(attrs: List(Attribute(a))) -> Element(a)

checks_fill

</> 
pub fn checks_fill(attrs: List(Attribute(a))) -> Element(a)

checks_light

</> 
pub fn checks_light(attrs: List(Attribute(a))) -> Element(a)

checks_regular

</> 
pub fn checks_regular(attrs: List(Attribute(a))) -> Element(a)

checks_thin

</> 
pub fn checks_thin(attrs: List(Attribute(a))) -> Element(a)

cheers_bold

</> 
pub fn cheers_bold(attrs: List(Attribute(a))) -> Element(a)

cheers_duotone

</> 
pub fn cheers_duotone(attrs: List(Attribute(a))) -> Element(a)

cheers_fill

</> 
pub fn cheers_fill(attrs: List(Attribute(a))) -> Element(a)

cheers_light

</> 
pub fn cheers_light(attrs: List(Attribute(a))) -> Element(a)

cheers_regular

</> 
pub fn cheers_regular(attrs: List(Attribute(a))) -> Element(a)

cheers_thin

</> 
pub fn cheers_thin(attrs: List(Attribute(a))) -> Element(a)

cheese_bold

</> 
pub fn cheese_bold(attrs: List(Attribute(a))) -> Element(a)

cheese_duotone

</> 
pub fn cheese_duotone(attrs: List(Attribute(a))) -> Element(a)

cheese_fill

</> 
pub fn cheese_fill(attrs: List(Attribute(a))) -> Element(a)

cheese_light

</> 
pub fn cheese_light(attrs: List(Attribute(a))) -> Element(a)

cheese_regular

</> 
pub fn cheese_regular(attrs: List(Attribute(a))) -> Element(a)

cheese_thin

</> 
pub fn cheese_thin(attrs: List(Attribute(a))) -> Element(a)

chef_hat_bold

</> 
pub fn chef_hat_bold(attrs: List(Attribute(a))) -> Element(a)

chef_hat_duotone

</> 
pub fn chef_hat_duotone(attrs: List(Attribute(a))) -> Element(a)

chef_hat_fill

</> 
pub fn chef_hat_fill(attrs: List(Attribute(a))) -> Element(a)

chef_hat_light

</> 
pub fn chef_hat_light(attrs: List(Attribute(a))) -> Element(a)

chef_hat_regular

</> 
pub fn chef_hat_regular(attrs: List(Attribute(a))) -> Element(a)

chef_hat_thin

</> 
pub fn chef_hat_thin(attrs: List(Attribute(a))) -> Element(a)

cherries_bold

</> 
pub fn cherries_bold(attrs: List(Attribute(a))) -> Element(a)

cherries_duotone

</> 
pub fn cherries_duotone(attrs: List(Attribute(a))) -> Element(a)

cherries_fill

</> 
pub fn cherries_fill(attrs: List(Attribute(a))) -> Element(a)

cherries_light

</> 
pub fn cherries_light(attrs: List(Attribute(a))) -> Element(a)

cherries_regular

</> 
pub fn cherries_regular(attrs: List(Attribute(a))) -> Element(a)

cherries_thin

</> 
pub fn cherries_thin(attrs: List(Attribute(a))) -> Element(a)

church_bold

</> 
pub fn church_bold(attrs: List(Attribute(a))) -> Element(a)

church_duotone

</> 
pub fn church_duotone(attrs: List(Attribute(a))) -> Element(a)

church_fill

</> 
pub fn church_fill(attrs: List(Attribute(a))) -> Element(a)

church_light

</> 
pub fn church_light(attrs: List(Attribute(a))) -> Element(a)

church_regular

</> 
pub fn church_regular(attrs: List(Attribute(a))) -> Element(a)

church_thin

</> 
pub fn church_thin(attrs: List(Attribute(a))) -> Element(a)

cigarette_bold

</> 
pub fn cigarette_bold(attrs: List(Attribute(a))) -> Element(a)

cigarette_duotone

</> 
pub fn cigarette_duotone(attrs: List(Attribute(a))) -> Element(a)

cigarette_fill

</> 
pub fn cigarette_fill(attrs: List(Attribute(a))) -> Element(a)

cigarette_light

</> 
pub fn cigarette_light(attrs: List(Attribute(a))) -> Element(a)

cigarette_regular

</> 
pub fn cigarette_regular(attrs: List(Attribute(a))) -> Element(a)

cigarette_slash_bold

</> 
pub fn cigarette_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cigarette_slash_duotone

</> 
pub fn cigarette_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cigarette_slash_fill

</> 
pub fn cigarette_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cigarette_slash_light

</> 
pub fn cigarette_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cigarette_slash_regular

</> 
pub fn cigarette_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cigarette_slash_thin

</> 
pub fn cigarette_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cigarette_thin

</> 
pub fn cigarette_thin(attrs: List(Attribute(a))) -> Element(a)

circle_bold

</> 
pub fn circle_bold(attrs: List(Attribute(a))) -> Element(a)

circle_dashed_bold

</> 
pub fn circle_dashed_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_dashed_duotone

</> 
pub fn circle_dashed_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_dashed_fill

</> 
pub fn circle_dashed_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_dashed_light

</> 
pub fn circle_dashed_light(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_dashed_regular

</> 
pub fn circle_dashed_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_dashed_thin

</> 
pub fn circle_dashed_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_duotone

</> 
pub fn circle_duotone(attrs: List(Attribute(a))) -> Element(a)

circle_fill

</> 
pub fn circle_fill(attrs: List(Attribute(a))) -> Element(a)

circle_half_bold

</> 
pub fn circle_half_bold(attrs: List(Attribute(a))) -> Element(a)

circle_half_duotone

</> 
pub fn circle_half_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_half_fill

</> 
pub fn circle_half_fill(attrs: List(Attribute(a))) -> Element(a)

circle_half_light

</> 
pub fn circle_half_light(attrs: List(Attribute(a))) -> Element(a)

circle_half_regular

</> 
pub fn circle_half_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_half_thin

</> 
pub fn circle_half_thin(attrs: List(Attribute(a))) -> Element(a)

circle_half_tilt_bold

</> 
pub fn circle_half_tilt_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_half_tilt_duotone

</> 
pub fn circle_half_tilt_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_half_tilt_fill

</> 
pub fn circle_half_tilt_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_half_tilt_light

</> 
pub fn circle_half_tilt_light(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_half_tilt_regular

</> 
pub fn circle_half_tilt_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_half_tilt_thin

</> 
pub fn circle_half_tilt_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_light

</> 
pub fn circle_light(attrs: List(Attribute(a))) -> Element(a)

circle_notch_bold

</> 
pub fn circle_notch_bold(attrs: List(Attribute(a))) -> Element(a)

circle_notch_duotone

</> 
pub fn circle_notch_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_notch_fill

</> 
pub fn circle_notch_fill(attrs: List(Attribute(a))) -> Element(a)

circle_notch_light

</> 
pub fn circle_notch_light(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_notch_regular

</> 
pub fn circle_notch_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

circle_notch_thin

</> 
pub fn circle_notch_thin(attrs: List(Attribute(a))) -> Element(a)

circle_regular

</> 
pub fn circle_regular(attrs: List(Attribute(a))) -> Element(a)

circle_thin

</> 
pub fn circle_thin(attrs: List(Attribute(a))) -> Element(a)

circles_four_bold

</> 
pub fn circles_four_bold(attrs: List(Attribute(a))) -> Element(a)

circles_four_duotone

</> 
pub fn circles_four_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_four_fill

</> 
pub fn circles_four_fill(attrs: List(Attribute(a))) -> Element(a)

circles_four_light

</> 
pub fn circles_four_light(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_four_regular

</> 
pub fn circles_four_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_four_thin

</> 
pub fn circles_four_thin(attrs: List(Attribute(a))) -> Element(a)

circles_three_bold

</> 
pub fn circles_three_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_duotone

</> 
pub fn circles_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_fill

</> 
pub fn circles_three_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_light

</> 
pub fn circles_three_light(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_plus_bold

</> 
pub fn circles_three_plus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_plus_duotone

</> 
pub fn circles_three_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_plus_fill

</> 
pub fn circles_three_plus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_plus_light

</> 
pub fn circles_three_plus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_plus_regular

</> 
pub fn circles_three_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_plus_thin

</> 
pub fn circles_three_plus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_regular

</> 
pub fn circles_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

circles_three_thin

</> 
pub fn circles_three_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

circuitry_bold

</> 
pub fn circuitry_bold(attrs: List(Attribute(a))) -> Element(a)

circuitry_duotone

</> 
pub fn circuitry_duotone(attrs: List(Attribute(a))) -> Element(a)

circuitry_fill

</> 
pub fn circuitry_fill(attrs: List(Attribute(a))) -> Element(a)

circuitry_light

</> 
pub fn circuitry_light(attrs: List(Attribute(a))) -> Element(a)

circuitry_regular

</> 
pub fn circuitry_regular(attrs: List(Attribute(a))) -> Element(a)

circuitry_thin

</> 
pub fn circuitry_thin(attrs: List(Attribute(a))) -> Element(a)

city_bold

</> 
pub fn city_bold(attrs: List(Attribute(a))) -> Element(a)

city_duotone

</> 
pub fn city_duotone(attrs: List(Attribute(a))) -> Element(a)

city_fill

</> 
pub fn city_fill(attrs: List(Attribute(a))) -> Element(a)

city_light

</> 
pub fn city_light(attrs: List(Attribute(a))) -> Element(a)

city_regular

</> 
pub fn city_regular(attrs: List(Attribute(a))) -> Element(a)

city_thin

</> 
pub fn city_thin(attrs: List(Attribute(a))) -> Element(a)

clipboard_bold

</> 
pub fn clipboard_bold(attrs: List(Attribute(a))) -> Element(a)

clipboard_duotone

</> 
pub fn clipboard_duotone(attrs: List(Attribute(a))) -> Element(a)

clipboard_fill

</> 
pub fn clipboard_fill(attrs: List(Attribute(a))) -> Element(a)

clipboard_light

</> 
pub fn clipboard_light(attrs: List(Attribute(a))) -> Element(a)

clipboard_regular

</> 
pub fn clipboard_regular(attrs: List(Attribute(a))) -> Element(a)

clipboard_text_bold

</> 
pub fn clipboard_text_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

clipboard_text_duotone

</> 
pub fn clipboard_text_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

clipboard_text_fill

</> 
pub fn clipboard_text_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

clipboard_text_light

</> 
pub fn clipboard_text_light(
  attrs: List(Attribute(a)),
) -> Element(a)

clipboard_text_regular

</> 
pub fn clipboard_text_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

clipboard_text_thin

</> 
pub fn clipboard_text_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

clipboard_thin

</> 
pub fn clipboard_thin(attrs: List(Attribute(a))) -> Element(a)

clock_afternoon_bold

</> 
pub fn clock_afternoon_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_afternoon_duotone

</> 
pub fn clock_afternoon_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_afternoon_fill

</> 
pub fn clock_afternoon_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_afternoon_light

</> 
pub fn clock_afternoon_light(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_afternoon_regular

</> 
pub fn clock_afternoon_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_afternoon_thin

</> 
pub fn clock_afternoon_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_bold

</> 
pub fn clock_bold(attrs: List(Attribute(a))) -> Element(a)

clock_clockwise_bold

</> 
pub fn clock_clockwise_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_clockwise_duotone

</> 
pub fn clock_clockwise_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_clockwise_fill

</> 
pub fn clock_clockwise_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_clockwise_light

</> 
pub fn clock_clockwise_light(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_clockwise_regular

</> 
pub fn clock_clockwise_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_clockwise_thin

</> 
pub fn clock_clockwise_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_countdown_bold

</> 
pub fn clock_countdown_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_countdown_duotone

</> 
pub fn clock_countdown_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_countdown_fill

</> 
pub fn clock_countdown_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_countdown_light

</> 
pub fn clock_countdown_light(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_countdown_regular

</> 
pub fn clock_countdown_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_countdown_thin

</> 
pub fn clock_countdown_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_counter_clockwise_bold

</> 
pub fn clock_counter_clockwise_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_counter_clockwise_duotone

</> 
pub fn clock_counter_clockwise_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_counter_clockwise_fill

</> 
pub fn clock_counter_clockwise_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_counter_clockwise_light

</> 
pub fn clock_counter_clockwise_light(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_counter_clockwise_regular

</> 
pub fn clock_counter_clockwise_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_counter_clockwise_thin

</> 
pub fn clock_counter_clockwise_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_duotone

</> 
pub fn clock_duotone(attrs: List(Attribute(a))) -> Element(a)

clock_fill

</> 
pub fn clock_fill(attrs: List(Attribute(a))) -> Element(a)

clock_light

</> 
pub fn clock_light(attrs: List(Attribute(a))) -> Element(a)

clock_regular

</> 
pub fn clock_regular(attrs: List(Attribute(a))) -> Element(a)

clock_thin

</> 
pub fn clock_thin(attrs: List(Attribute(a))) -> Element(a)

clock_user_bold

</> 
pub fn clock_user_bold(attrs: List(Attribute(a))) -> Element(a)

clock_user_duotone

</> 
pub fn clock_user_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_user_fill

</> 
pub fn clock_user_fill(attrs: List(Attribute(a))) -> Element(a)

clock_user_light

</> 
pub fn clock_user_light(attrs: List(Attribute(a))) -> Element(a)

clock_user_regular

</> 
pub fn clock_user_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

clock_user_thin

</> 
pub fn clock_user_thin(attrs: List(Attribute(a))) -> Element(a)

closed_captioning_bold

</> 
pub fn closed_captioning_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

closed_captioning_duotone

</> 
pub fn closed_captioning_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

closed_captioning_fill

</> 
pub fn closed_captioning_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

closed_captioning_light

</> 
pub fn closed_captioning_light(
  attrs: List(Attribute(a)),
) -> Element(a)

closed_captioning_regular

</> 
pub fn closed_captioning_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

closed_captioning_thin

</> 
pub fn closed_captioning_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_down_bold

</> 
pub fn cloud_arrow_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_down_duotone

</> 
pub fn cloud_arrow_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_down_fill

</> 
pub fn cloud_arrow_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_down_light

</> 
pub fn cloud_arrow_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_down_regular

</> 
pub fn cloud_arrow_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_down_thin

</> 
pub fn cloud_arrow_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_up_bold

</> 
pub fn cloud_arrow_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_up_duotone

</> 
pub fn cloud_arrow_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_up_fill

</> 
pub fn cloud_arrow_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_up_light

</> 
pub fn cloud_arrow_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_up_regular

</> 
pub fn cloud_arrow_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_arrow_up_thin

</> 
pub fn cloud_arrow_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_bold

</> 
pub fn cloud_bold(attrs: List(Attribute(a))) -> Element(a)

cloud_check_bold

</> 
pub fn cloud_check_bold(attrs: List(Attribute(a))) -> Element(a)

cloud_check_duotone

</> 
pub fn cloud_check_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_check_fill

</> 
pub fn cloud_check_fill(attrs: List(Attribute(a))) -> Element(a)

cloud_check_light

</> 
pub fn cloud_check_light(attrs: List(Attribute(a))) -> Element(a)

cloud_check_regular

</> 
pub fn cloud_check_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_check_thin

</> 
pub fn cloud_check_thin(attrs: List(Attribute(a))) -> Element(a)

cloud_duotone

</> 
pub fn cloud_duotone(attrs: List(Attribute(a))) -> Element(a)

cloud_fill

</> 
pub fn cloud_fill(attrs: List(Attribute(a))) -> Element(a)

cloud_fog_bold

</> 
pub fn cloud_fog_bold(attrs: List(Attribute(a))) -> Element(a)

cloud_fog_duotone

</> 
pub fn cloud_fog_duotone(attrs: List(Attribute(a))) -> Element(a)

cloud_fog_fill

</> 
pub fn cloud_fog_fill(attrs: List(Attribute(a))) -> Element(a)

cloud_fog_light

</> 
pub fn cloud_fog_light(attrs: List(Attribute(a))) -> Element(a)

cloud_fog_regular

</> 
pub fn cloud_fog_regular(attrs: List(Attribute(a))) -> Element(a)

cloud_fog_thin

</> 
pub fn cloud_fog_thin(attrs: List(Attribute(a))) -> Element(a)

cloud_light

</> 
pub fn cloud_light(attrs: List(Attribute(a))) -> Element(a)

cloud_lightning_bold

</> 
pub fn cloud_lightning_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_lightning_duotone

</> 
pub fn cloud_lightning_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_lightning_fill

</> 
pub fn cloud_lightning_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_lightning_light

</> 
pub fn cloud_lightning_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_lightning_regular

</> 
pub fn cloud_lightning_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_lightning_thin

</> 
pub fn cloud_lightning_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_moon_bold

</> 
pub fn cloud_moon_bold(attrs: List(Attribute(a))) -> Element(a)

cloud_moon_duotone

</> 
pub fn cloud_moon_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_moon_fill

</> 
pub fn cloud_moon_fill(attrs: List(Attribute(a))) -> Element(a)

cloud_moon_light

</> 
pub fn cloud_moon_light(attrs: List(Attribute(a))) -> Element(a)

cloud_moon_regular

</> 
pub fn cloud_moon_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_moon_thin

</> 
pub fn cloud_moon_thin(attrs: List(Attribute(a))) -> Element(a)

cloud_rain_bold

</> 
pub fn cloud_rain_bold(attrs: List(Attribute(a))) -> Element(a)

cloud_rain_duotone

</> 
pub fn cloud_rain_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_rain_fill

</> 
pub fn cloud_rain_fill(attrs: List(Attribute(a))) -> Element(a)

cloud_rain_light

</> 
pub fn cloud_rain_light(attrs: List(Attribute(a))) -> Element(a)

cloud_rain_regular

</> 
pub fn cloud_rain_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_rain_thin

</> 
pub fn cloud_rain_thin(attrs: List(Attribute(a))) -> Element(a)

cloud_regular

</> 
pub fn cloud_regular(attrs: List(Attribute(a))) -> Element(a)

cloud_slash_bold

</> 
pub fn cloud_slash_bold(attrs: List(Attribute(a))) -> Element(a)

cloud_slash_duotone

</> 
pub fn cloud_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_slash_fill

</> 
pub fn cloud_slash_fill(attrs: List(Attribute(a))) -> Element(a)

cloud_slash_light

</> 
pub fn cloud_slash_light(attrs: List(Attribute(a))) -> Element(a)

cloud_slash_regular

</> 
pub fn cloud_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_slash_thin

</> 
pub fn cloud_slash_thin(attrs: List(Attribute(a))) -> Element(a)

cloud_snow_bold

</> 
pub fn cloud_snow_bold(attrs: List(Attribute(a))) -> Element(a)

cloud_snow_duotone

</> 
pub fn cloud_snow_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_snow_fill

</> 
pub fn cloud_snow_fill(attrs: List(Attribute(a))) -> Element(a)

cloud_snow_light

</> 
pub fn cloud_snow_light(attrs: List(Attribute(a))) -> Element(a)

cloud_snow_regular

</> 
pub fn cloud_snow_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_snow_thin

</> 
pub fn cloud_snow_thin(attrs: List(Attribute(a))) -> Element(a)

cloud_sun_bold

</> 
pub fn cloud_sun_bold(attrs: List(Attribute(a))) -> Element(a)

cloud_sun_duotone

</> 
pub fn cloud_sun_duotone(attrs: List(Attribute(a))) -> Element(a)

cloud_sun_fill

</> 
pub fn cloud_sun_fill(attrs: List(Attribute(a))) -> Element(a)

cloud_sun_light

</> 
pub fn cloud_sun_light(attrs: List(Attribute(a))) -> Element(a)

cloud_sun_regular

</> 
pub fn cloud_sun_regular(attrs: List(Attribute(a))) -> Element(a)

cloud_sun_thin

</> 
pub fn cloud_sun_thin(attrs: List(Attribute(a))) -> Element(a)

cloud_thin

</> 
pub fn cloud_thin(attrs: List(Attribute(a))) -> Element(a)

cloud_warning_bold

</> 
pub fn cloud_warning_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_warning_duotone

</> 
pub fn cloud_warning_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_warning_fill

</> 
pub fn cloud_warning_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_warning_light

</> 
pub fn cloud_warning_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_warning_regular

</> 
pub fn cloud_warning_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_warning_thin

</> 
pub fn cloud_warning_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cloud_x_bold

</> 
pub fn cloud_x_bold(attrs: List(Attribute(a))) -> Element(a)

cloud_x_duotone

</> 
pub fn cloud_x_duotone(attrs: List(Attribute(a))) -> Element(a)

cloud_x_fill

</> 
pub fn cloud_x_fill(attrs: List(Attribute(a))) -> Element(a)

cloud_x_light

</> 
pub fn cloud_x_light(attrs: List(Attribute(a))) -> Element(a)

cloud_x_regular

</> 
pub fn cloud_x_regular(attrs: List(Attribute(a))) -> Element(a)

cloud_x_thin

</> 
pub fn cloud_x_thin(attrs: List(Attribute(a))) -> Element(a)

clover_bold

</> 
pub fn clover_bold(attrs: List(Attribute(a))) -> Element(a)

clover_duotone

</> 
pub fn clover_duotone(attrs: List(Attribute(a))) -> Element(a)

clover_fill

</> 
pub fn clover_fill(attrs: List(Attribute(a))) -> Element(a)

clover_light

</> 
pub fn clover_light(attrs: List(Attribute(a))) -> Element(a)

clover_regular

</> 
pub fn clover_regular(attrs: List(Attribute(a))) -> Element(a)

clover_thin

</> 
pub fn clover_thin(attrs: List(Attribute(a))) -> Element(a)

club_bold

</> 
pub fn club_bold(attrs: List(Attribute(a))) -> Element(a)

club_duotone

</> 
pub fn club_duotone(attrs: List(Attribute(a))) -> Element(a)

club_fill

</> 
pub fn club_fill(attrs: List(Attribute(a))) -> Element(a)

club_light

</> 
pub fn club_light(attrs: List(Attribute(a))) -> Element(a)

club_regular

</> 
pub fn club_regular(attrs: List(Attribute(a))) -> Element(a)

club_thin

</> 
pub fn club_thin(attrs: List(Attribute(a))) -> Element(a)

coat_hanger_bold

</> 
pub fn coat_hanger_bold(attrs: List(Attribute(a))) -> Element(a)

coat_hanger_duotone

</> 
pub fn coat_hanger_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

coat_hanger_fill

</> 
pub fn coat_hanger_fill(attrs: List(Attribute(a))) -> Element(a)

coat_hanger_light

</> 
pub fn coat_hanger_light(attrs: List(Attribute(a))) -> Element(a)

coat_hanger_regular

</> 
pub fn coat_hanger_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

coat_hanger_thin

</> 
pub fn coat_hanger_thin(attrs: List(Attribute(a))) -> Element(a)

coda_logo_bold

</> 
pub fn coda_logo_bold(attrs: List(Attribute(a))) -> Element(a)

coda_logo_duotone

</> 
pub fn coda_logo_duotone(attrs: List(Attribute(a))) -> Element(a)

coda_logo_fill

</> 
pub fn coda_logo_fill(attrs: List(Attribute(a))) -> Element(a)

coda_logo_light

</> 
pub fn coda_logo_light(attrs: List(Attribute(a))) -> Element(a)

coda_logo_regular

</> 
pub fn coda_logo_regular(attrs: List(Attribute(a))) -> Element(a)

coda_logo_thin

</> 
pub fn coda_logo_thin(attrs: List(Attribute(a))) -> Element(a)

code_block_bold

</> 
pub fn code_block_bold(attrs: List(Attribute(a))) -> Element(a)

code_block_duotone

</> 
pub fn code_block_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

code_block_fill

</> 
pub fn code_block_fill(attrs: List(Attribute(a))) -> Element(a)

code_block_light

</> 
pub fn code_block_light(attrs: List(Attribute(a))) -> Element(a)

code_block_regular

</> 
pub fn code_block_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

code_block_thin

</> 
pub fn code_block_thin(attrs: List(Attribute(a))) -> Element(a)

code_bold

</> 
pub fn code_bold(attrs: List(Attribute(a))) -> Element(a)

code_duotone

</> 
pub fn code_duotone(attrs: List(Attribute(a))) -> Element(a)

code_fill

</> 
pub fn code_fill(attrs: List(Attribute(a))) -> Element(a)

code_light

</> 
pub fn code_light(attrs: List(Attribute(a))) -> Element(a)

code_regular

</> 
pub fn code_regular(attrs: List(Attribute(a))) -> Element(a)

code_simple_bold

</> 
pub fn code_simple_bold(attrs: List(Attribute(a))) -> Element(a)

code_simple_duotone

</> 
pub fn code_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

code_simple_fill

</> 
pub fn code_simple_fill(attrs: List(Attribute(a))) -> Element(a)

code_simple_light

</> 
pub fn code_simple_light(attrs: List(Attribute(a))) -> Element(a)

code_simple_regular

</> 
pub fn code_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

code_simple_thin

</> 
pub fn code_simple_thin(attrs: List(Attribute(a))) -> Element(a)

code_thin

</> 
pub fn code_thin(attrs: List(Attribute(a))) -> Element(a)

codepen_logo_bold

</> 
pub fn codepen_logo_bold(attrs: List(Attribute(a))) -> Element(a)

codepen_logo_duotone

</> 
pub fn codepen_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

codepen_logo_fill

</> 
pub fn codepen_logo_fill(attrs: List(Attribute(a))) -> Element(a)

codepen_logo_light

</> 
pub fn codepen_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

codepen_logo_regular

</> 
pub fn codepen_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

codepen_logo_thin

</> 
pub fn codepen_logo_thin(attrs: List(Attribute(a))) -> Element(a)

codesandbox_logo_bold

</> 
pub fn codesandbox_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

codesandbox_logo_duotone

</> 
pub fn codesandbox_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

codesandbox_logo_fill

</> 
pub fn codesandbox_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

codesandbox_logo_light

</> 
pub fn codesandbox_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

codesandbox_logo_regular

</> 
pub fn codesandbox_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

codesandbox_logo_thin

</> 
pub fn codesandbox_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

coffee_bean_bold

</> 
pub fn coffee_bean_bold(attrs: List(Attribute(a))) -> Element(a)

coffee_bean_duotone

</> 
pub fn coffee_bean_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

coffee_bean_fill

</> 
pub fn coffee_bean_fill(attrs: List(Attribute(a))) -> Element(a)

coffee_bean_light

</> 
pub fn coffee_bean_light(attrs: List(Attribute(a))) -> Element(a)

coffee_bean_regular

</> 
pub fn coffee_bean_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

coffee_bean_thin

</> 
pub fn coffee_bean_thin(attrs: List(Attribute(a))) -> Element(a)

coffee_bold

</> 
pub fn coffee_bold(attrs: List(Attribute(a))) -> Element(a)

coffee_duotone

</> 
pub fn coffee_duotone(attrs: List(Attribute(a))) -> Element(a)

coffee_fill

</> 
pub fn coffee_fill(attrs: List(Attribute(a))) -> Element(a)

coffee_light

</> 
pub fn coffee_light(attrs: List(Attribute(a))) -> Element(a)

coffee_regular

</> 
pub fn coffee_regular(attrs: List(Attribute(a))) -> Element(a)

coffee_thin

</> 
pub fn coffee_thin(attrs: List(Attribute(a))) -> Element(a)

coin_bold

</> 
pub fn coin_bold(attrs: List(Attribute(a))) -> Element(a)

coin_duotone

</> 
pub fn coin_duotone(attrs: List(Attribute(a))) -> Element(a)

coin_fill

</> 
pub fn coin_fill(attrs: List(Attribute(a))) -> Element(a)

coin_light

</> 
pub fn coin_light(attrs: List(Attribute(a))) -> Element(a)

coin_regular

</> 
pub fn coin_regular(attrs: List(Attribute(a))) -> Element(a)

coin_thin

</> 
pub fn coin_thin(attrs: List(Attribute(a))) -> Element(a)

coin_vertical_bold

</> 
pub fn coin_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

coin_vertical_duotone

</> 
pub fn coin_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

coin_vertical_fill

</> 
pub fn coin_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

coin_vertical_light

</> 
pub fn coin_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

coin_vertical_regular

</> 
pub fn coin_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

coin_vertical_thin

</> 
pub fn coin_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

coins_bold

</> 
pub fn coins_bold(attrs: List(Attribute(a))) -> Element(a)

coins_duotone

</> 
pub fn coins_duotone(attrs: List(Attribute(a))) -> Element(a)

coins_fill

</> 
pub fn coins_fill(attrs: List(Attribute(a))) -> Element(a)

coins_light

</> 
pub fn coins_light(attrs: List(Attribute(a))) -> Element(a)

coins_regular

</> 
pub fn coins_regular(attrs: List(Attribute(a))) -> Element(a)

coins_thin

</> 
pub fn coins_thin(attrs: List(Attribute(a))) -> Element(a)

columns_bold

</> 
pub fn columns_bold(attrs: List(Attribute(a))) -> Element(a)

columns_duotone

</> 
pub fn columns_duotone(attrs: List(Attribute(a))) -> Element(a)

columns_fill

</> 
pub fn columns_fill(attrs: List(Attribute(a))) -> Element(a)

columns_light

</> 
pub fn columns_light(attrs: List(Attribute(a))) -> Element(a)

columns_plus_left_bold

</> 
pub fn columns_plus_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_left_duotone

</> 
pub fn columns_plus_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_left_fill

</> 
pub fn columns_plus_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_left_light

</> 
pub fn columns_plus_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_left_regular

</> 
pub fn columns_plus_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_left_thin

</> 
pub fn columns_plus_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_right_bold

</> 
pub fn columns_plus_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_right_duotone

</> 
pub fn columns_plus_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_right_fill

</> 
pub fn columns_plus_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_right_light

</> 
pub fn columns_plus_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_right_regular

</> 
pub fn columns_plus_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_plus_right_thin

</> 
pub fn columns_plus_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

columns_regular

</> 
pub fn columns_regular(attrs: List(Attribute(a))) -> Element(a)

columns_thin

</> 
pub fn columns_thin(attrs: List(Attribute(a))) -> Element(a)

command_bold

</> 
pub fn command_bold(attrs: List(Attribute(a))) -> Element(a)

command_duotone

</> 
pub fn command_duotone(attrs: List(Attribute(a))) -> Element(a)

command_fill

</> 
pub fn command_fill(attrs: List(Attribute(a))) -> Element(a)

command_light

</> 
pub fn command_light(attrs: List(Attribute(a))) -> Element(a)

command_regular

</> 
pub fn command_regular(attrs: List(Attribute(a))) -> Element(a)

command_thin

</> 
pub fn command_thin(attrs: List(Attribute(a))) -> Element(a)

compass_bold

</> 
pub fn compass_bold(attrs: List(Attribute(a))) -> Element(a)

compass_duotone

</> 
pub fn compass_duotone(attrs: List(Attribute(a))) -> Element(a)

compass_fill

</> 
pub fn compass_fill(attrs: List(Attribute(a))) -> Element(a)

compass_light

</> 
pub fn compass_light(attrs: List(Attribute(a))) -> Element(a)

compass_regular

</> 
pub fn compass_regular(attrs: List(Attribute(a))) -> Element(a)

compass_rose_bold

</> 
pub fn compass_rose_bold(attrs: List(Attribute(a))) -> Element(a)

compass_rose_duotone

</> 
pub fn compass_rose_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

compass_rose_fill

</> 
pub fn compass_rose_fill(attrs: List(Attribute(a))) -> Element(a)

compass_rose_light

</> 
pub fn compass_rose_light(
  attrs: List(Attribute(a)),
) -> Element(a)

compass_rose_regular

</> 
pub fn compass_rose_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

compass_rose_thin

</> 
pub fn compass_rose_thin(attrs: List(Attribute(a))) -> Element(a)

compass_thin

</> 
pub fn compass_thin(attrs: List(Attribute(a))) -> Element(a)

compass_tool_bold

</> 
pub fn compass_tool_bold(attrs: List(Attribute(a))) -> Element(a)

compass_tool_duotone

</> 
pub fn compass_tool_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

compass_tool_fill

</> 
pub fn compass_tool_fill(attrs: List(Attribute(a))) -> Element(a)

compass_tool_light

</> 
pub fn compass_tool_light(
  attrs: List(Attribute(a)),
) -> Element(a)

compass_tool_regular

</> 
pub fn compass_tool_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

compass_tool_thin

</> 
pub fn compass_tool_thin(attrs: List(Attribute(a))) -> Element(a)

computer_tower_bold

</> 
pub fn computer_tower_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

computer_tower_duotone

</> 
pub fn computer_tower_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

computer_tower_fill

</> 
pub fn computer_tower_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

computer_tower_light

</> 
pub fn computer_tower_light(
  attrs: List(Attribute(a)),
) -> Element(a)

computer_tower_regular

</> 
pub fn computer_tower_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

computer_tower_thin

</> 
pub fn computer_tower_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

confetti_bold

</> 
pub fn confetti_bold(attrs: List(Attribute(a))) -> Element(a)

confetti_duotone

</> 
pub fn confetti_duotone(attrs: List(Attribute(a))) -> Element(a)

confetti_fill

</> 
pub fn confetti_fill(attrs: List(Attribute(a))) -> Element(a)

confetti_light

</> 
pub fn confetti_light(attrs: List(Attribute(a))) -> Element(a)

confetti_regular

</> 
pub fn confetti_regular(attrs: List(Attribute(a))) -> Element(a)

confetti_thin

</> 
pub fn confetti_thin(attrs: List(Attribute(a))) -> Element(a)

contactless_payment_bold

</> 
pub fn contactless_payment_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

contactless_payment_duotone

</> 
pub fn contactless_payment_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

contactless_payment_fill

</> 
pub fn contactless_payment_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

contactless_payment_light

</> 
pub fn contactless_payment_light(
  attrs: List(Attribute(a)),
) -> Element(a)

contactless_payment_regular

</> 
pub fn contactless_payment_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

contactless_payment_thin

</> 
pub fn contactless_payment_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

control_bold

</> 
pub fn control_bold(attrs: List(Attribute(a))) -> Element(a)

control_duotone

</> 
pub fn control_duotone(attrs: List(Attribute(a))) -> Element(a)

control_fill

</> 
pub fn control_fill(attrs: List(Attribute(a))) -> Element(a)

control_light

</> 
pub fn control_light(attrs: List(Attribute(a))) -> Element(a)

control_regular

</> 
pub fn control_regular(attrs: List(Attribute(a))) -> Element(a)

control_thin

</> 
pub fn control_thin(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn cookie_bold(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn cookie_duotone(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn cookie_fill(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn cookie_light(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn cookie_regular(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn cookie_thin(attrs: List(Attribute(a))) -> Element(a)

cooking_pot_bold

</> 
pub fn cooking_pot_bold(attrs: List(Attribute(a))) -> Element(a)

cooking_pot_duotone

</> 
pub fn cooking_pot_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cooking_pot_fill

</> 
pub fn cooking_pot_fill(attrs: List(Attribute(a))) -> Element(a)

cooking_pot_light

</> 
pub fn cooking_pot_light(attrs: List(Attribute(a))) -> Element(a)

cooking_pot_regular

</> 
pub fn cooking_pot_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cooking_pot_thin

</> 
pub fn cooking_pot_thin(attrs: List(Attribute(a))) -> Element(a)

copy_bold

</> 
pub fn copy_bold(attrs: List(Attribute(a))) -> Element(a)

copy_duotone

</> 
pub fn copy_duotone(attrs: List(Attribute(a))) -> Element(a)

copy_fill

</> 
pub fn copy_fill(attrs: List(Attribute(a))) -> Element(a)

copy_light

</> 
pub fn copy_light(attrs: List(Attribute(a))) -> Element(a)

copy_regular

</> 
pub fn copy_regular(attrs: List(Attribute(a))) -> Element(a)

copy_simple_bold

</> 
pub fn copy_simple_bold(attrs: List(Attribute(a))) -> Element(a)

copy_simple_duotone

</> 
pub fn copy_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

copy_simple_fill

</> 
pub fn copy_simple_fill(attrs: List(Attribute(a))) -> Element(a)

copy_simple_light

</> 
pub fn copy_simple_light(attrs: List(Attribute(a))) -> Element(a)

copy_simple_regular

</> 
pub fn copy_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

copy_simple_thin

</> 
pub fn copy_simple_thin(attrs: List(Attribute(a))) -> Element(a)

copy_thin

</> 
pub fn copy_thin(attrs: List(Attribute(a))) -> Element(a)

copyleft_bold

</> 
pub fn copyleft_bold(attrs: List(Attribute(a))) -> Element(a)

copyleft_duotone

</> 
pub fn copyleft_duotone(attrs: List(Attribute(a))) -> Element(a)

copyleft_fill

</> 
pub fn copyleft_fill(attrs: List(Attribute(a))) -> Element(a)

copyleft_light

</> 
pub fn copyleft_light(attrs: List(Attribute(a))) -> Element(a)

copyleft_regular

</> 
pub fn copyleft_regular(attrs: List(Attribute(a))) -> Element(a)

copyleft_thin

</> 
pub fn copyleft_thin(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn copyright_bold(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn copyright_duotone(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn copyright_fill(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn copyright_light(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn copyright_regular(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn copyright_thin(attrs: List(Attribute(a))) -> Element(a)

corners_in_bold

</> 
pub fn corners_in_bold(attrs: List(Attribute(a))) -> Element(a)

corners_in_duotone

</> 
pub fn corners_in_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

corners_in_fill

</> 
pub fn corners_in_fill(attrs: List(Attribute(a))) -> Element(a)

corners_in_light

</> 
pub fn corners_in_light(attrs: List(Attribute(a))) -> Element(a)

corners_in_regular

</> 
pub fn corners_in_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

corners_in_thin

</> 
pub fn corners_in_thin(attrs: List(Attribute(a))) -> Element(a)

corners_out_bold

</> 
pub fn corners_out_bold(attrs: List(Attribute(a))) -> Element(a)

corners_out_duotone

</> 
pub fn corners_out_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

corners_out_fill

</> 
pub fn corners_out_fill(attrs: List(Attribute(a))) -> Element(a)

corners_out_light

</> 
pub fn corners_out_light(attrs: List(Attribute(a))) -> Element(a)

corners_out_regular

</> 
pub fn corners_out_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

corners_out_thin

</> 
pub fn corners_out_thin(attrs: List(Attribute(a))) -> Element(a)

couch_bold

</> 
pub fn couch_bold(attrs: List(Attribute(a))) -> Element(a)

couch_duotone

</> 
pub fn couch_duotone(attrs: List(Attribute(a))) -> Element(a)

couch_fill

</> 
pub fn couch_fill(attrs: List(Attribute(a))) -> Element(a)

couch_light

</> 
pub fn couch_light(attrs: List(Attribute(a))) -> Element(a)

couch_regular

</> 
pub fn couch_regular(attrs: List(Attribute(a))) -> Element(a)

couch_thin

</> 
pub fn couch_thin(attrs: List(Attribute(a))) -> Element(a)

court_basketball_bold

</> 
pub fn court_basketball_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

court_basketball_duotone

</> 
pub fn court_basketball_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

court_basketball_fill

</> 
pub fn court_basketball_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

court_basketball_light

</> 
pub fn court_basketball_light(
  attrs: List(Attribute(a)),
) -> Element(a)

court_basketball_regular

</> 
pub fn court_basketball_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

court_basketball_thin

</> 
pub fn court_basketball_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

cow_bold

</> 
pub fn cow_bold(attrs: List(Attribute(a))) -> Element(a)

cow_duotone

</> 
pub fn cow_duotone(attrs: List(Attribute(a))) -> Element(a)

cow_fill

</> 
pub fn cow_fill(attrs: List(Attribute(a))) -> Element(a)

cow_light

</> 
pub fn cow_light(attrs: List(Attribute(a))) -> Element(a)

cow_regular

</> 
pub fn cow_regular(attrs: List(Attribute(a))) -> Element(a)

cow_thin

</> 
pub fn cow_thin(attrs: List(Attribute(a))) -> Element(a)

cowboy_hat_bold

</> 
pub fn cowboy_hat_bold(attrs: List(Attribute(a))) -> Element(a)

cowboy_hat_duotone

</> 
pub fn cowboy_hat_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cowboy_hat_fill

</> 
pub fn cowboy_hat_fill(attrs: List(Attribute(a))) -> Element(a)

cowboy_hat_light

</> 
pub fn cowboy_hat_light(attrs: List(Attribute(a))) -> Element(a)

cowboy_hat_regular

</> 
pub fn cowboy_hat_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cowboy_hat_thin

</> 
pub fn cowboy_hat_thin(attrs: List(Attribute(a))) -> Element(a)

cpu_bold

</> 
pub fn cpu_bold(attrs: List(Attribute(a))) -> Element(a)

cpu_duotone

</> 
pub fn cpu_duotone(attrs: List(Attribute(a))) -> Element(a)

cpu_fill

</> 
pub fn cpu_fill(attrs: List(Attribute(a))) -> Element(a)

cpu_light

</> 
pub fn cpu_light(attrs: List(Attribute(a))) -> Element(a)

cpu_regular

</> 
pub fn cpu_regular(attrs: List(Attribute(a))) -> Element(a)

cpu_thin

</> 
pub fn cpu_thin(attrs: List(Attribute(a))) -> Element(a)

crane_bold

</> 
pub fn crane_bold(attrs: List(Attribute(a))) -> Element(a)

crane_duotone

</> 
pub fn crane_duotone(attrs: List(Attribute(a))) -> Element(a)

crane_fill

</> 
pub fn crane_fill(attrs: List(Attribute(a))) -> Element(a)

crane_light

</> 
pub fn crane_light(attrs: List(Attribute(a))) -> Element(a)

crane_regular

</> 
pub fn crane_regular(attrs: List(Attribute(a))) -> Element(a)

crane_thin

</> 
pub fn crane_thin(attrs: List(Attribute(a))) -> Element(a)

crane_tower_bold

</> 
pub fn crane_tower_bold(attrs: List(Attribute(a))) -> Element(a)

crane_tower_duotone

</> 
pub fn crane_tower_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

crane_tower_fill

</> 
pub fn crane_tower_fill(attrs: List(Attribute(a))) -> Element(a)

crane_tower_light

</> 
pub fn crane_tower_light(attrs: List(Attribute(a))) -> Element(a)

crane_tower_regular

</> 
pub fn crane_tower_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

crane_tower_thin

</> 
pub fn crane_tower_thin(attrs: List(Attribute(a))) -> Element(a)

credit_card_bold

</> 
pub fn credit_card_bold(attrs: List(Attribute(a))) -> Element(a)

credit_card_duotone

</> 
pub fn credit_card_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

credit_card_fill

</> 
pub fn credit_card_fill(attrs: List(Attribute(a))) -> Element(a)

credit_card_light

</> 
pub fn credit_card_light(attrs: List(Attribute(a))) -> Element(a)

credit_card_regular

</> 
pub fn credit_card_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

credit_card_thin

</> 
pub fn credit_card_thin(attrs: List(Attribute(a))) -> Element(a)

cricket_bold

</> 
pub fn cricket_bold(attrs: List(Attribute(a))) -> Element(a)

cricket_duotone

</> 
pub fn cricket_duotone(attrs: List(Attribute(a))) -> Element(a)

cricket_fill

</> 
pub fn cricket_fill(attrs: List(Attribute(a))) -> Element(a)

cricket_light

</> 
pub fn cricket_light(attrs: List(Attribute(a))) -> Element(a)

cricket_regular

</> 
pub fn cricket_regular(attrs: List(Attribute(a))) -> Element(a)

cricket_thin

</> 
pub fn cricket_thin(attrs: List(Attribute(a))) -> Element(a)

crop_bold

</> 
pub fn crop_bold(attrs: List(Attribute(a))) -> Element(a)

crop_duotone

</> 
pub fn crop_duotone(attrs: List(Attribute(a))) -> Element(a)

crop_fill

</> 
pub fn crop_fill(attrs: List(Attribute(a))) -> Element(a)

crop_light

</> 
pub fn crop_light(attrs: List(Attribute(a))) -> Element(a)

crop_regular

</> 
pub fn crop_regular(attrs: List(Attribute(a))) -> Element(a)

crop_thin

</> 
pub fn crop_thin(attrs: List(Attribute(a))) -> Element(a)

cross_bold

</> 
pub fn cross_bold(attrs: List(Attribute(a))) -> Element(a)

cross_duotone

</> 
pub fn cross_duotone(attrs: List(Attribute(a))) -> Element(a)

cross_fill

</> 
pub fn cross_fill(attrs: List(Attribute(a))) -> Element(a)

cross_light

</> 
pub fn cross_light(attrs: List(Attribute(a))) -> Element(a)

cross_regular

</> 
pub fn cross_regular(attrs: List(Attribute(a))) -> Element(a)

cross_thin

</> 
pub fn cross_thin(attrs: List(Attribute(a))) -> Element(a)

crosshair_bold

</> 
pub fn crosshair_bold(attrs: List(Attribute(a))) -> Element(a)

crosshair_duotone

</> 
pub fn crosshair_duotone(attrs: List(Attribute(a))) -> Element(a)

crosshair_fill

</> 
pub fn crosshair_fill(attrs: List(Attribute(a))) -> Element(a)

crosshair_light

</> 
pub fn crosshair_light(attrs: List(Attribute(a))) -> Element(a)

crosshair_regular

</> 
pub fn crosshair_regular(attrs: List(Attribute(a))) -> Element(a)

crosshair_simple_bold

</> 
pub fn crosshair_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

crosshair_simple_duotone

</> 
pub fn crosshair_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

crosshair_simple_fill

</> 
pub fn crosshair_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

crosshair_simple_light

</> 
pub fn crosshair_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

crosshair_simple_regular

</> 
pub fn crosshair_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

crosshair_simple_thin

</> 
pub fn crosshair_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

crosshair_thin

</> 
pub fn crosshair_thin(attrs: List(Attribute(a))) -> Element(a)

crown_bold

</> 
pub fn crown_bold(attrs: List(Attribute(a))) -> Element(a)

crown_cross_bold

</> 
pub fn crown_cross_bold(attrs: List(Attribute(a))) -> Element(a)

crown_cross_duotone

</> 
pub fn crown_cross_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

crown_cross_fill

</> 
pub fn crown_cross_fill(attrs: List(Attribute(a))) -> Element(a)

crown_cross_light

</> 
pub fn crown_cross_light(attrs: List(Attribute(a))) -> Element(a)

crown_cross_regular

</> 
pub fn crown_cross_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

crown_cross_thin

</> 
pub fn crown_cross_thin(attrs: List(Attribute(a))) -> Element(a)

crown_duotone

</> 
pub fn crown_duotone(attrs: List(Attribute(a))) -> Element(a)

crown_fill

</> 
pub fn crown_fill(attrs: List(Attribute(a))) -> Element(a)

crown_light

</> 
pub fn crown_light(attrs: List(Attribute(a))) -> Element(a)

crown_regular

</> 
pub fn crown_regular(attrs: List(Attribute(a))) -> Element(a)

crown_simple_bold

</> 
pub fn crown_simple_bold(attrs: List(Attribute(a))) -> Element(a)

crown_simple_duotone

</> 
pub fn crown_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

crown_simple_fill

</> 
pub fn crown_simple_fill(attrs: List(Attribute(a))) -> Element(a)

crown_simple_light

</> 
pub fn crown_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

crown_simple_regular

</> 
pub fn crown_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

crown_simple_thin

</> 
pub fn crown_simple_thin(attrs: List(Attribute(a))) -> Element(a)

crown_thin

</> 
pub fn crown_thin(attrs: List(Attribute(a))) -> Element(a)

cube_bold

</> 
pub fn cube_bold(attrs: List(Attribute(a))) -> Element(a)

cube_duotone

</> 
pub fn cube_duotone(attrs: List(Attribute(a))) -> Element(a)

cube_fill

</> 
pub fn cube_fill(attrs: List(Attribute(a))) -> Element(a)

cube_focus_bold

</> 
pub fn cube_focus_bold(attrs: List(Attribute(a))) -> Element(a)

cube_focus_duotone

</> 
pub fn cube_focus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cube_focus_fill

</> 
pub fn cube_focus_fill(attrs: List(Attribute(a))) -> Element(a)

cube_focus_light

</> 
pub fn cube_focus_light(attrs: List(Attribute(a))) -> Element(a)

cube_focus_regular

</> 
pub fn cube_focus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cube_focus_thin

</> 
pub fn cube_focus_thin(attrs: List(Attribute(a))) -> Element(a)

cube_light

</> 
pub fn cube_light(attrs: List(Attribute(a))) -> Element(a)

cube_regular

</> 
pub fn cube_regular(attrs: List(Attribute(a))) -> Element(a)

cube_thin

</> 
pub fn cube_thin(attrs: List(Attribute(a))) -> Element(a)

cube_transparent_bold

</> 
pub fn cube_transparent_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

cube_transparent_duotone

</> 
pub fn cube_transparent_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cube_transparent_fill

</> 
pub fn cube_transparent_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

cube_transparent_light

</> 
pub fn cube_transparent_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cube_transparent_regular

</> 
pub fn cube_transparent_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cube_transparent_thin

</> 
pub fn cube_transparent_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_btc_bold

</> 
pub fn currency_btc_bold(attrs: List(Attribute(a))) -> Element(a)

currency_btc_duotone

</> 
pub fn currency_btc_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_btc_fill

</> 
pub fn currency_btc_fill(attrs: List(Attribute(a))) -> Element(a)

currency_btc_light

</> 
pub fn currency_btc_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_btc_regular

</> 
pub fn currency_btc_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_btc_thin

</> 
pub fn currency_btc_thin(attrs: List(Attribute(a))) -> Element(a)

currency_circle_dollar_bold

</> 
pub fn currency_circle_dollar_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_circle_dollar_duotone

</> 
pub fn currency_circle_dollar_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_circle_dollar_fill

</> 
pub fn currency_circle_dollar_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_circle_dollar_light

</> 
pub fn currency_circle_dollar_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_circle_dollar_regular

</> 
pub fn currency_circle_dollar_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_circle_dollar_thin

</> 
pub fn currency_circle_dollar_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_cny_bold

</> 
pub fn currency_cny_bold(attrs: List(Attribute(a))) -> Element(a)

currency_cny_duotone

</> 
pub fn currency_cny_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_cny_fill

</> 
pub fn currency_cny_fill(attrs: List(Attribute(a))) -> Element(a)

currency_cny_light

</> 
pub fn currency_cny_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_cny_regular

</> 
pub fn currency_cny_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_cny_thin

</> 
pub fn currency_cny_thin(attrs: List(Attribute(a))) -> Element(a)

currency_dollar_bold

</> 
pub fn currency_dollar_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_duotone

</> 
pub fn currency_dollar_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_fill

</> 
pub fn currency_dollar_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_light

</> 
pub fn currency_dollar_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_regular

</> 
pub fn currency_dollar_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_simple_bold

</> 
pub fn currency_dollar_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_simple_duotone

</> 
pub fn currency_dollar_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_simple_fill

</> 
pub fn currency_dollar_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_simple_light

</> 
pub fn currency_dollar_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_simple_regular

</> 
pub fn currency_dollar_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_simple_thin

</> 
pub fn currency_dollar_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_dollar_thin

</> 
pub fn currency_dollar_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_eth_bold

</> 
pub fn currency_eth_bold(attrs: List(Attribute(a))) -> Element(a)

currency_eth_duotone

</> 
pub fn currency_eth_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_eth_fill

</> 
pub fn currency_eth_fill(attrs: List(Attribute(a))) -> Element(a)

currency_eth_light

</> 
pub fn currency_eth_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_eth_regular

</> 
pub fn currency_eth_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_eth_thin

</> 
pub fn currency_eth_thin(attrs: List(Attribute(a))) -> Element(a)

currency_eur_bold

</> 
pub fn currency_eur_bold(attrs: List(Attribute(a))) -> Element(a)

currency_eur_duotone

</> 
pub fn currency_eur_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_eur_fill

</> 
pub fn currency_eur_fill(attrs: List(Attribute(a))) -> Element(a)

currency_eur_light

</> 
pub fn currency_eur_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_eur_regular

</> 
pub fn currency_eur_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_eur_thin

</> 
pub fn currency_eur_thin(attrs: List(Attribute(a))) -> Element(a)

currency_gbp_bold

</> 
pub fn currency_gbp_bold(attrs: List(Attribute(a))) -> Element(a)

currency_gbp_duotone

</> 
pub fn currency_gbp_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_gbp_fill

</> 
pub fn currency_gbp_fill(attrs: List(Attribute(a))) -> Element(a)

currency_gbp_light

</> 
pub fn currency_gbp_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_gbp_regular

</> 
pub fn currency_gbp_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_gbp_thin

</> 
pub fn currency_gbp_thin(attrs: List(Attribute(a))) -> Element(a)

currency_inr_bold

</> 
pub fn currency_inr_bold(attrs: List(Attribute(a))) -> Element(a)

currency_inr_duotone

</> 
pub fn currency_inr_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_inr_fill

</> 
pub fn currency_inr_fill(attrs: List(Attribute(a))) -> Element(a)

currency_inr_light

</> 
pub fn currency_inr_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_inr_regular

</> 
pub fn currency_inr_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_inr_thin

</> 
pub fn currency_inr_thin(attrs: List(Attribute(a))) -> Element(a)

currency_jpy_bold

</> 
pub fn currency_jpy_bold(attrs: List(Attribute(a))) -> Element(a)

currency_jpy_duotone

</> 
pub fn currency_jpy_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_jpy_fill

</> 
pub fn currency_jpy_fill(attrs: List(Attribute(a))) -> Element(a)

currency_jpy_light

</> 
pub fn currency_jpy_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_jpy_regular

</> 
pub fn currency_jpy_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_jpy_thin

</> 
pub fn currency_jpy_thin(attrs: List(Attribute(a))) -> Element(a)

currency_krw_bold

</> 
pub fn currency_krw_bold(attrs: List(Attribute(a))) -> Element(a)

currency_krw_duotone

</> 
pub fn currency_krw_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_krw_fill

</> 
pub fn currency_krw_fill(attrs: List(Attribute(a))) -> Element(a)

currency_krw_light

</> 
pub fn currency_krw_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_krw_regular

</> 
pub fn currency_krw_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_krw_thin

</> 
pub fn currency_krw_thin(attrs: List(Attribute(a))) -> Element(a)

currency_kzt_bold

</> 
pub fn currency_kzt_bold(attrs: List(Attribute(a))) -> Element(a)

currency_kzt_duotone

</> 
pub fn currency_kzt_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_kzt_fill

</> 
pub fn currency_kzt_fill(attrs: List(Attribute(a))) -> Element(a)

currency_kzt_light

</> 
pub fn currency_kzt_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_kzt_regular

</> 
pub fn currency_kzt_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_kzt_thin

</> 
pub fn currency_kzt_thin(attrs: List(Attribute(a))) -> Element(a)

currency_ngn_bold

</> 
pub fn currency_ngn_bold(attrs: List(Attribute(a))) -> Element(a)

currency_ngn_duotone

</> 
pub fn currency_ngn_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_ngn_fill

</> 
pub fn currency_ngn_fill(attrs: List(Attribute(a))) -> Element(a)

currency_ngn_light

</> 
pub fn currency_ngn_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_ngn_regular

</> 
pub fn currency_ngn_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_ngn_thin

</> 
pub fn currency_ngn_thin(attrs: List(Attribute(a))) -> Element(a)

currency_rub_bold

</> 
pub fn currency_rub_bold(attrs: List(Attribute(a))) -> Element(a)

currency_rub_duotone

</> 
pub fn currency_rub_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_rub_fill

</> 
pub fn currency_rub_fill(attrs: List(Attribute(a))) -> Element(a)

currency_rub_light

</> 
pub fn currency_rub_light(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_rub_regular

</> 
pub fn currency_rub_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

currency_rub_thin

</> 
pub fn currency_rub_thin(attrs: List(Attribute(a))) -> Element(a)

cursor_bold

</> 
pub fn cursor_bold(attrs: List(Attribute(a))) -> Element(a)

cursor_click_bold

</> 
pub fn cursor_click_bold(attrs: List(Attribute(a))) -> Element(a)

cursor_click_duotone

</> 
pub fn cursor_click_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cursor_click_fill

</> 
pub fn cursor_click_fill(attrs: List(Attribute(a))) -> Element(a)

cursor_click_light

</> 
pub fn cursor_click_light(
  attrs: List(Attribute(a)),
) -> Element(a)

cursor_click_regular

</> 
pub fn cursor_click_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cursor_click_thin

</> 
pub fn cursor_click_thin(attrs: List(Attribute(a))) -> Element(a)

cursor_duotone

</> 
pub fn cursor_duotone(attrs: List(Attribute(a))) -> Element(a)

cursor_fill

</> 
pub fn cursor_fill(attrs: List(Attribute(a))) -> Element(a)

cursor_light

</> 
pub fn cursor_light(attrs: List(Attribute(a))) -> Element(a)

cursor_regular

</> 
pub fn cursor_regular(attrs: List(Attribute(a))) -> Element(a)

cursor_text_bold

</> 
pub fn cursor_text_bold(attrs: List(Attribute(a))) -> Element(a)

cursor_text_duotone

</> 
pub fn cursor_text_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

cursor_text_fill

</> 
pub fn cursor_text_fill(attrs: List(Attribute(a))) -> Element(a)

cursor_text_light

</> 
pub fn cursor_text_light(attrs: List(Attribute(a))) -> Element(a)

cursor_text_regular

</> 
pub fn cursor_text_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

cursor_text_thin

</> 
pub fn cursor_text_thin(attrs: List(Attribute(a))) -> Element(a)

cursor_thin

</> 
pub fn cursor_thin(attrs: List(Attribute(a))) -> Element(a)

cylinder_bold

</> 
pub fn cylinder_bold(attrs: List(Attribute(a))) -> Element(a)

cylinder_duotone

</> 
pub fn cylinder_duotone(attrs: List(Attribute(a))) -> Element(a)

cylinder_fill

</> 
pub fn cylinder_fill(attrs: List(Attribute(a))) -> Element(a)

cylinder_light

</> 
pub fn cylinder_light(attrs: List(Attribute(a))) -> Element(a)

cylinder_regular

</> 
pub fn cylinder_regular(attrs: List(Attribute(a))) -> Element(a)

cylinder_thin

</> 
pub fn cylinder_thin(attrs: List(Attribute(a))) -> Element(a)

database_bold

</> 
pub fn database_bold(attrs: List(Attribute(a))) -> Element(a)

database_duotone

</> 
pub fn database_duotone(attrs: List(Attribute(a))) -> Element(a)

database_fill

</> 
pub fn database_fill(attrs: List(Attribute(a))) -> Element(a)

database_light

</> 
pub fn database_light(attrs: List(Attribute(a))) -> Element(a)

database_regular

</> 
pub fn database_regular(attrs: List(Attribute(a))) -> Element(a)

database_thin

</> 
pub fn database_thin(attrs: List(Attribute(a))) -> Element(a)

desk_bold

</> 
pub fn desk_bold(attrs: List(Attribute(a))) -> Element(a)

desk_duotone

</> 
pub fn desk_duotone(attrs: List(Attribute(a))) -> Element(a)

desk_fill

</> 
pub fn desk_fill(attrs: List(Attribute(a))) -> Element(a)

desk_light

</> 
pub fn desk_light(attrs: List(Attribute(a))) -> Element(a)

desk_regular

</> 
pub fn desk_regular(attrs: List(Attribute(a))) -> Element(a)

desk_thin

</> 
pub fn desk_thin(attrs: List(Attribute(a))) -> Element(a)

desktop_bold

</> 
pub fn desktop_bold(attrs: List(Attribute(a))) -> Element(a)

desktop_duotone

</> 
pub fn desktop_duotone(attrs: List(Attribute(a))) -> Element(a)

desktop_fill

</> 
pub fn desktop_fill(attrs: List(Attribute(a))) -> Element(a)

desktop_light

</> 
pub fn desktop_light(attrs: List(Attribute(a))) -> Element(a)

desktop_regular

</> 
pub fn desktop_regular(attrs: List(Attribute(a))) -> Element(a)

desktop_thin

</> 
pub fn desktop_thin(attrs: List(Attribute(a))) -> Element(a)

desktop_tower_bold

</> 
pub fn desktop_tower_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

desktop_tower_duotone

</> 
pub fn desktop_tower_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

desktop_tower_fill

</> 
pub fn desktop_tower_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

desktop_tower_light

</> 
pub fn desktop_tower_light(
  attrs: List(Attribute(a)),
) -> Element(a)

desktop_tower_regular

</> 
pub fn desktop_tower_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

desktop_tower_thin

</> 
pub fn desktop_tower_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

detective_bold

</> 
pub fn detective_bold(attrs: List(Attribute(a))) -> Element(a)

detective_duotone

</> 
pub fn detective_duotone(attrs: List(Attribute(a))) -> Element(a)

detective_fill

</> 
pub fn detective_fill(attrs: List(Attribute(a))) -> Element(a)

detective_light

</> 
pub fn detective_light(attrs: List(Attribute(a))) -> Element(a)

detective_regular

</> 
pub fn detective_regular(attrs: List(Attribute(a))) -> Element(a)

detective_thin

</> 
pub fn detective_thin(attrs: List(Attribute(a))) -> Element(a)

dev_to_logo_bold

</> 
pub fn dev_to_logo_bold(attrs: List(Attribute(a))) -> Element(a)

dev_to_logo_duotone

</> 
pub fn dev_to_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dev_to_logo_fill

</> 
pub fn dev_to_logo_fill(attrs: List(Attribute(a))) -> Element(a)

dev_to_logo_light

</> 
pub fn dev_to_logo_light(attrs: List(Attribute(a))) -> Element(a)

dev_to_logo_regular

</> 
pub fn dev_to_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dev_to_logo_thin

</> 
pub fn dev_to_logo_thin(attrs: List(Attribute(a))) -> Element(a)

device_mobile_bold

</> 
pub fn device_mobile_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_camera_bold

</> 
pub fn device_mobile_camera_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_camera_duotone

</> 
pub fn device_mobile_camera_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_camera_fill

</> 
pub fn device_mobile_camera_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_camera_light

</> 
pub fn device_mobile_camera_light(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_camera_regular

</> 
pub fn device_mobile_camera_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_camera_thin

</> 
pub fn device_mobile_camera_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_duotone

</> 
pub fn device_mobile_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_fill

</> 
pub fn device_mobile_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_light

</> 
pub fn device_mobile_light(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_regular

</> 
pub fn device_mobile_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_slash_bold

</> 
pub fn device_mobile_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_slash_duotone

</> 
pub fn device_mobile_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_slash_fill

</> 
pub fn device_mobile_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_slash_light

</> 
pub fn device_mobile_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_slash_regular

</> 
pub fn device_mobile_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_slash_thin

</> 
pub fn device_mobile_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_speaker_bold

</> 
pub fn device_mobile_speaker_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_speaker_duotone

</> 
pub fn device_mobile_speaker_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_speaker_fill

</> 
pub fn device_mobile_speaker_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_speaker_light

</> 
pub fn device_mobile_speaker_light(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_speaker_regular

</> 
pub fn device_mobile_speaker_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_speaker_thin

</> 
pub fn device_mobile_speaker_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

device_mobile_thin

</> 
pub fn device_mobile_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

device_rotate_bold

</> 
pub fn device_rotate_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

device_rotate_duotone

</> 
pub fn device_rotate_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

device_rotate_fill

</> 
pub fn device_rotate_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

device_rotate_light

</> 
pub fn device_rotate_light(
  attrs: List(Attribute(a)),
) -> Element(a)

device_rotate_regular

</> 
pub fn device_rotate_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

device_rotate_thin

</> 
pub fn device_rotate_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_bold

</> 
pub fn device_tablet_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_camera_bold

</> 
pub fn device_tablet_camera_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_camera_duotone

</> 
pub fn device_tablet_camera_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_camera_fill

</> 
pub fn device_tablet_camera_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_camera_light

</> 
pub fn device_tablet_camera_light(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_camera_regular

</> 
pub fn device_tablet_camera_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_camera_thin

</> 
pub fn device_tablet_camera_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_duotone

</> 
pub fn device_tablet_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_fill

</> 
pub fn device_tablet_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_light

</> 
pub fn device_tablet_light(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_regular

</> 
pub fn device_tablet_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_speaker_bold

</> 
pub fn device_tablet_speaker_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_speaker_duotone

</> 
pub fn device_tablet_speaker_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_speaker_fill

</> 
pub fn device_tablet_speaker_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_speaker_light

</> 
pub fn device_tablet_speaker_light(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_speaker_regular

</> 
pub fn device_tablet_speaker_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_speaker_thin

</> 
pub fn device_tablet_speaker_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

device_tablet_thin

</> 
pub fn device_tablet_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

devices_bold

</> 
pub fn devices_bold(attrs: List(Attribute(a))) -> Element(a)

devices_duotone

</> 
pub fn devices_duotone(attrs: List(Attribute(a))) -> Element(a)

devices_fill

</> 
pub fn devices_fill(attrs: List(Attribute(a))) -> Element(a)

devices_light

</> 
pub fn devices_light(attrs: List(Attribute(a))) -> Element(a)

devices_regular

</> 
pub fn devices_regular(attrs: List(Attribute(a))) -> Element(a)

devices_thin

</> 
pub fn devices_thin(attrs: List(Attribute(a))) -> Element(a)

diamond_bold

</> 
pub fn diamond_bold(attrs: List(Attribute(a))) -> Element(a)

diamond_duotone

</> 
pub fn diamond_duotone(attrs: List(Attribute(a))) -> Element(a)

diamond_fill

</> 
pub fn diamond_fill(attrs: List(Attribute(a))) -> Element(a)

diamond_light

</> 
pub fn diamond_light(attrs: List(Attribute(a))) -> Element(a)

diamond_regular

</> 
pub fn diamond_regular(attrs: List(Attribute(a))) -> Element(a)

diamond_thin

</> 
pub fn diamond_thin(attrs: List(Attribute(a))) -> Element(a)

diamonds_four_bold

</> 
pub fn diamonds_four_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

diamonds_four_duotone

</> 
pub fn diamonds_four_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

diamonds_four_fill

</> 
pub fn diamonds_four_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

diamonds_four_light

</> 
pub fn diamonds_four_light(
  attrs: List(Attribute(a)),
) -> Element(a)

diamonds_four_regular

</> 
pub fn diamonds_four_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

diamonds_four_thin

</> 
pub fn diamonds_four_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

dice_five_bold

</> 
pub fn dice_five_bold(attrs: List(Attribute(a))) -> Element(a)

dice_five_duotone

</> 
pub fn dice_five_duotone(attrs: List(Attribute(a))) -> Element(a)

dice_five_fill

</> 
pub fn dice_five_fill(attrs: List(Attribute(a))) -> Element(a)

dice_five_light

</> 
pub fn dice_five_light(attrs: List(Attribute(a))) -> Element(a)

dice_five_regular

</> 
pub fn dice_five_regular(attrs: List(Attribute(a))) -> Element(a)

dice_five_thin

</> 
pub fn dice_five_thin(attrs: List(Attribute(a))) -> Element(a)

dice_four_bold

</> 
pub fn dice_four_bold(attrs: List(Attribute(a))) -> Element(a)

dice_four_duotone

</> 
pub fn dice_four_duotone(attrs: List(Attribute(a))) -> Element(a)

dice_four_fill

</> 
pub fn dice_four_fill(attrs: List(Attribute(a))) -> Element(a)

dice_four_light

</> 
pub fn dice_four_light(attrs: List(Attribute(a))) -> Element(a)

dice_four_regular

</> 
pub fn dice_four_regular(attrs: List(Attribute(a))) -> Element(a)

dice_four_thin

</> 
pub fn dice_four_thin(attrs: List(Attribute(a))) -> Element(a)

dice_one_bold

</> 
pub fn dice_one_bold(attrs: List(Attribute(a))) -> Element(a)

dice_one_duotone

</> 
pub fn dice_one_duotone(attrs: List(Attribute(a))) -> Element(a)

dice_one_fill

</> 
pub fn dice_one_fill(attrs: List(Attribute(a))) -> Element(a)

dice_one_light

</> 
pub fn dice_one_light(attrs: List(Attribute(a))) -> Element(a)

dice_one_regular

</> 
pub fn dice_one_regular(attrs: List(Attribute(a))) -> Element(a)

dice_one_thin

</> 
pub fn dice_one_thin(attrs: List(Attribute(a))) -> Element(a)

dice_six_bold

</> 
pub fn dice_six_bold(attrs: List(Attribute(a))) -> Element(a)

dice_six_duotone

</> 
pub fn dice_six_duotone(attrs: List(Attribute(a))) -> Element(a)

dice_six_fill

</> 
pub fn dice_six_fill(attrs: List(Attribute(a))) -> Element(a)

dice_six_light

</> 
pub fn dice_six_light(attrs: List(Attribute(a))) -> Element(a)

dice_six_regular

</> 
pub fn dice_six_regular(attrs: List(Attribute(a))) -> Element(a)

dice_six_thin

</> 
pub fn dice_six_thin(attrs: List(Attribute(a))) -> Element(a)

dice_three_bold

</> 
pub fn dice_three_bold(attrs: List(Attribute(a))) -> Element(a)

dice_three_duotone

</> 
pub fn dice_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dice_three_fill

</> 
pub fn dice_three_fill(attrs: List(Attribute(a))) -> Element(a)

dice_three_light

</> 
pub fn dice_three_light(attrs: List(Attribute(a))) -> Element(a)

dice_three_regular

</> 
pub fn dice_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dice_three_thin

</> 
pub fn dice_three_thin(attrs: List(Attribute(a))) -> Element(a)

dice_two_bold

</> 
pub fn dice_two_bold(attrs: List(Attribute(a))) -> Element(a)

dice_two_duotone

</> 
pub fn dice_two_duotone(attrs: List(Attribute(a))) -> Element(a)

dice_two_fill

</> 
pub fn dice_two_fill(attrs: List(Attribute(a))) -> Element(a)

dice_two_light

</> 
pub fn dice_two_light(attrs: List(Attribute(a))) -> Element(a)

dice_two_regular

</> 
pub fn dice_two_regular(attrs: List(Attribute(a))) -> Element(a)

dice_two_thin

</> 
pub fn dice_two_thin(attrs: List(Attribute(a))) -> Element(a)

disc_bold

</> 
pub fn disc_bold(attrs: List(Attribute(a))) -> Element(a)

disc_duotone

</> 
pub fn disc_duotone(attrs: List(Attribute(a))) -> Element(a)

disc_fill

</> 
pub fn disc_fill(attrs: List(Attribute(a))) -> Element(a)

disc_light

</> 
pub fn disc_light(attrs: List(Attribute(a))) -> Element(a)

disc_regular

</> 
pub fn disc_regular(attrs: List(Attribute(a))) -> Element(a)

disc_thin

</> 
pub fn disc_thin(attrs: List(Attribute(a))) -> Element(a)

disco_ball_bold

</> 
pub fn disco_ball_bold(attrs: List(Attribute(a))) -> Element(a)

disco_ball_duotone

</> 
pub fn disco_ball_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

disco_ball_fill

</> 
pub fn disco_ball_fill(attrs: List(Attribute(a))) -> Element(a)

disco_ball_light

</> 
pub fn disco_ball_light(attrs: List(Attribute(a))) -> Element(a)

disco_ball_regular

</> 
pub fn disco_ball_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

disco_ball_thin

</> 
pub fn disco_ball_thin(attrs: List(Attribute(a))) -> Element(a)

discord_logo_bold

</> 
pub fn discord_logo_bold(attrs: List(Attribute(a))) -> Element(a)

discord_logo_duotone

</> 
pub fn discord_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

discord_logo_fill

</> 
pub fn discord_logo_fill(attrs: List(Attribute(a))) -> Element(a)

discord_logo_light

</> 
pub fn discord_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

discord_logo_regular

</> 
pub fn discord_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

discord_logo_thin

</> 
pub fn discord_logo_thin(attrs: List(Attribute(a))) -> Element(a)

divide_bold

</> 
pub fn divide_bold(attrs: List(Attribute(a))) -> Element(a)

divide_duotone

</> 
pub fn divide_duotone(attrs: List(Attribute(a))) -> Element(a)

divide_fill

</> 
pub fn divide_fill(attrs: List(Attribute(a))) -> Element(a)

divide_light

</> 
pub fn divide_light(attrs: List(Attribute(a))) -> Element(a)

divide_regular

</> 
pub fn divide_regular(attrs: List(Attribute(a))) -> Element(a)

divide_thin

</> 
pub fn divide_thin(attrs: List(Attribute(a))) -> Element(a)

dna_bold

</> 
pub fn dna_bold(attrs: List(Attribute(a))) -> Element(a)

dna_duotone

</> 
pub fn dna_duotone(attrs: List(Attribute(a))) -> Element(a)

dna_fill

</> 
pub fn dna_fill(attrs: List(Attribute(a))) -> Element(a)

dna_light

</> 
pub fn dna_light(attrs: List(Attribute(a))) -> Element(a)

dna_regular

</> 
pub fn dna_regular(attrs: List(Attribute(a))) -> Element(a)

dna_thin

</> 
pub fn dna_thin(attrs: List(Attribute(a))) -> Element(a)

dog_bold

</> 
pub fn dog_bold(attrs: List(Attribute(a))) -> Element(a)

dog_duotone

</> 
pub fn dog_duotone(attrs: List(Attribute(a))) -> Element(a)

dog_fill

</> 
pub fn dog_fill(attrs: List(Attribute(a))) -> Element(a)

dog_light

</> 
pub fn dog_light(attrs: List(Attribute(a))) -> Element(a)

dog_regular

</> 
pub fn dog_regular(attrs: List(Attribute(a))) -> Element(a)

dog_thin

</> 
pub fn dog_thin(attrs: List(Attribute(a))) -> Element(a)

door_bold

</> 
pub fn door_bold(attrs: List(Attribute(a))) -> Element(a)

door_duotone

</> 
pub fn door_duotone(attrs: List(Attribute(a))) -> Element(a)

door_fill

</> 
pub fn door_fill(attrs: List(Attribute(a))) -> Element(a)

door_light

</> 
pub fn door_light(attrs: List(Attribute(a))) -> Element(a)

door_open_bold

</> 
pub fn door_open_bold(attrs: List(Attribute(a))) -> Element(a)

door_open_duotone

</> 
pub fn door_open_duotone(attrs: List(Attribute(a))) -> Element(a)

door_open_fill

</> 
pub fn door_open_fill(attrs: List(Attribute(a))) -> Element(a)

door_open_light

</> 
pub fn door_open_light(attrs: List(Attribute(a))) -> Element(a)

door_open_regular

</> 
pub fn door_open_regular(attrs: List(Attribute(a))) -> Element(a)

door_open_thin

</> 
pub fn door_open_thin(attrs: List(Attribute(a))) -> Element(a)

door_regular

</> 
pub fn door_regular(attrs: List(Attribute(a))) -> Element(a)

door_thin

</> 
pub fn door_thin(attrs: List(Attribute(a))) -> Element(a)

dot_bold

</> 
pub fn dot_bold(attrs: List(Attribute(a))) -> Element(a)

dot_duotone

</> 
pub fn dot_duotone(attrs: List(Attribute(a))) -> Element(a)

dot_fill

</> 
pub fn dot_fill(attrs: List(Attribute(a))) -> Element(a)

dot_light

</> 
pub fn dot_light(attrs: List(Attribute(a))) -> Element(a)

dot_outline_bold

</> 
pub fn dot_outline_bold(attrs: List(Attribute(a))) -> Element(a)

dot_outline_duotone

</> 
pub fn dot_outline_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dot_outline_fill

</> 
pub fn dot_outline_fill(attrs: List(Attribute(a))) -> Element(a)

dot_outline_light

</> 
pub fn dot_outline_light(attrs: List(Attribute(a))) -> Element(a)

dot_outline_regular

</> 
pub fn dot_outline_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dot_outline_thin

</> 
pub fn dot_outline_thin(attrs: List(Attribute(a))) -> Element(a)

dot_regular

</> 
pub fn dot_regular(attrs: List(Attribute(a))) -> Element(a)

dot_thin

</> 
pub fn dot_thin(attrs: List(Attribute(a))) -> Element(a)

dots_nine_bold

</> 
pub fn dots_nine_bold(attrs: List(Attribute(a))) -> Element(a)

dots_nine_duotone

</> 
pub fn dots_nine_duotone(attrs: List(Attribute(a))) -> Element(a)

dots_nine_fill

</> 
pub fn dots_nine_fill(attrs: List(Attribute(a))) -> Element(a)

dots_nine_light

</> 
pub fn dots_nine_light(attrs: List(Attribute(a))) -> Element(a)

dots_nine_regular

</> 
pub fn dots_nine_regular(attrs: List(Attribute(a))) -> Element(a)

dots_nine_thin

</> 
pub fn dots_nine_thin(attrs: List(Attribute(a))) -> Element(a)

dots_six_bold

</> 
pub fn dots_six_bold(attrs: List(Attribute(a))) -> Element(a)

dots_six_duotone

</> 
pub fn dots_six_duotone(attrs: List(Attribute(a))) -> Element(a)

dots_six_fill

</> 
pub fn dots_six_fill(attrs: List(Attribute(a))) -> Element(a)

dots_six_light

</> 
pub fn dots_six_light(attrs: List(Attribute(a))) -> Element(a)

dots_six_regular

</> 
pub fn dots_six_regular(attrs: List(Attribute(a))) -> Element(a)

dots_six_thin

</> 
pub fn dots_six_thin(attrs: List(Attribute(a))) -> Element(a)

dots_six_vertical_bold

</> 
pub fn dots_six_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_six_vertical_duotone

</> 
pub fn dots_six_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_six_vertical_fill

</> 
pub fn dots_six_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_six_vertical_light

</> 
pub fn dots_six_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_six_vertical_regular

</> 
pub fn dots_six_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_six_vertical_thin

</> 
pub fn dots_six_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_bold

</> 
pub fn dots_three_bold(attrs: List(Attribute(a))) -> Element(a)

dots_three_circle_bold

</> 
pub fn dots_three_circle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_duotone

</> 
pub fn dots_three_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_fill

</> 
pub fn dots_three_circle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_light

</> 
pub fn dots_three_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_regular

</> 
pub fn dots_three_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_thin

</> 
pub fn dots_three_circle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_vertical_bold

</> 
pub fn dots_three_circle_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_vertical_duotone

</> 
pub fn dots_three_circle_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_vertical_fill

</> 
pub fn dots_three_circle_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_vertical_light

</> 
pub fn dots_three_circle_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_vertical_regular

</> 
pub fn dots_three_circle_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_circle_vertical_thin

</> 
pub fn dots_three_circle_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_duotone

</> 
pub fn dots_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_fill

</> 
pub fn dots_three_fill(attrs: List(Attribute(a))) -> Element(a)

dots_three_light

</> 
pub fn dots_three_light(attrs: List(Attribute(a))) -> Element(a)

dots_three_outline_bold

</> 
pub fn dots_three_outline_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_duotone

</> 
pub fn dots_three_outline_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_fill

</> 
pub fn dots_three_outline_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_light

</> 
pub fn dots_three_outline_light(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_regular

</> 
pub fn dots_three_outline_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_thin

</> 
pub fn dots_three_outline_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_vertical_bold

</> 
pub fn dots_three_outline_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_vertical_duotone

</> 
pub fn dots_three_outline_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_vertical_fill

</> 
pub fn dots_three_outline_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_vertical_light

</> 
pub fn dots_three_outline_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_vertical_regular

</> 
pub fn dots_three_outline_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_outline_vertical_thin

</> 
pub fn dots_three_outline_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_regular

</> 
pub fn dots_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_thin

</> 
pub fn dots_three_thin(attrs: List(Attribute(a))) -> Element(a)

dots_three_vertical_bold

</> 
pub fn dots_three_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_vertical_duotone

</> 
pub fn dots_three_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_vertical_fill

</> 
pub fn dots_three_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_vertical_light

</> 
pub fn dots_three_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_vertical_regular

</> 
pub fn dots_three_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dots_three_vertical_thin

</> 
pub fn dots_three_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

download_bold

</> 
pub fn download_bold(attrs: List(Attribute(a))) -> Element(a)

download_duotone

</> 
pub fn download_duotone(attrs: List(Attribute(a))) -> Element(a)

download_fill

</> 
pub fn download_fill(attrs: List(Attribute(a))) -> Element(a)

download_light

</> 
pub fn download_light(attrs: List(Attribute(a))) -> Element(a)

download_regular

</> 
pub fn download_regular(attrs: List(Attribute(a))) -> Element(a)

download_simple_bold

</> 
pub fn download_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

download_simple_duotone

</> 
pub fn download_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

download_simple_fill

</> 
pub fn download_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

download_simple_light

</> 
pub fn download_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

download_simple_regular

</> 
pub fn download_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

download_simple_thin

</> 
pub fn download_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

download_thin

</> 
pub fn download_thin(attrs: List(Attribute(a))) -> Element(a)

dress_bold

</> 
pub fn dress_bold(attrs: List(Attribute(a))) -> Element(a)

dress_duotone

</> 
pub fn dress_duotone(attrs: List(Attribute(a))) -> Element(a)

dress_fill

</> 
pub fn dress_fill(attrs: List(Attribute(a))) -> Element(a)

dress_light

</> 
pub fn dress_light(attrs: List(Attribute(a))) -> Element(a)

dress_regular

</> 
pub fn dress_regular(attrs: List(Attribute(a))) -> Element(a)

dress_thin

</> 
pub fn dress_thin(attrs: List(Attribute(a))) -> Element(a)

dresser_bold

</> 
pub fn dresser_bold(attrs: List(Attribute(a))) -> Element(a)

dresser_duotone

</> 
pub fn dresser_duotone(attrs: List(Attribute(a))) -> Element(a)

dresser_fill

</> 
pub fn dresser_fill(attrs: List(Attribute(a))) -> Element(a)

dresser_light

</> 
pub fn dresser_light(attrs: List(Attribute(a))) -> Element(a)

dresser_regular

</> 
pub fn dresser_regular(attrs: List(Attribute(a))) -> Element(a)

dresser_thin

</> 
pub fn dresser_thin(attrs: List(Attribute(a))) -> Element(a)

dribbble_logo_bold

</> 
pub fn dribbble_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

dribbble_logo_duotone

</> 
pub fn dribbble_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dribbble_logo_fill

</> 
pub fn dribbble_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

dribbble_logo_light

</> 
pub fn dribbble_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

dribbble_logo_regular

</> 
pub fn dribbble_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dribbble_logo_thin

</> 
pub fn dribbble_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

drone_bold

</> 
pub fn drone_bold(attrs: List(Attribute(a))) -> Element(a)

drone_duotone

</> 
pub fn drone_duotone(attrs: List(Attribute(a))) -> Element(a)

drone_fill

</> 
pub fn drone_fill(attrs: List(Attribute(a))) -> Element(a)

drone_light

</> 
pub fn drone_light(attrs: List(Attribute(a))) -> Element(a)

drone_regular

</> 
pub fn drone_regular(attrs: List(Attribute(a))) -> Element(a)

drone_thin

</> 
pub fn drone_thin(attrs: List(Attribute(a))) -> Element(a)

drop_bold

</> 
pub fn drop_bold(attrs: List(Attribute(a))) -> Element(a)

drop_duotone

</> 
pub fn drop_duotone(attrs: List(Attribute(a))) -> Element(a)

drop_fill

</> 
pub fn drop_fill(attrs: List(Attribute(a))) -> Element(a)

drop_half_bold

</> 
pub fn drop_half_bold(attrs: List(Attribute(a))) -> Element(a)

drop_half_bottom_bold

</> 
pub fn drop_half_bottom_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

drop_half_bottom_duotone

</> 
pub fn drop_half_bottom_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

drop_half_bottom_fill

</> 
pub fn drop_half_bottom_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

drop_half_bottom_light

</> 
pub fn drop_half_bottom_light(
  attrs: List(Attribute(a)),
) -> Element(a)

drop_half_bottom_regular

</> 
pub fn drop_half_bottom_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

drop_half_bottom_thin

</> 
pub fn drop_half_bottom_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

drop_half_duotone

</> 
pub fn drop_half_duotone(attrs: List(Attribute(a))) -> Element(a)

drop_half_fill

</> 
pub fn drop_half_fill(attrs: List(Attribute(a))) -> Element(a)

drop_half_light

</> 
pub fn drop_half_light(attrs: List(Attribute(a))) -> Element(a)

drop_half_regular

</> 
pub fn drop_half_regular(attrs: List(Attribute(a))) -> Element(a)

drop_half_thin

</> 
pub fn drop_half_thin(attrs: List(Attribute(a))) -> Element(a)

drop_light

</> 
pub fn drop_light(attrs: List(Attribute(a))) -> Element(a)

drop_regular

</> 
pub fn drop_regular(attrs: List(Attribute(a))) -> Element(a)

drop_simple_bold

</> 
pub fn drop_simple_bold(attrs: List(Attribute(a))) -> Element(a)

drop_simple_duotone

</> 
pub fn drop_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

drop_simple_fill

</> 
pub fn drop_simple_fill(attrs: List(Attribute(a))) -> Element(a)

drop_simple_light

</> 
pub fn drop_simple_light(attrs: List(Attribute(a))) -> Element(a)

drop_simple_regular

</> 
pub fn drop_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

drop_simple_thin

</> 
pub fn drop_simple_thin(attrs: List(Attribute(a))) -> Element(a)

drop_slash_bold

</> 
pub fn drop_slash_bold(attrs: List(Attribute(a))) -> Element(a)

drop_slash_duotone

</> 
pub fn drop_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

drop_slash_fill

</> 
pub fn drop_slash_fill(attrs: List(Attribute(a))) -> Element(a)

drop_slash_light

</> 
pub fn drop_slash_light(attrs: List(Attribute(a))) -> Element(a)

drop_slash_regular

</> 
pub fn drop_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

drop_slash_thin

</> 
pub fn drop_slash_thin(attrs: List(Attribute(a))) -> Element(a)

drop_thin

</> 
pub fn drop_thin(attrs: List(Attribute(a))) -> Element(a)

dropbox_logo_bold

</> 
pub fn dropbox_logo_bold(attrs: List(Attribute(a))) -> Element(a)

dropbox_logo_duotone

</> 
pub fn dropbox_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

dropbox_logo_fill

</> 
pub fn dropbox_logo_fill(attrs: List(Attribute(a))) -> Element(a)

dropbox_logo_light

</> 
pub fn dropbox_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

dropbox_logo_regular

</> 
pub fn dropbox_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

dropbox_logo_thin

</> 
pub fn dropbox_logo_thin(attrs: List(Attribute(a))) -> Element(a)

ear_bold

</> 
pub fn ear_bold(attrs: List(Attribute(a))) -> Element(a)

ear_duotone

</> 
pub fn ear_duotone(attrs: List(Attribute(a))) -> Element(a)

ear_fill

</> 
pub fn ear_fill(attrs: List(Attribute(a))) -> Element(a)

ear_light

</> 
pub fn ear_light(attrs: List(Attribute(a))) -> Element(a)

ear_regular

</> 
pub fn ear_regular(attrs: List(Attribute(a))) -> Element(a)

ear_slash_bold

</> 
pub fn ear_slash_bold(attrs: List(Attribute(a))) -> Element(a)

ear_slash_duotone

</> 
pub fn ear_slash_duotone(attrs: List(Attribute(a))) -> Element(a)

ear_slash_fill

</> 
pub fn ear_slash_fill(attrs: List(Attribute(a))) -> Element(a)

ear_slash_light

</> 
pub fn ear_slash_light(attrs: List(Attribute(a))) -> Element(a)

ear_slash_regular

</> 
pub fn ear_slash_regular(attrs: List(Attribute(a))) -> Element(a)

ear_slash_thin

</> 
pub fn ear_slash_thin(attrs: List(Attribute(a))) -> Element(a)

ear_thin

</> 
pub fn ear_thin(attrs: List(Attribute(a))) -> Element(a)

egg_bold

</> 
pub fn egg_bold(attrs: List(Attribute(a))) -> Element(a)

egg_crack_bold

</> 
pub fn egg_crack_bold(attrs: List(Attribute(a))) -> Element(a)

egg_crack_duotone

</> 
pub fn egg_crack_duotone(attrs: List(Attribute(a))) -> Element(a)

egg_crack_fill

</> 
pub fn egg_crack_fill(attrs: List(Attribute(a))) -> Element(a)

egg_crack_light

</> 
pub fn egg_crack_light(attrs: List(Attribute(a))) -> Element(a)

egg_crack_regular

</> 
pub fn egg_crack_regular(attrs: List(Attribute(a))) -> Element(a)

egg_crack_thin

</> 
pub fn egg_crack_thin(attrs: List(Attribute(a))) -> Element(a)

egg_duotone

</> 
pub fn egg_duotone(attrs: List(Attribute(a))) -> Element(a)

egg_fill

</> 
pub fn egg_fill(attrs: List(Attribute(a))) -> Element(a)

egg_light

</> 
pub fn egg_light(attrs: List(Attribute(a))) -> Element(a)

egg_regular

</> 
pub fn egg_regular(attrs: List(Attribute(a))) -> Element(a)

egg_thin

</> 
pub fn egg_thin(attrs: List(Attribute(a))) -> Element(a)

eject_bold

</> 
pub fn eject_bold(attrs: List(Attribute(a))) -> Element(a)

eject_duotone

</> 
pub fn eject_duotone(attrs: List(Attribute(a))) -> Element(a)

eject_fill

</> 
pub fn eject_fill(attrs: List(Attribute(a))) -> Element(a)

eject_light

</> 
pub fn eject_light(attrs: List(Attribute(a))) -> Element(a)

eject_regular

</> 
pub fn eject_regular(attrs: List(Attribute(a))) -> Element(a)

eject_simple_bold

</> 
pub fn eject_simple_bold(attrs: List(Attribute(a))) -> Element(a)

eject_simple_duotone

</> 
pub fn eject_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

eject_simple_fill

</> 
pub fn eject_simple_fill(attrs: List(Attribute(a))) -> Element(a)

eject_simple_light

</> 
pub fn eject_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

eject_simple_regular

</> 
pub fn eject_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

eject_simple_thin

</> 
pub fn eject_simple_thin(attrs: List(Attribute(a))) -> Element(a)

eject_thin

</> 
pub fn eject_thin(attrs: List(Attribute(a))) -> Element(a)

elevator_bold

</> 
pub fn elevator_bold(attrs: List(Attribute(a))) -> Element(a)

elevator_duotone

</> 
pub fn elevator_duotone(attrs: List(Attribute(a))) -> Element(a)

elevator_fill

</> 
pub fn elevator_fill(attrs: List(Attribute(a))) -> Element(a)

elevator_light

</> 
pub fn elevator_light(attrs: List(Attribute(a))) -> Element(a)

elevator_regular

</> 
pub fn elevator_regular(attrs: List(Attribute(a))) -> Element(a)

elevator_thin

</> 
pub fn elevator_thin(attrs: List(Attribute(a))) -> Element(a)

empty_bold

</> 
pub fn empty_bold(attrs: List(Attribute(a))) -> Element(a)

empty_duotone

</> 
pub fn empty_duotone(attrs: List(Attribute(a))) -> Element(a)

empty_fill

</> 
pub fn empty_fill(attrs: List(Attribute(a))) -> Element(a)

empty_light

</> 
pub fn empty_light(attrs: List(Attribute(a))) -> Element(a)

empty_regular

</> 
pub fn empty_regular(attrs: List(Attribute(a))) -> Element(a)

empty_thin

</> 
pub fn empty_thin(attrs: List(Attribute(a))) -> Element(a)

engine_bold

</> 
pub fn engine_bold(attrs: List(Attribute(a))) -> Element(a)

engine_duotone

</> 
pub fn engine_duotone(attrs: List(Attribute(a))) -> Element(a)

engine_fill

</> 
pub fn engine_fill(attrs: List(Attribute(a))) -> Element(a)

engine_light

</> 
pub fn engine_light(attrs: List(Attribute(a))) -> Element(a)

engine_regular

</> 
pub fn engine_regular(attrs: List(Attribute(a))) -> Element(a)

engine_thin

</> 
pub fn engine_thin(attrs: List(Attribute(a))) -> Element(a)

envelope_bold

</> 
pub fn envelope_bold(attrs: List(Attribute(a))) -> Element(a)

envelope_duotone

</> 
pub fn envelope_duotone(attrs: List(Attribute(a))) -> Element(a)

envelope_fill

</> 
pub fn envelope_fill(attrs: List(Attribute(a))) -> Element(a)

envelope_light

</> 
pub fn envelope_light(attrs: List(Attribute(a))) -> Element(a)

envelope_open_bold

</> 
pub fn envelope_open_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_open_duotone

</> 
pub fn envelope_open_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_open_fill

</> 
pub fn envelope_open_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_open_light

</> 
pub fn envelope_open_light(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_open_regular

</> 
pub fn envelope_open_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_open_thin

</> 
pub fn envelope_open_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_regular

</> 
pub fn envelope_regular(attrs: List(Attribute(a))) -> Element(a)

envelope_simple_bold

</> 
pub fn envelope_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_duotone

</> 
pub fn envelope_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_fill

</> 
pub fn envelope_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_light

</> 
pub fn envelope_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_open_bold

</> 
pub fn envelope_simple_open_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_open_duotone

</> 
pub fn envelope_simple_open_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_open_fill

</> 
pub fn envelope_simple_open_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_open_light

</> 
pub fn envelope_simple_open_light(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_open_regular

</> 
pub fn envelope_simple_open_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_open_thin

</> 
pub fn envelope_simple_open_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_regular

</> 
pub fn envelope_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_simple_thin

</> 
pub fn envelope_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

envelope_thin

</> 
pub fn envelope_thin(attrs: List(Attribute(a))) -> Element(a)

equalizer_bold

</> 
pub fn equalizer_bold(attrs: List(Attribute(a))) -> Element(a)

equalizer_duotone

</> 
pub fn equalizer_duotone(attrs: List(Attribute(a))) -> Element(a)

equalizer_fill

</> 
pub fn equalizer_fill(attrs: List(Attribute(a))) -> Element(a)

equalizer_light

</> 
pub fn equalizer_light(attrs: List(Attribute(a))) -> Element(a)

equalizer_regular

</> 
pub fn equalizer_regular(attrs: List(Attribute(a))) -> Element(a)

equalizer_thin

</> 
pub fn equalizer_thin(attrs: List(Attribute(a))) -> Element(a)

equals_bold

</> 
pub fn equals_bold(attrs: List(Attribute(a))) -> Element(a)

equals_duotone

</> 
pub fn equals_duotone(attrs: List(Attribute(a))) -> Element(a)

equals_fill

</> 
pub fn equals_fill(attrs: List(Attribute(a))) -> Element(a)

equals_light

</> 
pub fn equals_light(attrs: List(Attribute(a))) -> Element(a)

equals_regular

</> 
pub fn equals_regular(attrs: List(Attribute(a))) -> Element(a)

equals_thin

</> 
pub fn equals_thin(attrs: List(Attribute(a))) -> Element(a)

eraser_bold

</> 
pub fn eraser_bold(attrs: List(Attribute(a))) -> Element(a)

eraser_duotone

</> 
pub fn eraser_duotone(attrs: List(Attribute(a))) -> Element(a)

eraser_fill

</> 
pub fn eraser_fill(attrs: List(Attribute(a))) -> Element(a)

eraser_light

</> 
pub fn eraser_light(attrs: List(Attribute(a))) -> Element(a)

eraser_regular

</> 
pub fn eraser_regular(attrs: List(Attribute(a))) -> Element(a)

eraser_thin

</> 
pub fn eraser_thin(attrs: List(Attribute(a))) -> Element(a)

escalator_down_bold

</> 
pub fn escalator_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

escalator_down_duotone

</> 
pub fn escalator_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

escalator_down_fill

</> 
pub fn escalator_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

escalator_down_light

</> 
pub fn escalator_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

escalator_down_regular

</> 
pub fn escalator_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

escalator_down_thin

</> 
pub fn escalator_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

escalator_up_bold

</> 
pub fn escalator_up_bold(attrs: List(Attribute(a))) -> Element(a)

escalator_up_duotone

</> 
pub fn escalator_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

escalator_up_fill

</> 
pub fn escalator_up_fill(attrs: List(Attribute(a))) -> Element(a)

escalator_up_light

</> 
pub fn escalator_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

escalator_up_regular

</> 
pub fn escalator_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

escalator_up_thin

</> 
pub fn escalator_up_thin(attrs: List(Attribute(a))) -> Element(a)

exam_bold

</> 
pub fn exam_bold(attrs: List(Attribute(a))) -> Element(a)

exam_duotone

</> 
pub fn exam_duotone(attrs: List(Attribute(a))) -> Element(a)

exam_fill

</> 
pub fn exam_fill(attrs: List(Attribute(a))) -> Element(a)

exam_light

</> 
pub fn exam_light(attrs: List(Attribute(a))) -> Element(a)

exam_regular

</> 
pub fn exam_regular(attrs: List(Attribute(a))) -> Element(a)

exam_thin

</> 
pub fn exam_thin(attrs: List(Attribute(a))) -> Element(a)

exclamation_mark_bold

</> 
pub fn exclamation_mark_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

exclamation_mark_duotone

</> 
pub fn exclamation_mark_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

exclamation_mark_fill

</> 
pub fn exclamation_mark_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

exclamation_mark_light

</> 
pub fn exclamation_mark_light(
  attrs: List(Attribute(a)),
) -> Element(a)

exclamation_mark_regular

</> 
pub fn exclamation_mark_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

exclamation_mark_thin

</> 
pub fn exclamation_mark_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

exclude_bold

</> 
pub fn exclude_bold(attrs: List(Attribute(a))) -> Element(a)

exclude_duotone

</> 
pub fn exclude_duotone(attrs: List(Attribute(a))) -> Element(a)

exclude_fill

</> 
pub fn exclude_fill(attrs: List(Attribute(a))) -> Element(a)

exclude_light

</> 
pub fn exclude_light(attrs: List(Attribute(a))) -> Element(a)

exclude_regular

</> 
pub fn exclude_regular(attrs: List(Attribute(a))) -> Element(a)

exclude_square_bold

</> 
pub fn exclude_square_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

exclude_square_duotone

</> 
pub fn exclude_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

exclude_square_fill

</> 
pub fn exclude_square_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

exclude_square_light

</> 
pub fn exclude_square_light(
  attrs: List(Attribute(a)),
) -> Element(a)

exclude_square_regular

</> 
pub fn exclude_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

exclude_square_thin

</> 
pub fn exclude_square_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

exclude_thin

</> 
pub fn exclude_thin(attrs: List(Attribute(a))) -> Element(a)

export_bold

</> 
pub fn export_bold(attrs: List(Attribute(a))) -> Element(a)

export_duotone

</> 
pub fn export_duotone(attrs: List(Attribute(a))) -> Element(a)

export_fill

</> 
pub fn export_fill(attrs: List(Attribute(a))) -> Element(a)

export_light

</> 
pub fn export_light(attrs: List(Attribute(a))) -> Element(a)

export_regular

</> 
pub fn export_regular(attrs: List(Attribute(a))) -> Element(a)

export_thin

</> 
pub fn export_thin(attrs: List(Attribute(a))) -> Element(a)

eye_bold

</> 
pub fn eye_bold(attrs: List(Attribute(a))) -> Element(a)

eye_closed_bold

</> 
pub fn eye_closed_bold(attrs: List(Attribute(a))) -> Element(a)

eye_closed_duotone

</> 
pub fn eye_closed_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

eye_closed_fill

</> 
pub fn eye_closed_fill(attrs: List(Attribute(a))) -> Element(a)

eye_closed_light

</> 
pub fn eye_closed_light(attrs: List(Attribute(a))) -> Element(a)

eye_closed_regular

</> 
pub fn eye_closed_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

eye_closed_thin

</> 
pub fn eye_closed_thin(attrs: List(Attribute(a))) -> Element(a)

eye_duotone

</> 
pub fn eye_duotone(attrs: List(Attribute(a))) -> Element(a)

eye_fill

</> 
pub fn eye_fill(attrs: List(Attribute(a))) -> Element(a)

eye_light

</> 
pub fn eye_light(attrs: List(Attribute(a))) -> Element(a)

eye_regular

</> 
pub fn eye_regular(attrs: List(Attribute(a))) -> Element(a)

eye_slash_bold

</> 
pub fn eye_slash_bold(attrs: List(Attribute(a))) -> Element(a)

eye_slash_duotone

</> 
pub fn eye_slash_duotone(attrs: List(Attribute(a))) -> Element(a)

eye_slash_fill

</> 
pub fn eye_slash_fill(attrs: List(Attribute(a))) -> Element(a)

eye_slash_light

</> 
pub fn eye_slash_light(attrs: List(Attribute(a))) -> Element(a)

eye_slash_regular

</> 
pub fn eye_slash_regular(attrs: List(Attribute(a))) -> Element(a)

eye_slash_thin

</> 
pub fn eye_slash_thin(attrs: List(Attribute(a))) -> Element(a)

eye_thin

</> 
pub fn eye_thin(attrs: List(Attribute(a))) -> Element(a)

eyedropper_bold

</> 
pub fn eyedropper_bold(attrs: List(Attribute(a))) -> Element(a)

eyedropper_duotone

</> 
pub fn eyedropper_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

eyedropper_fill

</> 
pub fn eyedropper_fill(attrs: List(Attribute(a))) -> Element(a)

eyedropper_light

</> 
pub fn eyedropper_light(attrs: List(Attribute(a))) -> Element(a)

eyedropper_regular

</> 
pub fn eyedropper_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

eyedropper_sample_bold

</> 
pub fn eyedropper_sample_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

eyedropper_sample_duotone

</> 
pub fn eyedropper_sample_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

eyedropper_sample_fill

</> 
pub fn eyedropper_sample_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

eyedropper_sample_light

</> 
pub fn eyedropper_sample_light(
  attrs: List(Attribute(a)),
) -> Element(a)

eyedropper_sample_regular

</> 
pub fn eyedropper_sample_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

eyedropper_sample_thin

</> 
pub fn eyedropper_sample_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

eyedropper_thin

</> 
pub fn eyedropper_thin(attrs: List(Attribute(a))) -> Element(a)

eyeglasses_bold

</> 
pub fn eyeglasses_bold(attrs: List(Attribute(a))) -> Element(a)

eyeglasses_duotone

</> 
pub fn eyeglasses_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

eyeglasses_fill

</> 
pub fn eyeglasses_fill(attrs: List(Attribute(a))) -> Element(a)

eyeglasses_light

</> 
pub fn eyeglasses_light(attrs: List(Attribute(a))) -> Element(a)

eyeglasses_regular

</> 
pub fn eyeglasses_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

eyeglasses_thin

</> 
pub fn eyeglasses_thin(attrs: List(Attribute(a))) -> Element(a)

eyes_bold

</> 
pub fn eyes_bold(attrs: List(Attribute(a))) -> Element(a)

eyes_duotone

</> 
pub fn eyes_duotone(attrs: List(Attribute(a))) -> Element(a)

eyes_fill

</> 
pub fn eyes_fill(attrs: List(Attribute(a))) -> Element(a)

eyes_light

</> 
pub fn eyes_light(attrs: List(Attribute(a))) -> Element(a)

eyes_regular

</> 
pub fn eyes_regular(attrs: List(Attribute(a))) -> Element(a)

eyes_thin

</> 
pub fn eyes_thin(attrs: List(Attribute(a))) -> Element(a)

face_mask_bold

</> 
pub fn face_mask_bold(attrs: List(Attribute(a))) -> Element(a)

face_mask_duotone

</> 
pub fn face_mask_duotone(attrs: List(Attribute(a))) -> Element(a)

face_mask_fill

</> 
pub fn face_mask_fill(attrs: List(Attribute(a))) -> Element(a)

face_mask_light

</> 
pub fn face_mask_light(attrs: List(Attribute(a))) -> Element(a)

face_mask_regular

</> 
pub fn face_mask_regular(attrs: List(Attribute(a))) -> Element(a)

face_mask_thin

</> 
pub fn face_mask_thin(attrs: List(Attribute(a))) -> Element(a)

facebook_logo_bold

</> 
pub fn facebook_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

facebook_logo_duotone

</> 
pub fn facebook_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

facebook_logo_fill

</> 
pub fn facebook_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

facebook_logo_light

</> 
pub fn facebook_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

facebook_logo_regular

</> 
pub fn facebook_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

facebook_logo_thin

</> 
pub fn facebook_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

factory_bold

</> 
pub fn factory_bold(attrs: List(Attribute(a))) -> Element(a)

factory_duotone

</> 
pub fn factory_duotone(attrs: List(Attribute(a))) -> Element(a)

factory_fill

</> 
pub fn factory_fill(attrs: List(Attribute(a))) -> Element(a)

factory_light

</> 
pub fn factory_light(attrs: List(Attribute(a))) -> Element(a)

factory_regular

</> 
pub fn factory_regular(attrs: List(Attribute(a))) -> Element(a)

factory_thin

</> 
pub fn factory_thin(attrs: List(Attribute(a))) -> Element(a)

faders_bold

</> 
pub fn faders_bold(attrs: List(Attribute(a))) -> Element(a)

faders_duotone

</> 
pub fn faders_duotone(attrs: List(Attribute(a))) -> Element(a)

faders_fill

</> 
pub fn faders_fill(attrs: List(Attribute(a))) -> Element(a)

faders_horizontal_bold

</> 
pub fn faders_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

faders_horizontal_duotone

</> 
pub fn faders_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

faders_horizontal_fill

</> 
pub fn faders_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

faders_horizontal_light

</> 
pub fn faders_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

faders_horizontal_regular

</> 
pub fn faders_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

faders_horizontal_thin

</> 
pub fn faders_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

faders_light

</> 
pub fn faders_light(attrs: List(Attribute(a))) -> Element(a)

faders_regular

</> 
pub fn faders_regular(attrs: List(Attribute(a))) -> Element(a)

faders_thin

</> 
pub fn faders_thin(attrs: List(Attribute(a))) -> Element(a)

fallout_shelter_bold

</> 
pub fn fallout_shelter_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

fallout_shelter_duotone

</> 
pub fn fallout_shelter_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fallout_shelter_fill

</> 
pub fn fallout_shelter_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

fallout_shelter_light

</> 
pub fn fallout_shelter_light(
  attrs: List(Attribute(a)),
) -> Element(a)

fallout_shelter_regular

</> 
pub fn fallout_shelter_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fallout_shelter_thin

</> 
pub fn fallout_shelter_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

fan_bold

</> 
pub fn fan_bold(attrs: List(Attribute(a))) -> Element(a)

fan_duotone

</> 
pub fn fan_duotone(attrs: List(Attribute(a))) -> Element(a)

fan_fill

</> 
pub fn fan_fill(attrs: List(Attribute(a))) -> Element(a)

fan_light

</> 
pub fn fan_light(attrs: List(Attribute(a))) -> Element(a)

fan_regular

</> 
pub fn fan_regular(attrs: List(Attribute(a))) -> Element(a)

fan_thin

</> 
pub fn fan_thin(attrs: List(Attribute(a))) -> Element(a)

farm_bold

</> 
pub fn farm_bold(attrs: List(Attribute(a))) -> Element(a)

farm_duotone

</> 
pub fn farm_duotone(attrs: List(Attribute(a))) -> Element(a)

farm_fill

</> 
pub fn farm_fill(attrs: List(Attribute(a))) -> Element(a)

farm_light

</> 
pub fn farm_light(attrs: List(Attribute(a))) -> Element(a)

farm_regular

</> 
pub fn farm_regular(attrs: List(Attribute(a))) -> Element(a)

farm_thin

</> 
pub fn farm_thin(attrs: List(Attribute(a))) -> Element(a)

fast_forward_bold

</> 
pub fn fast_forward_bold(attrs: List(Attribute(a))) -> Element(a)

fast_forward_circle_bold

</> 
pub fn fast_forward_circle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

fast_forward_circle_duotone

</> 
pub fn fast_forward_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fast_forward_circle_fill

</> 
pub fn fast_forward_circle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

fast_forward_circle_light

</> 
pub fn fast_forward_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

fast_forward_circle_regular

</> 
pub fn fast_forward_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fast_forward_circle_thin

</> 
pub fn fast_forward_circle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

fast_forward_duotone

</> 
pub fn fast_forward_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fast_forward_fill

</> 
pub fn fast_forward_fill(attrs: List(Attribute(a))) -> Element(a)

fast_forward_light

</> 
pub fn fast_forward_light(
  attrs: List(Attribute(a)),
) -> Element(a)

fast_forward_regular

</> 
pub fn fast_forward_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fast_forward_thin

</> 
pub fn fast_forward_thin(attrs: List(Attribute(a))) -> Element(a)

feather_bold

</> 
pub fn feather_bold(attrs: List(Attribute(a))) -> Element(a)

feather_duotone

</> 
pub fn feather_duotone(attrs: List(Attribute(a))) -> Element(a)

feather_fill

</> 
pub fn feather_fill(attrs: List(Attribute(a))) -> Element(a)

feather_light

</> 
pub fn feather_light(attrs: List(Attribute(a))) -> Element(a)

feather_regular

</> 
pub fn feather_regular(attrs: List(Attribute(a))) -> Element(a)

feather_thin

</> 
pub fn feather_thin(attrs: List(Attribute(a))) -> Element(a)

fediverse_logo_bold

</> 
pub fn fediverse_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

fediverse_logo_duotone

</> 
pub fn fediverse_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fediverse_logo_fill

</> 
pub fn fediverse_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

fediverse_logo_light

</> 
pub fn fediverse_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

fediverse_logo_regular

</> 
pub fn fediverse_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fediverse_logo_thin

</> 
pub fn fediverse_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

figma_logo_bold

</> 
pub fn figma_logo_bold(attrs: List(Attribute(a))) -> Element(a)

figma_logo_duotone

</> 
pub fn figma_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

figma_logo_fill

</> 
pub fn figma_logo_fill(attrs: List(Attribute(a))) -> Element(a)

figma_logo_light

</> 
pub fn figma_logo_light(attrs: List(Attribute(a))) -> Element(a)

figma_logo_regular

</> 
pub fn figma_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

figma_logo_thin

</> 
pub fn figma_logo_thin(attrs: List(Attribute(a))) -> Element(a)

file_archive_bold

</> 
pub fn file_archive_bold(attrs: List(Attribute(a))) -> Element(a)

file_archive_duotone

</> 
pub fn file_archive_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_archive_fill

</> 
pub fn file_archive_fill(attrs: List(Attribute(a))) -> Element(a)

file_archive_light

</> 
pub fn file_archive_light(
  attrs: List(Attribute(a)),
) -> Element(a)

file_archive_regular

</> 
pub fn file_archive_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_archive_thin

</> 
pub fn file_archive_thin(attrs: List(Attribute(a))) -> Element(a)

file_arrow_down_bold

</> 
pub fn file_arrow_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_down_duotone

</> 
pub fn file_arrow_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_down_fill

</> 
pub fn file_arrow_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_down_light

</> 
pub fn file_arrow_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_down_regular

</> 
pub fn file_arrow_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_down_thin

</> 
pub fn file_arrow_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_up_bold

</> 
pub fn file_arrow_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_up_duotone

</> 
pub fn file_arrow_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_up_fill

</> 
pub fn file_arrow_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_up_light

</> 
pub fn file_arrow_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_up_regular

</> 
pub fn file_arrow_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_arrow_up_thin

</> 
pub fn file_arrow_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

file_audio_bold

</> 
pub fn file_audio_bold(attrs: List(Attribute(a))) -> Element(a)

file_audio_duotone

</> 
pub fn file_audio_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_audio_fill

</> 
pub fn file_audio_fill(attrs: List(Attribute(a))) -> Element(a)

file_audio_light

</> 
pub fn file_audio_light(attrs: List(Attribute(a))) -> Element(a)

file_audio_regular

</> 
pub fn file_audio_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_audio_thin

</> 
pub fn file_audio_thin(attrs: List(Attribute(a))) -> Element(a)

file_bold

</> 
pub fn file_bold(attrs: List(Attribute(a))) -> Element(a)

file_c_bold

</> 
pub fn file_c_bold(attrs: List(Attribute(a))) -> Element(a)

file_c_duotone

</> 
pub fn file_c_duotone(attrs: List(Attribute(a))) -> Element(a)

file_c_fill

</> 
pub fn file_c_fill(attrs: List(Attribute(a))) -> Element(a)

file_c_light

</> 
pub fn file_c_light(attrs: List(Attribute(a))) -> Element(a)

file_c_regular

</> 
pub fn file_c_regular(attrs: List(Attribute(a))) -> Element(a)

file_c_sharp_bold

</> 
pub fn file_c_sharp_bold(attrs: List(Attribute(a))) -> Element(a)

file_c_sharp_duotone

</> 
pub fn file_c_sharp_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_c_sharp_fill

</> 
pub fn file_c_sharp_fill(attrs: List(Attribute(a))) -> Element(a)

file_c_sharp_light

</> 
pub fn file_c_sharp_light(
  attrs: List(Attribute(a)),
) -> Element(a)

file_c_sharp_regular

</> 
pub fn file_c_sharp_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_c_sharp_thin

</> 
pub fn file_c_sharp_thin(attrs: List(Attribute(a))) -> Element(a)

file_c_thin

</> 
pub fn file_c_thin(attrs: List(Attribute(a))) -> Element(a)

file_cloud_bold

</> 
pub fn file_cloud_bold(attrs: List(Attribute(a))) -> Element(a)

file_cloud_duotone

</> 
pub fn file_cloud_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_cloud_fill

</> 
pub fn file_cloud_fill(attrs: List(Attribute(a))) -> Element(a)

file_cloud_light

</> 
pub fn file_cloud_light(attrs: List(Attribute(a))) -> Element(a)

file_cloud_regular

</> 
pub fn file_cloud_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_cloud_thin

</> 
pub fn file_cloud_thin(attrs: List(Attribute(a))) -> Element(a)

file_code_bold

</> 
pub fn file_code_bold(attrs: List(Attribute(a))) -> Element(a)

file_code_duotone

</> 
pub fn file_code_duotone(attrs: List(Attribute(a))) -> Element(a)

file_code_fill

</> 
pub fn file_code_fill(attrs: List(Attribute(a))) -> Element(a)

file_code_light

</> 
pub fn file_code_light(attrs: List(Attribute(a))) -> Element(a)

file_code_regular

</> 
pub fn file_code_regular(attrs: List(Attribute(a))) -> Element(a)

file_code_thin

</> 
pub fn file_code_thin(attrs: List(Attribute(a))) -> Element(a)

file_cpp_bold

</> 
pub fn file_cpp_bold(attrs: List(Attribute(a))) -> Element(a)

file_cpp_duotone

</> 
pub fn file_cpp_duotone(attrs: List(Attribute(a))) -> Element(a)

file_cpp_fill

</> 
pub fn file_cpp_fill(attrs: List(Attribute(a))) -> Element(a)

file_cpp_light

</> 
pub fn file_cpp_light(attrs: List(Attribute(a))) -> Element(a)

file_cpp_regular

</> 
pub fn file_cpp_regular(attrs: List(Attribute(a))) -> Element(a)

file_cpp_thin

</> 
pub fn file_cpp_thin(attrs: List(Attribute(a))) -> Element(a)

file_css_bold

</> 
pub fn file_css_bold(attrs: List(Attribute(a))) -> Element(a)

file_css_duotone

</> 
pub fn file_css_duotone(attrs: List(Attribute(a))) -> Element(a)

file_css_fill

</> 
pub fn file_css_fill(attrs: List(Attribute(a))) -> Element(a)

file_css_light

</> 
pub fn file_css_light(attrs: List(Attribute(a))) -> Element(a)

file_css_regular

</> 
pub fn file_css_regular(attrs: List(Attribute(a))) -> Element(a)

file_css_thin

</> 
pub fn file_css_thin(attrs: List(Attribute(a))) -> Element(a)

file_csv_bold

</> 
pub fn file_csv_bold(attrs: List(Attribute(a))) -> Element(a)

file_csv_duotone

</> 
pub fn file_csv_duotone(attrs: List(Attribute(a))) -> Element(a)

file_csv_fill

</> 
pub fn file_csv_fill(attrs: List(Attribute(a))) -> Element(a)

file_csv_light

</> 
pub fn file_csv_light(attrs: List(Attribute(a))) -> Element(a)

file_csv_regular

</> 
pub fn file_csv_regular(attrs: List(Attribute(a))) -> Element(a)

file_csv_thin

</> 
pub fn file_csv_thin(attrs: List(Attribute(a))) -> Element(a)

file_dashed_bold

</> 
pub fn file_dashed_bold(attrs: List(Attribute(a))) -> Element(a)

file_dashed_duotone

</> 
pub fn file_dashed_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_dashed_fill

</> 
pub fn file_dashed_fill(attrs: List(Attribute(a))) -> Element(a)

file_dashed_light

</> 
pub fn file_dashed_light(attrs: List(Attribute(a))) -> Element(a)

file_dashed_regular

</> 
pub fn file_dashed_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_dashed_thin

</> 
pub fn file_dashed_thin(attrs: List(Attribute(a))) -> Element(a)

file_doc_bold

</> 
pub fn file_doc_bold(attrs: List(Attribute(a))) -> Element(a)

file_doc_duotone

</> 
pub fn file_doc_duotone(attrs: List(Attribute(a))) -> Element(a)

file_doc_fill

</> 
pub fn file_doc_fill(attrs: List(Attribute(a))) -> Element(a)

file_doc_light

</> 
pub fn file_doc_light(attrs: List(Attribute(a))) -> Element(a)

file_doc_regular

</> 
pub fn file_doc_regular(attrs: List(Attribute(a))) -> Element(a)

file_doc_thin

</> 
pub fn file_doc_thin(attrs: List(Attribute(a))) -> Element(a)

file_duotone

</> 
pub fn file_duotone(attrs: List(Attribute(a))) -> Element(a)

file_fill

</> 
pub fn file_fill(attrs: List(Attribute(a))) -> Element(a)

file_html_bold

</> 
pub fn file_html_bold(attrs: List(Attribute(a))) -> Element(a)

file_html_duotone

</> 
pub fn file_html_duotone(attrs: List(Attribute(a))) -> Element(a)

file_html_fill

</> 
pub fn file_html_fill(attrs: List(Attribute(a))) -> Element(a)

file_html_light

</> 
pub fn file_html_light(attrs: List(Attribute(a))) -> Element(a)

file_html_regular

</> 
pub fn file_html_regular(attrs: List(Attribute(a))) -> Element(a)

file_html_thin

</> 
pub fn file_html_thin(attrs: List(Attribute(a))) -> Element(a)

file_image_bold

</> 
pub fn file_image_bold(attrs: List(Attribute(a))) -> Element(a)

file_image_duotone

</> 
pub fn file_image_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_image_fill

</> 
pub fn file_image_fill(attrs: List(Attribute(a))) -> Element(a)

file_image_light

</> 
pub fn file_image_light(attrs: List(Attribute(a))) -> Element(a)

file_image_regular

</> 
pub fn file_image_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_image_thin

</> 
pub fn file_image_thin(attrs: List(Attribute(a))) -> Element(a)

file_ini_bold

</> 
pub fn file_ini_bold(attrs: List(Attribute(a))) -> Element(a)

file_ini_duotone

</> 
pub fn file_ini_duotone(attrs: List(Attribute(a))) -> Element(a)

file_ini_fill

</> 
pub fn file_ini_fill(attrs: List(Attribute(a))) -> Element(a)

file_ini_light

</> 
pub fn file_ini_light(attrs: List(Attribute(a))) -> Element(a)

file_ini_regular

</> 
pub fn file_ini_regular(attrs: List(Attribute(a))) -> Element(a)

file_ini_thin

</> 
pub fn file_ini_thin(attrs: List(Attribute(a))) -> Element(a)

file_jpg_bold

</> 
pub fn file_jpg_bold(attrs: List(Attribute(a))) -> Element(a)

file_jpg_duotone

</> 
pub fn file_jpg_duotone(attrs: List(Attribute(a))) -> Element(a)

file_jpg_fill

</> 
pub fn file_jpg_fill(attrs: List(Attribute(a))) -> Element(a)

file_jpg_light

</> 
pub fn file_jpg_light(attrs: List(Attribute(a))) -> Element(a)

file_jpg_regular

</> 
pub fn file_jpg_regular(attrs: List(Attribute(a))) -> Element(a)

file_jpg_thin

</> 
pub fn file_jpg_thin(attrs: List(Attribute(a))) -> Element(a)

file_js_bold

</> 
pub fn file_js_bold(attrs: List(Attribute(a))) -> Element(a)

file_js_duotone

</> 
pub fn file_js_duotone(attrs: List(Attribute(a))) -> Element(a)

file_js_fill

</> 
pub fn file_js_fill(attrs: List(Attribute(a))) -> Element(a)

file_js_light

</> 
pub fn file_js_light(attrs: List(Attribute(a))) -> Element(a)

file_js_regular

</> 
pub fn file_js_regular(attrs: List(Attribute(a))) -> Element(a)

file_js_thin

</> 
pub fn file_js_thin(attrs: List(Attribute(a))) -> Element(a)

file_jsx_bold

</> 
pub fn file_jsx_bold(attrs: List(Attribute(a))) -> Element(a)

file_jsx_duotone

</> 
pub fn file_jsx_duotone(attrs: List(Attribute(a))) -> Element(a)

file_jsx_fill

</> 
pub fn file_jsx_fill(attrs: List(Attribute(a))) -> Element(a)

file_jsx_light

</> 
pub fn file_jsx_light(attrs: List(Attribute(a))) -> Element(a)

file_jsx_regular

</> 
pub fn file_jsx_regular(attrs: List(Attribute(a))) -> Element(a)

file_jsx_thin

</> 
pub fn file_jsx_thin(attrs: List(Attribute(a))) -> Element(a)

file_light

</> 
pub fn file_light(attrs: List(Attribute(a))) -> Element(a)

file_lock_bold

</> 
pub fn file_lock_bold(attrs: List(Attribute(a))) -> Element(a)

file_lock_duotone

</> 
pub fn file_lock_duotone(attrs: List(Attribute(a))) -> Element(a)

file_lock_fill

</> 
pub fn file_lock_fill(attrs: List(Attribute(a))) -> Element(a)

file_lock_light

</> 
pub fn file_lock_light(attrs: List(Attribute(a))) -> Element(a)

file_lock_regular

</> 
pub fn file_lock_regular(attrs: List(Attribute(a))) -> Element(a)

file_lock_thin

</> 
pub fn file_lock_thin(attrs: List(Attribute(a))) -> Element(a)

file_magnifying_glass_bold

</> 
pub fn file_magnifying_glass_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

file_magnifying_glass_duotone

</> 
pub fn file_magnifying_glass_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_magnifying_glass_fill

</> 
pub fn file_magnifying_glass_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

file_magnifying_glass_light

</> 
pub fn file_magnifying_glass_light(
  attrs: List(Attribute(a)),
) -> Element(a)

file_magnifying_glass_regular

</> 
pub fn file_magnifying_glass_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_magnifying_glass_thin

</> 
pub fn file_magnifying_glass_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

file_md_bold

</> 
pub fn file_md_bold(attrs: List(Attribute(a))) -> Element(a)

file_md_duotone

</> 
pub fn file_md_duotone(attrs: List(Attribute(a))) -> Element(a)

file_md_fill

</> 
pub fn file_md_fill(attrs: List(Attribute(a))) -> Element(a)

file_md_light

</> 
pub fn file_md_light(attrs: List(Attribute(a))) -> Element(a)

file_md_regular

</> 
pub fn file_md_regular(attrs: List(Attribute(a))) -> Element(a)

file_md_thin

</> 
pub fn file_md_thin(attrs: List(Attribute(a))) -> Element(a)

file_minus_bold

</> 
pub fn file_minus_bold(attrs: List(Attribute(a))) -> Element(a)

file_minus_duotone

</> 
pub fn file_minus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_minus_fill

</> 
pub fn file_minus_fill(attrs: List(Attribute(a))) -> Element(a)

file_minus_light

</> 
pub fn file_minus_light(attrs: List(Attribute(a))) -> Element(a)

file_minus_regular

</> 
pub fn file_minus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_minus_thin

</> 
pub fn file_minus_thin(attrs: List(Attribute(a))) -> Element(a)

file_pdf_bold

</> 
pub fn file_pdf_bold(attrs: List(Attribute(a))) -> Element(a)

file_pdf_duotone

</> 
pub fn file_pdf_duotone(attrs: List(Attribute(a))) -> Element(a)

file_pdf_fill

</> 
pub fn file_pdf_fill(attrs: List(Attribute(a))) -> Element(a)

file_pdf_light

</> 
pub fn file_pdf_light(attrs: List(Attribute(a))) -> Element(a)

file_pdf_regular

</> 
pub fn file_pdf_regular(attrs: List(Attribute(a))) -> Element(a)

file_pdf_thin

</> 
pub fn file_pdf_thin(attrs: List(Attribute(a))) -> Element(a)

file_plus_bold

</> 
pub fn file_plus_bold(attrs: List(Attribute(a))) -> Element(a)

file_plus_duotone

</> 
pub fn file_plus_duotone(attrs: List(Attribute(a))) -> Element(a)

file_plus_fill

</> 
pub fn file_plus_fill(attrs: List(Attribute(a))) -> Element(a)

file_plus_light

</> 
pub fn file_plus_light(attrs: List(Attribute(a))) -> Element(a)

file_plus_regular

</> 
pub fn file_plus_regular(attrs: List(Attribute(a))) -> Element(a)

file_plus_thin

</> 
pub fn file_plus_thin(attrs: List(Attribute(a))) -> Element(a)

file_png_bold

</> 
pub fn file_png_bold(attrs: List(Attribute(a))) -> Element(a)

file_png_duotone

</> 
pub fn file_png_duotone(attrs: List(Attribute(a))) -> Element(a)

file_png_fill

</> 
pub fn file_png_fill(attrs: List(Attribute(a))) -> Element(a)

file_png_light

</> 
pub fn file_png_light(attrs: List(Attribute(a))) -> Element(a)

file_png_regular

</> 
pub fn file_png_regular(attrs: List(Attribute(a))) -> Element(a)

file_png_thin

</> 
pub fn file_png_thin(attrs: List(Attribute(a))) -> Element(a)

file_ppt_bold

</> 
pub fn file_ppt_bold(attrs: List(Attribute(a))) -> Element(a)

file_ppt_duotone

</> 
pub fn file_ppt_duotone(attrs: List(Attribute(a))) -> Element(a)

file_ppt_fill

</> 
pub fn file_ppt_fill(attrs: List(Attribute(a))) -> Element(a)

file_ppt_light

</> 
pub fn file_ppt_light(attrs: List(Attribute(a))) -> Element(a)

file_ppt_regular

</> 
pub fn file_ppt_regular(attrs: List(Attribute(a))) -> Element(a)

file_ppt_thin

</> 
pub fn file_ppt_thin(attrs: List(Attribute(a))) -> Element(a)

file_py_bold

</> 
pub fn file_py_bold(attrs: List(Attribute(a))) -> Element(a)

file_py_duotone

</> 
pub fn file_py_duotone(attrs: List(Attribute(a))) -> Element(a)

file_py_fill

</> 
pub fn file_py_fill(attrs: List(Attribute(a))) -> Element(a)

file_py_light

</> 
pub fn file_py_light(attrs: List(Attribute(a))) -> Element(a)

file_py_regular

</> 
pub fn file_py_regular(attrs: List(Attribute(a))) -> Element(a)

file_py_thin

</> 
pub fn file_py_thin(attrs: List(Attribute(a))) -> Element(a)

file_regular

</> 
pub fn file_regular(attrs: List(Attribute(a))) -> Element(a)

file_rs_bold

</> 
pub fn file_rs_bold(attrs: List(Attribute(a))) -> Element(a)

file_rs_duotone

</> 
pub fn file_rs_duotone(attrs: List(Attribute(a))) -> Element(a)

file_rs_fill

</> 
pub fn file_rs_fill(attrs: List(Attribute(a))) -> Element(a)

file_rs_light

</> 
pub fn file_rs_light(attrs: List(Attribute(a))) -> Element(a)

file_rs_regular

</> 
pub fn file_rs_regular(attrs: List(Attribute(a))) -> Element(a)

file_rs_thin

</> 
pub fn file_rs_thin(attrs: List(Attribute(a))) -> Element(a)

file_sql_bold

</> 
pub fn file_sql_bold(attrs: List(Attribute(a))) -> Element(a)

file_sql_duotone

</> 
pub fn file_sql_duotone(attrs: List(Attribute(a))) -> Element(a)

file_sql_fill

</> 
pub fn file_sql_fill(attrs: List(Attribute(a))) -> Element(a)

file_sql_light

</> 
pub fn file_sql_light(attrs: List(Attribute(a))) -> Element(a)

file_sql_regular

</> 
pub fn file_sql_regular(attrs: List(Attribute(a))) -> Element(a)

file_sql_thin

</> 
pub fn file_sql_thin(attrs: List(Attribute(a))) -> Element(a)

file_svg_bold

</> 
pub fn file_svg_bold(attrs: List(Attribute(a))) -> Element(a)

file_svg_duotone

</> 
pub fn file_svg_duotone(attrs: List(Attribute(a))) -> Element(a)

file_svg_fill

</> 
pub fn file_svg_fill(attrs: List(Attribute(a))) -> Element(a)

file_svg_light

</> 
pub fn file_svg_light(attrs: List(Attribute(a))) -> Element(a)

file_svg_regular

</> 
pub fn file_svg_regular(attrs: List(Attribute(a))) -> Element(a)

file_svg_thin

</> 
pub fn file_svg_thin(attrs: List(Attribute(a))) -> Element(a)

file_text_bold

</> 
pub fn file_text_bold(attrs: List(Attribute(a))) -> Element(a)

file_text_duotone

</> 
pub fn file_text_duotone(attrs: List(Attribute(a))) -> Element(a)

file_text_fill

</> 
pub fn file_text_fill(attrs: List(Attribute(a))) -> Element(a)

file_text_light

</> 
pub fn file_text_light(attrs: List(Attribute(a))) -> Element(a)

file_text_regular

</> 
pub fn file_text_regular(attrs: List(Attribute(a))) -> Element(a)

file_text_thin

</> 
pub fn file_text_thin(attrs: List(Attribute(a))) -> Element(a)

file_thin

</> 
pub fn file_thin(attrs: List(Attribute(a))) -> Element(a)

file_ts_bold

</> 
pub fn file_ts_bold(attrs: List(Attribute(a))) -> Element(a)

file_ts_duotone

</> 
pub fn file_ts_duotone(attrs: List(Attribute(a))) -> Element(a)

file_ts_fill

</> 
pub fn file_ts_fill(attrs: List(Attribute(a))) -> Element(a)

file_ts_light

</> 
pub fn file_ts_light(attrs: List(Attribute(a))) -> Element(a)

file_ts_regular

</> 
pub fn file_ts_regular(attrs: List(Attribute(a))) -> Element(a)

file_ts_thin

</> 
pub fn file_ts_thin(attrs: List(Attribute(a))) -> Element(a)

file_tsx_bold

</> 
pub fn file_tsx_bold(attrs: List(Attribute(a))) -> Element(a)

file_tsx_duotone

</> 
pub fn file_tsx_duotone(attrs: List(Attribute(a))) -> Element(a)

file_tsx_fill

</> 
pub fn file_tsx_fill(attrs: List(Attribute(a))) -> Element(a)

file_tsx_light

</> 
pub fn file_tsx_light(attrs: List(Attribute(a))) -> Element(a)

file_tsx_regular

</> 
pub fn file_tsx_regular(attrs: List(Attribute(a))) -> Element(a)

file_tsx_thin

</> 
pub fn file_tsx_thin(attrs: List(Attribute(a))) -> Element(a)

file_txt_bold

</> 
pub fn file_txt_bold(attrs: List(Attribute(a))) -> Element(a)

file_txt_duotone

</> 
pub fn file_txt_duotone(attrs: List(Attribute(a))) -> Element(a)

file_txt_fill

</> 
pub fn file_txt_fill(attrs: List(Attribute(a))) -> Element(a)

file_txt_light

</> 
pub fn file_txt_light(attrs: List(Attribute(a))) -> Element(a)

file_txt_regular

</> 
pub fn file_txt_regular(attrs: List(Attribute(a))) -> Element(a)

file_txt_thin

</> 
pub fn file_txt_thin(attrs: List(Attribute(a))) -> Element(a)

file_video_bold

</> 
pub fn file_video_bold(attrs: List(Attribute(a))) -> Element(a)

file_video_duotone

</> 
pub fn file_video_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

file_video_fill

</> 
pub fn file_video_fill(attrs: List(Attribute(a))) -> Element(a)

file_video_light

</> 
pub fn file_video_light(attrs: List(Attribute(a))) -> Element(a)

file_video_regular

</> 
pub fn file_video_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

file_video_thin

</> 
pub fn file_video_thin(attrs: List(Attribute(a))) -> Element(a)

file_vue_bold

</> 
pub fn file_vue_bold(attrs: List(Attribute(a))) -> Element(a)

file_vue_duotone

</> 
pub fn file_vue_duotone(attrs: List(Attribute(a))) -> Element(a)

file_vue_fill

</> 
pub fn file_vue_fill(attrs: List(Attribute(a))) -> Element(a)

file_vue_light

</> 
pub fn file_vue_light(attrs: List(Attribute(a))) -> Element(a)

file_vue_regular

</> 
pub fn file_vue_regular(attrs: List(Attribute(a))) -> Element(a)

file_vue_thin

</> 
pub fn file_vue_thin(attrs: List(Attribute(a))) -> Element(a)

file_x_bold

</> 
pub fn file_x_bold(attrs: List(Attribute(a))) -> Element(a)

file_x_duotone

</> 
pub fn file_x_duotone(attrs: List(Attribute(a))) -> Element(a)

file_x_fill

</> 
pub fn file_x_fill(attrs: List(Attribute(a))) -> Element(a)

file_x_light

</> 
pub fn file_x_light(attrs: List(Attribute(a))) -> Element(a)

file_x_regular

</> 
pub fn file_x_regular(attrs: List(Attribute(a))) -> Element(a)

file_x_thin

</> 
pub fn file_x_thin(attrs: List(Attribute(a))) -> Element(a)

file_xls_bold

</> 
pub fn file_xls_bold(attrs: List(Attribute(a))) -> Element(a)

file_xls_duotone

</> 
pub fn file_xls_duotone(attrs: List(Attribute(a))) -> Element(a)

file_xls_fill

</> 
pub fn file_xls_fill(attrs: List(Attribute(a))) -> Element(a)

file_xls_light

</> 
pub fn file_xls_light(attrs: List(Attribute(a))) -> Element(a)

file_xls_regular

</> 
pub fn file_xls_regular(attrs: List(Attribute(a))) -> Element(a)

file_xls_thin

</> 
pub fn file_xls_thin(attrs: List(Attribute(a))) -> Element(a)

file_zip_bold

</> 
pub fn file_zip_bold(attrs: List(Attribute(a))) -> Element(a)

file_zip_duotone

</> 
pub fn file_zip_duotone(attrs: List(Attribute(a))) -> Element(a)

file_zip_fill

</> 
pub fn file_zip_fill(attrs: List(Attribute(a))) -> Element(a)

file_zip_light

</> 
pub fn file_zip_light(attrs: List(Attribute(a))) -> Element(a)

file_zip_regular

</> 
pub fn file_zip_regular(attrs: List(Attribute(a))) -> Element(a)

file_zip_thin

</> 
pub fn file_zip_thin(attrs: List(Attribute(a))) -> Element(a)

files_bold

</> 
pub fn files_bold(attrs: List(Attribute(a))) -> Element(a)

files_duotone

</> 
pub fn files_duotone(attrs: List(Attribute(a))) -> Element(a)

files_fill

</> 
pub fn files_fill(attrs: List(Attribute(a))) -> Element(a)

files_light

</> 
pub fn files_light(attrs: List(Attribute(a))) -> Element(a)

files_regular

</> 
pub fn files_regular(attrs: List(Attribute(a))) -> Element(a)

files_thin

</> 
pub fn files_thin(attrs: List(Attribute(a))) -> Element(a)

film_reel_bold

</> 
pub fn film_reel_bold(attrs: List(Attribute(a))) -> Element(a)

film_reel_duotone

</> 
pub fn film_reel_duotone(attrs: List(Attribute(a))) -> Element(a)

film_reel_fill

</> 
pub fn film_reel_fill(attrs: List(Attribute(a))) -> Element(a)

film_reel_light

</> 
pub fn film_reel_light(attrs: List(Attribute(a))) -> Element(a)

film_reel_regular

</> 
pub fn film_reel_regular(attrs: List(Attribute(a))) -> Element(a)

film_reel_thin

</> 
pub fn film_reel_thin(attrs: List(Attribute(a))) -> Element(a)

film_script_bold

</> 
pub fn film_script_bold(attrs: List(Attribute(a))) -> Element(a)

film_script_duotone

</> 
pub fn film_script_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

film_script_fill

</> 
pub fn film_script_fill(attrs: List(Attribute(a))) -> Element(a)

film_script_light

</> 
pub fn film_script_light(attrs: List(Attribute(a))) -> Element(a)

film_script_regular

</> 
pub fn film_script_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

film_script_thin

</> 
pub fn film_script_thin(attrs: List(Attribute(a))) -> Element(a)

film_slate_bold

</> 
pub fn film_slate_bold(attrs: List(Attribute(a))) -> Element(a)

film_slate_duotone

</> 
pub fn film_slate_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

film_slate_fill

</> 
pub fn film_slate_fill(attrs: List(Attribute(a))) -> Element(a)

film_slate_light

</> 
pub fn film_slate_light(attrs: List(Attribute(a))) -> Element(a)

film_slate_regular

</> 
pub fn film_slate_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

film_slate_thin

</> 
pub fn film_slate_thin(attrs: List(Attribute(a))) -> Element(a)

film_strip_bold

</> 
pub fn film_strip_bold(attrs: List(Attribute(a))) -> Element(a)

film_strip_duotone

</> 
pub fn film_strip_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

film_strip_fill

</> 
pub fn film_strip_fill(attrs: List(Attribute(a))) -> Element(a)

film_strip_light

</> 
pub fn film_strip_light(attrs: List(Attribute(a))) -> Element(a)

film_strip_regular

</> 
pub fn film_strip_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

film_strip_thin

</> 
pub fn film_strip_thin(attrs: List(Attribute(a))) -> Element(a)

fingerprint_bold

</> 
pub fn fingerprint_bold(attrs: List(Attribute(a))) -> Element(a)

fingerprint_duotone

</> 
pub fn fingerprint_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fingerprint_fill

</> 
pub fn fingerprint_fill(attrs: List(Attribute(a))) -> Element(a)

fingerprint_light

</> 
pub fn fingerprint_light(attrs: List(Attribute(a))) -> Element(a)

fingerprint_regular

</> 
pub fn fingerprint_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fingerprint_simple_bold

</> 
pub fn fingerprint_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

fingerprint_simple_duotone

</> 
pub fn fingerprint_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fingerprint_simple_fill

</> 
pub fn fingerprint_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

fingerprint_simple_light

</> 
pub fn fingerprint_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

fingerprint_simple_regular

</> 
pub fn fingerprint_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fingerprint_simple_thin

</> 
pub fn fingerprint_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

fingerprint_thin

</> 
pub fn fingerprint_thin(attrs: List(Attribute(a))) -> Element(a)

finn_the_human_bold

</> 
pub fn finn_the_human_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

finn_the_human_duotone

</> 
pub fn finn_the_human_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

finn_the_human_fill

</> 
pub fn finn_the_human_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

finn_the_human_light

</> 
pub fn finn_the_human_light(
  attrs: List(Attribute(a)),
) -> Element(a)

finn_the_human_regular

</> 
pub fn finn_the_human_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

finn_the_human_thin

</> 
pub fn finn_the_human_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_bold

</> 
pub fn fire_bold(attrs: List(Attribute(a))) -> Element(a)

fire_duotone

</> 
pub fn fire_duotone(attrs: List(Attribute(a))) -> Element(a)

fire_extinguisher_bold

</> 
pub fn fire_extinguisher_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_extinguisher_duotone

</> 
pub fn fire_extinguisher_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_extinguisher_fill

</> 
pub fn fire_extinguisher_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_extinguisher_light

</> 
pub fn fire_extinguisher_light(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_extinguisher_regular

</> 
pub fn fire_extinguisher_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_extinguisher_thin

</> 
pub fn fire_extinguisher_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_fill

</> 
pub fn fire_fill(attrs: List(Attribute(a))) -> Element(a)

fire_light

</> 
pub fn fire_light(attrs: List(Attribute(a))) -> Element(a)

fire_regular

</> 
pub fn fire_regular(attrs: List(Attribute(a))) -> Element(a)

fire_simple_bold

</> 
pub fn fire_simple_bold(attrs: List(Attribute(a))) -> Element(a)

fire_simple_duotone

</> 
pub fn fire_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_simple_fill

</> 
pub fn fire_simple_fill(attrs: List(Attribute(a))) -> Element(a)

fire_simple_light

</> 
pub fn fire_simple_light(attrs: List(Attribute(a))) -> Element(a)

fire_simple_regular

</> 
pub fn fire_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_simple_thin

</> 
pub fn fire_simple_thin(attrs: List(Attribute(a))) -> Element(a)

fire_thin

</> 
pub fn fire_thin(attrs: List(Attribute(a))) -> Element(a)

fire_truck_bold

</> 
pub fn fire_truck_bold(attrs: List(Attribute(a))) -> Element(a)

fire_truck_duotone

</> 
pub fn fire_truck_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_truck_fill

</> 
pub fn fire_truck_fill(attrs: List(Attribute(a))) -> Element(a)

fire_truck_light

</> 
pub fn fire_truck_light(attrs: List(Attribute(a))) -> Element(a)

fire_truck_regular

</> 
pub fn fire_truck_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fire_truck_thin

</> 
pub fn fire_truck_thin(attrs: List(Attribute(a))) -> Element(a)

first_aid_bold

</> 
pub fn first_aid_bold(attrs: List(Attribute(a))) -> Element(a)

first_aid_duotone

</> 
pub fn first_aid_duotone(attrs: List(Attribute(a))) -> Element(a)

first_aid_fill

</> 
pub fn first_aid_fill(attrs: List(Attribute(a))) -> Element(a)

first_aid_kit_bold

</> 
pub fn first_aid_kit_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

first_aid_kit_duotone

</> 
pub fn first_aid_kit_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

first_aid_kit_fill

</> 
pub fn first_aid_kit_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

first_aid_kit_light

</> 
pub fn first_aid_kit_light(
  attrs: List(Attribute(a)),
) -> Element(a)

first_aid_kit_regular

</> 
pub fn first_aid_kit_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

first_aid_kit_thin

</> 
pub fn first_aid_kit_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

first_aid_light

</> 
pub fn first_aid_light(attrs: List(Attribute(a))) -> Element(a)

first_aid_regular

</> 
pub fn first_aid_regular(attrs: List(Attribute(a))) -> Element(a)

first_aid_thin

</> 
pub fn first_aid_thin(attrs: List(Attribute(a))) -> Element(a)

fish_bold

</> 
pub fn fish_bold(attrs: List(Attribute(a))) -> Element(a)

fish_duotone

</> 
pub fn fish_duotone(attrs: List(Attribute(a))) -> Element(a)

fish_fill

</> 
pub fn fish_fill(attrs: List(Attribute(a))) -> Element(a)

fish_light

</> 
pub fn fish_light(attrs: List(Attribute(a))) -> Element(a)

fish_regular

</> 
pub fn fish_regular(attrs: List(Attribute(a))) -> Element(a)

fish_simple_bold

</> 
pub fn fish_simple_bold(attrs: List(Attribute(a))) -> Element(a)

fish_simple_duotone

</> 
pub fn fish_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fish_simple_fill

</> 
pub fn fish_simple_fill(attrs: List(Attribute(a))) -> Element(a)

fish_simple_light

</> 
pub fn fish_simple_light(attrs: List(Attribute(a))) -> Element(a)

fish_simple_regular

</> 
pub fn fish_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fish_simple_thin

</> 
pub fn fish_simple_thin(attrs: List(Attribute(a))) -> Element(a)

fish_thin

</> 
pub fn fish_thin(attrs: List(Attribute(a))) -> Element(a)

flag_banner_bold

</> 
pub fn flag_banner_bold(attrs: List(Attribute(a))) -> Element(a)

flag_banner_duotone

</> 
pub fn flag_banner_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_banner_fill

</> 
pub fn flag_banner_fill(attrs: List(Attribute(a))) -> Element(a)

flag_banner_fold_bold

</> 
pub fn flag_banner_fold_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_banner_fold_duotone

</> 
pub fn flag_banner_fold_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_banner_fold_fill

</> 
pub fn flag_banner_fold_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_banner_fold_light

</> 
pub fn flag_banner_fold_light(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_banner_fold_regular

</> 
pub fn flag_banner_fold_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_banner_fold_thin

</> 
pub fn flag_banner_fold_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_banner_light

</> 
pub fn flag_banner_light(attrs: List(Attribute(a))) -> Element(a)

flag_banner_regular

</> 
pub fn flag_banner_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_banner_thin

</> 
pub fn flag_banner_thin(attrs: List(Attribute(a))) -> Element(a)

flag_bold

</> 
pub fn flag_bold(attrs: List(Attribute(a))) -> Element(a)

flag_checkered_bold

</> 
pub fn flag_checkered_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_checkered_duotone

</> 
pub fn flag_checkered_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_checkered_fill

</> 
pub fn flag_checkered_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_checkered_light

</> 
pub fn flag_checkered_light(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_checkered_regular

</> 
pub fn flag_checkered_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_checkered_thin

</> 
pub fn flag_checkered_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_duotone

</> 
pub fn flag_duotone(attrs: List(Attribute(a))) -> Element(a)

flag_fill

</> 
pub fn flag_fill(attrs: List(Attribute(a))) -> Element(a)

flag_light

</> 
pub fn flag_light(attrs: List(Attribute(a))) -> Element(a)

flag_pennant_bold

</> 
pub fn flag_pennant_bold(attrs: List(Attribute(a))) -> Element(a)

flag_pennant_duotone

</> 
pub fn flag_pennant_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_pennant_fill

</> 
pub fn flag_pennant_fill(attrs: List(Attribute(a))) -> Element(a)

flag_pennant_light

</> 
pub fn flag_pennant_light(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_pennant_regular

</> 
pub fn flag_pennant_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flag_pennant_thin

</> 
pub fn flag_pennant_thin(attrs: List(Attribute(a))) -> Element(a)

flag_regular

</> 
pub fn flag_regular(attrs: List(Attribute(a))) -> Element(a)

flag_thin

</> 
pub fn flag_thin(attrs: List(Attribute(a))) -> Element(a)

flame_bold

</> 
pub fn flame_bold(attrs: List(Attribute(a))) -> Element(a)

flame_duotone

</> 
pub fn flame_duotone(attrs: List(Attribute(a))) -> Element(a)

flame_fill

</> 
pub fn flame_fill(attrs: List(Attribute(a))) -> Element(a)

flame_light

</> 
pub fn flame_light(attrs: List(Attribute(a))) -> Element(a)

flame_regular

</> 
pub fn flame_regular(attrs: List(Attribute(a))) -> Element(a)

flame_thin

</> 
pub fn flame_thin(attrs: List(Attribute(a))) -> Element(a)

flashlight_bold

</> 
pub fn flashlight_bold(attrs: List(Attribute(a))) -> Element(a)

flashlight_duotone

</> 
pub fn flashlight_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flashlight_fill

</> 
pub fn flashlight_fill(attrs: List(Attribute(a))) -> Element(a)

flashlight_light

</> 
pub fn flashlight_light(attrs: List(Attribute(a))) -> Element(a)

flashlight_regular

</> 
pub fn flashlight_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flashlight_thin

</> 
pub fn flashlight_thin(attrs: List(Attribute(a))) -> Element(a)

flask_bold

</> 
pub fn flask_bold(attrs: List(Attribute(a))) -> Element(a)

flask_duotone

</> 
pub fn flask_duotone(attrs: List(Attribute(a))) -> Element(a)

flask_fill

</> 
pub fn flask_fill(attrs: List(Attribute(a))) -> Element(a)

flask_light

</> 
pub fn flask_light(attrs: List(Attribute(a))) -> Element(a)

flask_regular

</> 
pub fn flask_regular(attrs: List(Attribute(a))) -> Element(a)

flask_thin

</> 
pub fn flask_thin(attrs: List(Attribute(a))) -> Element(a)

flip_horizontal_bold

</> 
pub fn flip_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_horizontal_duotone

</> 
pub fn flip_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_horizontal_fill

</> 
pub fn flip_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_horizontal_light

</> 
pub fn flip_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_horizontal_regular

</> 
pub fn flip_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_horizontal_thin

</> 
pub fn flip_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_vertical_bold

</> 
pub fn flip_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_vertical_duotone

</> 
pub fn flip_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_vertical_fill

</> 
pub fn flip_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_vertical_light

</> 
pub fn flip_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_vertical_regular

</> 
pub fn flip_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flip_vertical_thin

</> 
pub fn flip_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

floppy_disk_back_bold

</> 
pub fn floppy_disk_back_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

floppy_disk_back_duotone

</> 
pub fn floppy_disk_back_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

floppy_disk_back_fill

</> 
pub fn floppy_disk_back_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

floppy_disk_back_light

</> 
pub fn floppy_disk_back_light(
  attrs: List(Attribute(a)),
) -> Element(a)

floppy_disk_back_regular

</> 
pub fn floppy_disk_back_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

floppy_disk_back_thin

</> 
pub fn floppy_disk_back_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

floppy_disk_bold

</> 
pub fn floppy_disk_bold(attrs: List(Attribute(a))) -> Element(a)

floppy_disk_duotone

</> 
pub fn floppy_disk_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

floppy_disk_fill

</> 
pub fn floppy_disk_fill(attrs: List(Attribute(a))) -> Element(a)

floppy_disk_light

</> 
pub fn floppy_disk_light(attrs: List(Attribute(a))) -> Element(a)

floppy_disk_regular

</> 
pub fn floppy_disk_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

floppy_disk_thin

</> 
pub fn floppy_disk_thin(attrs: List(Attribute(a))) -> Element(a)

flow_arrow_bold

</> 
pub fn flow_arrow_bold(attrs: List(Attribute(a))) -> Element(a)

flow_arrow_duotone

</> 
pub fn flow_arrow_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flow_arrow_fill

</> 
pub fn flow_arrow_fill(attrs: List(Attribute(a))) -> Element(a)

flow_arrow_light

</> 
pub fn flow_arrow_light(attrs: List(Attribute(a))) -> Element(a)

flow_arrow_regular

</> 
pub fn flow_arrow_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flow_arrow_thin

</> 
pub fn flow_arrow_thin(attrs: List(Attribute(a))) -> Element(a)

flower_bold

</> 
pub fn flower_bold(attrs: List(Attribute(a))) -> Element(a)

flower_duotone

</> 
pub fn flower_duotone(attrs: List(Attribute(a))) -> Element(a)

flower_fill

</> 
pub fn flower_fill(attrs: List(Attribute(a))) -> Element(a)

flower_light

</> 
pub fn flower_light(attrs: List(Attribute(a))) -> Element(a)

flower_lotus_bold

</> 
pub fn flower_lotus_bold(attrs: List(Attribute(a))) -> Element(a)

flower_lotus_duotone

</> 
pub fn flower_lotus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flower_lotus_fill

</> 
pub fn flower_lotus_fill(attrs: List(Attribute(a))) -> Element(a)

flower_lotus_light

</> 
pub fn flower_lotus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

flower_lotus_regular

</> 
pub fn flower_lotus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flower_lotus_thin

</> 
pub fn flower_lotus_thin(attrs: List(Attribute(a))) -> Element(a)

flower_regular

</> 
pub fn flower_regular(attrs: List(Attribute(a))) -> Element(a)

flower_thin

</> 
pub fn flower_thin(attrs: List(Attribute(a))) -> Element(a)

flower_tulip_bold

</> 
pub fn flower_tulip_bold(attrs: List(Attribute(a))) -> Element(a)

flower_tulip_duotone

</> 
pub fn flower_tulip_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flower_tulip_fill

</> 
pub fn flower_tulip_fill(attrs: List(Attribute(a))) -> Element(a)

flower_tulip_light

</> 
pub fn flower_tulip_light(
  attrs: List(Attribute(a)),
) -> Element(a)

flower_tulip_regular

</> 
pub fn flower_tulip_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flower_tulip_thin

</> 
pub fn flower_tulip_thin(attrs: List(Attribute(a))) -> Element(a)

flying_saucer_bold

</> 
pub fn flying_saucer_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

flying_saucer_duotone

</> 
pub fn flying_saucer_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

flying_saucer_fill

</> 
pub fn flying_saucer_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

flying_saucer_light

</> 
pub fn flying_saucer_light(
  attrs: List(Attribute(a)),
) -> Element(a)

flying_saucer_regular

</> 
pub fn flying_saucer_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

flying_saucer_thin

</> 
pub fn flying_saucer_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_bold

</> 
pub fn folder_bold(attrs: List(Attribute(a))) -> Element(a)

folder_dashed_bold

</> 
pub fn folder_dashed_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_dashed_duotone

</> 
pub fn folder_dashed_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_dashed_fill

</> 
pub fn folder_dashed_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_dashed_light

</> 
pub fn folder_dashed_light(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_dashed_regular

</> 
pub fn folder_dashed_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_dashed_thin

</> 
pub fn folder_dashed_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_duotone

</> 
pub fn folder_duotone(attrs: List(Attribute(a))) -> Element(a)

folder_fill

</> 
pub fn folder_fill(attrs: List(Attribute(a))) -> Element(a)

folder_light

</> 
pub fn folder_light(attrs: List(Attribute(a))) -> Element(a)

folder_lock_bold

</> 
pub fn folder_lock_bold(attrs: List(Attribute(a))) -> Element(a)

folder_lock_duotone

</> 
pub fn folder_lock_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_lock_fill

</> 
pub fn folder_lock_fill(attrs: List(Attribute(a))) -> Element(a)

folder_lock_light

</> 
pub fn folder_lock_light(attrs: List(Attribute(a))) -> Element(a)

folder_lock_regular

</> 
pub fn folder_lock_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_lock_thin

</> 
pub fn folder_lock_thin(attrs: List(Attribute(a))) -> Element(a)

folder_minus_bold

</> 
pub fn folder_minus_bold(attrs: List(Attribute(a))) -> Element(a)

folder_minus_duotone

</> 
pub fn folder_minus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_minus_fill

</> 
pub fn folder_minus_fill(attrs: List(Attribute(a))) -> Element(a)

folder_minus_light

</> 
pub fn folder_minus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_minus_regular

</> 
pub fn folder_minus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_minus_thin

</> 
pub fn folder_minus_thin(attrs: List(Attribute(a))) -> Element(a)

folder_open_bold

</> 
pub fn folder_open_bold(attrs: List(Attribute(a))) -> Element(a)

folder_open_duotone

</> 
pub fn folder_open_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_open_fill

</> 
pub fn folder_open_fill(attrs: List(Attribute(a))) -> Element(a)

folder_open_light

</> 
pub fn folder_open_light(attrs: List(Attribute(a))) -> Element(a)

folder_open_regular

</> 
pub fn folder_open_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_open_thin

</> 
pub fn folder_open_thin(attrs: List(Attribute(a))) -> Element(a)

folder_plus_bold

</> 
pub fn folder_plus_bold(attrs: List(Attribute(a))) -> Element(a)

folder_plus_duotone

</> 
pub fn folder_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_plus_fill

</> 
pub fn folder_plus_fill(attrs: List(Attribute(a))) -> Element(a)

folder_plus_light

</> 
pub fn folder_plus_light(attrs: List(Attribute(a))) -> Element(a)

folder_plus_regular

</> 
pub fn folder_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_plus_thin

</> 
pub fn folder_plus_thin(attrs: List(Attribute(a))) -> Element(a)

folder_regular

</> 
pub fn folder_regular(attrs: List(Attribute(a))) -> Element(a)

folder_simple_bold

</> 
pub fn folder_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_dashed_bold

</> 
pub fn folder_simple_dashed_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_dashed_duotone

</> 
pub fn folder_simple_dashed_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_dashed_fill

</> 
pub fn folder_simple_dashed_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_dashed_light

</> 
pub fn folder_simple_dashed_light(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_dashed_regular

</> 
pub fn folder_simple_dashed_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_dashed_thin

</> 
pub fn folder_simple_dashed_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_duotone

</> 
pub fn folder_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_fill

</> 
pub fn folder_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_light

</> 
pub fn folder_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_lock_bold

</> 
pub fn folder_simple_lock_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_lock_duotone

</> 
pub fn folder_simple_lock_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_lock_fill

</> 
pub fn folder_simple_lock_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_lock_light

</> 
pub fn folder_simple_lock_light(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_lock_regular

</> 
pub fn folder_simple_lock_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_lock_thin

</> 
pub fn folder_simple_lock_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_minus_bold

</> 
pub fn folder_simple_minus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_minus_duotone

</> 
pub fn folder_simple_minus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_minus_fill

</> 
pub fn folder_simple_minus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_minus_light

</> 
pub fn folder_simple_minus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_minus_regular

</> 
pub fn folder_simple_minus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_minus_thin

</> 
pub fn folder_simple_minus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_plus_bold

</> 
pub fn folder_simple_plus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_plus_duotone

</> 
pub fn folder_simple_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_plus_fill

</> 
pub fn folder_simple_plus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_plus_light

</> 
pub fn folder_simple_plus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_plus_regular

</> 
pub fn folder_simple_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_plus_thin

</> 
pub fn folder_simple_plus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_regular

</> 
pub fn folder_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_star_bold

</> 
pub fn folder_simple_star_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_star_duotone

</> 
pub fn folder_simple_star_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_star_fill

</> 
pub fn folder_simple_star_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_star_light

</> 
pub fn folder_simple_star_light(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_star_regular

</> 
pub fn folder_simple_star_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_star_thin

</> 
pub fn folder_simple_star_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_thin

</> 
pub fn folder_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_user_bold

</> 
pub fn folder_simple_user_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_user_duotone

</> 
pub fn folder_simple_user_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_user_fill

</> 
pub fn folder_simple_user_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_user_light

</> 
pub fn folder_simple_user_light(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_user_regular

</> 
pub fn folder_simple_user_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_simple_user_thin

</> 
pub fn folder_simple_user_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_star_bold

</> 
pub fn folder_star_bold(attrs: List(Attribute(a))) -> Element(a)

folder_star_duotone

</> 
pub fn folder_star_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_star_fill

</> 
pub fn folder_star_fill(attrs: List(Attribute(a))) -> Element(a)

folder_star_light

</> 
pub fn folder_star_light(attrs: List(Attribute(a))) -> Element(a)

folder_star_regular

</> 
pub fn folder_star_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_star_thin

</> 
pub fn folder_star_thin(attrs: List(Attribute(a))) -> Element(a)

folder_thin

</> 
pub fn folder_thin(attrs: List(Attribute(a))) -> Element(a)

folder_user_bold

</> 
pub fn folder_user_bold(attrs: List(Attribute(a))) -> Element(a)

folder_user_duotone

</> 
pub fn folder_user_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_user_fill

</> 
pub fn folder_user_fill(attrs: List(Attribute(a))) -> Element(a)

folder_user_light

</> 
pub fn folder_user_light(attrs: List(Attribute(a))) -> Element(a)

folder_user_regular

</> 
pub fn folder_user_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

folder_user_thin

</> 
pub fn folder_user_thin(attrs: List(Attribute(a))) -> Element(a)

folders_bold

</> 
pub fn folders_bold(attrs: List(Attribute(a))) -> Element(a)

folders_duotone

</> 
pub fn folders_duotone(attrs: List(Attribute(a))) -> Element(a)

folders_fill

</> 
pub fn folders_fill(attrs: List(Attribute(a))) -> Element(a)

folders_light

</> 
pub fn folders_light(attrs: List(Attribute(a))) -> Element(a)

folders_regular

</> 
pub fn folders_regular(attrs: List(Attribute(a))) -> Element(a)

folders_thin

</> 
pub fn folders_thin(attrs: List(Attribute(a))) -> Element(a)

football_bold

</> 
pub fn football_bold(attrs: List(Attribute(a))) -> Element(a)

football_duotone

</> 
pub fn football_duotone(attrs: List(Attribute(a))) -> Element(a)

football_fill

</> 
pub fn football_fill(attrs: List(Attribute(a))) -> Element(a)

football_helmet_bold

</> 
pub fn football_helmet_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

football_helmet_duotone

</> 
pub fn football_helmet_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

football_helmet_fill

</> 
pub fn football_helmet_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

football_helmet_light

</> 
pub fn football_helmet_light(
  attrs: List(Attribute(a)),
) -> Element(a)

football_helmet_regular

</> 
pub fn football_helmet_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

football_helmet_thin

</> 
pub fn football_helmet_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

football_light

</> 
pub fn football_light(attrs: List(Attribute(a))) -> Element(a)

football_regular

</> 
pub fn football_regular(attrs: List(Attribute(a))) -> Element(a)

football_thin

</> 
pub fn football_thin(attrs: List(Attribute(a))) -> Element(a)

footprints_bold

</> 
pub fn footprints_bold(attrs: List(Attribute(a))) -> Element(a)

footprints_duotone

</> 
pub fn footprints_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

footprints_fill

</> 
pub fn footprints_fill(attrs: List(Attribute(a))) -> Element(a)

footprints_light

</> 
pub fn footprints_light(attrs: List(Attribute(a))) -> Element(a)

footprints_regular

</> 
pub fn footprints_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

footprints_thin

</> 
pub fn footprints_thin(attrs: List(Attribute(a))) -> Element(a)

fork_knife_bold

</> 
pub fn fork_knife_bold(attrs: List(Attribute(a))) -> Element(a)

fork_knife_duotone

</> 
pub fn fork_knife_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

fork_knife_fill

</> 
pub fn fork_knife_fill(attrs: List(Attribute(a))) -> Element(a)

fork_knife_light

</> 
pub fn fork_knife_light(attrs: List(Attribute(a))) -> Element(a)

fork_knife_regular

</> 
pub fn fork_knife_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

fork_knife_thin

</> 
pub fn fork_knife_thin(attrs: List(Attribute(a))) -> Element(a)

four_k_bold

</> 
pub fn four_k_bold(attrs: List(Attribute(a))) -> Element(a)

four_k_duotone

</> 
pub fn four_k_duotone(attrs: List(Attribute(a))) -> Element(a)

four_k_fill

</> 
pub fn four_k_fill(attrs: List(Attribute(a))) -> Element(a)

four_k_light

</> 
pub fn four_k_light(attrs: List(Attribute(a))) -> Element(a)

four_k_regular

</> 
pub fn four_k_regular(attrs: List(Attribute(a))) -> Element(a)

four_k_thin

</> 
pub fn four_k_thin(attrs: List(Attribute(a))) -> Element(a)

frame_corners_bold

</> 
pub fn frame_corners_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

frame_corners_duotone

</> 
pub fn frame_corners_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

frame_corners_fill

</> 
pub fn frame_corners_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

frame_corners_light

</> 
pub fn frame_corners_light(
  attrs: List(Attribute(a)),
) -> Element(a)

frame_corners_regular

</> 
pub fn frame_corners_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

frame_corners_thin

</> 
pub fn frame_corners_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

framer_logo_bold

</> 
pub fn framer_logo_bold(attrs: List(Attribute(a))) -> Element(a)

framer_logo_duotone

</> 
pub fn framer_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

framer_logo_fill

</> 
pub fn framer_logo_fill(attrs: List(Attribute(a))) -> Element(a)

framer_logo_light

</> 
pub fn framer_logo_light(attrs: List(Attribute(a))) -> Element(a)

framer_logo_regular

</> 
pub fn framer_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

framer_logo_thin

</> 
pub fn framer_logo_thin(attrs: List(Attribute(a))) -> Element(a)

function_bold

</> 
pub fn function_bold(attrs: List(Attribute(a))) -> Element(a)

function_duotone

</> 
pub fn function_duotone(attrs: List(Attribute(a))) -> Element(a)

function_fill

</> 
pub fn function_fill(attrs: List(Attribute(a))) -> Element(a)

function_light

</> 
pub fn function_light(attrs: List(Attribute(a))) -> Element(a)

function_regular

</> 
pub fn function_regular(attrs: List(Attribute(a))) -> Element(a)

function_thin

</> 
pub fn function_thin(attrs: List(Attribute(a))) -> Element(a)

funnel_bold

</> 
pub fn funnel_bold(attrs: List(Attribute(a))) -> Element(a)

funnel_duotone

</> 
pub fn funnel_duotone(attrs: List(Attribute(a))) -> Element(a)

funnel_fill

</> 
pub fn funnel_fill(attrs: List(Attribute(a))) -> Element(a)

funnel_light

</> 
pub fn funnel_light(attrs: List(Attribute(a))) -> Element(a)

funnel_regular

</> 
pub fn funnel_regular(attrs: List(Attribute(a))) -> Element(a)

funnel_simple_bold

</> 
pub fn funnel_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_duotone

</> 
pub fn funnel_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_fill

</> 
pub fn funnel_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_light

</> 
pub fn funnel_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_regular

</> 
pub fn funnel_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_thin

</> 
pub fn funnel_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_x_bold

</> 
pub fn funnel_simple_x_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_x_duotone

</> 
pub fn funnel_simple_x_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_x_fill

</> 
pub fn funnel_simple_x_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_x_light

</> 
pub fn funnel_simple_x_light(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_x_regular

</> 
pub fn funnel_simple_x_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_simple_x_thin

</> 
pub fn funnel_simple_x_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

funnel_thin

</> 
pub fn funnel_thin(attrs: List(Attribute(a))) -> Element(a)

funnel_x_bold

</> 
pub fn funnel_x_bold(attrs: List(Attribute(a))) -> Element(a)

funnel_x_duotone

</> 
pub fn funnel_x_duotone(attrs: List(Attribute(a))) -> Element(a)

funnel_x_fill

</> 
pub fn funnel_x_fill(attrs: List(Attribute(a))) -> Element(a)

funnel_x_light

</> 
pub fn funnel_x_light(attrs: List(Attribute(a))) -> Element(a)

funnel_x_regular

</> 
pub fn funnel_x_regular(attrs: List(Attribute(a))) -> Element(a)

funnel_x_thin

</> 
pub fn funnel_x_thin(attrs: List(Attribute(a))) -> Element(a)

game_controller_bold

</> 
pub fn game_controller_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

game_controller_duotone

</> 
pub fn game_controller_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

game_controller_fill

</> 
pub fn game_controller_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

game_controller_light

</> 
pub fn game_controller_light(
  attrs: List(Attribute(a)),
) -> Element(a)

game_controller_regular

</> 
pub fn game_controller_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

game_controller_thin

</> 
pub fn game_controller_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

garage_bold

</> 
pub fn garage_bold(attrs: List(Attribute(a))) -> Element(a)

garage_duotone

</> 
pub fn garage_duotone(attrs: List(Attribute(a))) -> Element(a)

garage_fill

</> 
pub fn garage_fill(attrs: List(Attribute(a))) -> Element(a)

garage_light

</> 
pub fn garage_light(attrs: List(Attribute(a))) -> Element(a)

garage_regular

</> 
pub fn garage_regular(attrs: List(Attribute(a))) -> Element(a)

garage_thin

</> 
pub fn garage_thin(attrs: List(Attribute(a))) -> Element(a)

gas_can_bold

</> 
pub fn gas_can_bold(attrs: List(Attribute(a))) -> Element(a)

gas_can_duotone

</> 
pub fn gas_can_duotone(attrs: List(Attribute(a))) -> Element(a)

gas_can_fill

</> 
pub fn gas_can_fill(attrs: List(Attribute(a))) -> Element(a)

gas_can_light

</> 
pub fn gas_can_light(attrs: List(Attribute(a))) -> Element(a)

gas_can_regular

</> 
pub fn gas_can_regular(attrs: List(Attribute(a))) -> Element(a)

gas_can_thin

</> 
pub fn gas_can_thin(attrs: List(Attribute(a))) -> Element(a)

gas_pump_bold

</> 
pub fn gas_pump_bold(attrs: List(Attribute(a))) -> Element(a)

gas_pump_duotone

</> 
pub fn gas_pump_duotone(attrs: List(Attribute(a))) -> Element(a)

gas_pump_fill

</> 
pub fn gas_pump_fill(attrs: List(Attribute(a))) -> Element(a)

gas_pump_light

</> 
pub fn gas_pump_light(attrs: List(Attribute(a))) -> Element(a)

gas_pump_regular

</> 
pub fn gas_pump_regular(attrs: List(Attribute(a))) -> Element(a)

gas_pump_thin

</> 
pub fn gas_pump_thin(attrs: List(Attribute(a))) -> Element(a)

gauge_bold

</> 
pub fn gauge_bold(attrs: List(Attribute(a))) -> Element(a)

gauge_duotone

</> 
pub fn gauge_duotone(attrs: List(Attribute(a))) -> Element(a)

gauge_fill

</> 
pub fn gauge_fill(attrs: List(Attribute(a))) -> Element(a)

gauge_light

</> 
pub fn gauge_light(attrs: List(Attribute(a))) -> Element(a)

gauge_regular

</> 
pub fn gauge_regular(attrs: List(Attribute(a))) -> Element(a)

gauge_thin

</> 
pub fn gauge_thin(attrs: List(Attribute(a))) -> Element(a)

gavel_bold

</> 
pub fn gavel_bold(attrs: List(Attribute(a))) -> Element(a)

gavel_duotone

</> 
pub fn gavel_duotone(attrs: List(Attribute(a))) -> Element(a)

gavel_fill

</> 
pub fn gavel_fill(attrs: List(Attribute(a))) -> Element(a)

gavel_light

</> 
pub fn gavel_light(attrs: List(Attribute(a))) -> Element(a)

gavel_regular

</> 
pub fn gavel_regular(attrs: List(Attribute(a))) -> Element(a)

gavel_thin

</> 
pub fn gavel_thin(attrs: List(Attribute(a))) -> Element(a)

gear_bold

</> 
pub fn gear_bold(attrs: List(Attribute(a))) -> Element(a)

gear_duotone

</> 
pub fn gear_duotone(attrs: List(Attribute(a))) -> Element(a)

gear_fill

</> 
pub fn gear_fill(attrs: List(Attribute(a))) -> Element(a)

gear_fine_bold

</> 
pub fn gear_fine_bold(attrs: List(Attribute(a))) -> Element(a)

gear_fine_duotone

</> 
pub fn gear_fine_duotone(attrs: List(Attribute(a))) -> Element(a)

gear_fine_fill

</> 
pub fn gear_fine_fill(attrs: List(Attribute(a))) -> Element(a)

gear_fine_light

</> 
pub fn gear_fine_light(attrs: List(Attribute(a))) -> Element(a)

gear_fine_regular

</> 
pub fn gear_fine_regular(attrs: List(Attribute(a))) -> Element(a)

gear_fine_thin

</> 
pub fn gear_fine_thin(attrs: List(Attribute(a))) -> Element(a)

gear_light

</> 
pub fn gear_light(attrs: List(Attribute(a))) -> Element(a)

gear_regular

</> 
pub fn gear_regular(attrs: List(Attribute(a))) -> Element(a)

gear_six_bold

</> 
pub fn gear_six_bold(attrs: List(Attribute(a))) -> Element(a)

gear_six_duotone

</> 
pub fn gear_six_duotone(attrs: List(Attribute(a))) -> Element(a)

gear_six_fill

</> 
pub fn gear_six_fill(attrs: List(Attribute(a))) -> Element(a)

gear_six_light

</> 
pub fn gear_six_light(attrs: List(Attribute(a))) -> Element(a)

gear_six_regular

</> 
pub fn gear_six_regular(attrs: List(Attribute(a))) -> Element(a)

gear_six_thin

</> 
pub fn gear_six_thin(attrs: List(Attribute(a))) -> Element(a)

gear_thin

</> 
pub fn gear_thin(attrs: List(Attribute(a))) -> Element(a)

gender_female_bold

</> 
pub fn gender_female_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_female_duotone

</> 
pub fn gender_female_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_female_fill

</> 
pub fn gender_female_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_female_light

</> 
pub fn gender_female_light(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_female_regular

</> 
pub fn gender_female_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_female_thin

</> 
pub fn gender_female_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_intersex_bold

</> 
pub fn gender_intersex_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_intersex_duotone

</> 
pub fn gender_intersex_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_intersex_fill

</> 
pub fn gender_intersex_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_intersex_light

</> 
pub fn gender_intersex_light(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_intersex_regular

</> 
pub fn gender_intersex_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_intersex_thin

</> 
pub fn gender_intersex_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_male_bold

</> 
pub fn gender_male_bold(attrs: List(Attribute(a))) -> Element(a)

gender_male_duotone

</> 
pub fn gender_male_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_male_fill

</> 
pub fn gender_male_fill(attrs: List(Attribute(a))) -> Element(a)

gender_male_light

</> 
pub fn gender_male_light(attrs: List(Attribute(a))) -> Element(a)

gender_male_regular

</> 
pub fn gender_male_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_male_thin

</> 
pub fn gender_male_thin(attrs: List(Attribute(a))) -> Element(a)

gender_neuter_bold

</> 
pub fn gender_neuter_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_neuter_duotone

</> 
pub fn gender_neuter_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_neuter_fill

</> 
pub fn gender_neuter_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_neuter_light

</> 
pub fn gender_neuter_light(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_neuter_regular

</> 
pub fn gender_neuter_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_neuter_thin

</> 
pub fn gender_neuter_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_nonbinary_bold

</> 
pub fn gender_nonbinary_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_nonbinary_duotone

</> 
pub fn gender_nonbinary_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_nonbinary_fill

</> 
pub fn gender_nonbinary_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_nonbinary_light

</> 
pub fn gender_nonbinary_light(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_nonbinary_regular

</> 
pub fn gender_nonbinary_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_nonbinary_thin

</> 
pub fn gender_nonbinary_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_transgender_bold

</> 
pub fn gender_transgender_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_transgender_duotone

</> 
pub fn gender_transgender_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_transgender_fill

</> 
pub fn gender_transgender_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_transgender_light

</> 
pub fn gender_transgender_light(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_transgender_regular

</> 
pub fn gender_transgender_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

gender_transgender_thin

</> 
pub fn gender_transgender_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

ghost_bold

</> 
pub fn ghost_bold(attrs: List(Attribute(a))) -> Element(a)

ghost_duotone

</> 
pub fn ghost_duotone(attrs: List(Attribute(a))) -> Element(a)

ghost_fill

</> 
pub fn ghost_fill(attrs: List(Attribute(a))) -> Element(a)

ghost_light

</> 
pub fn ghost_light(attrs: List(Attribute(a))) -> Element(a)

ghost_regular

</> 
pub fn ghost_regular(attrs: List(Attribute(a))) -> Element(a)

ghost_thin

</> 
pub fn ghost_thin(attrs: List(Attribute(a))) -> Element(a)

gif_bold

</> 
pub fn gif_bold(attrs: List(Attribute(a))) -> Element(a)

gif_duotone

</> 
pub fn gif_duotone(attrs: List(Attribute(a))) -> Element(a)

gif_fill

</> 
pub fn gif_fill(attrs: List(Attribute(a))) -> Element(a)

gif_light

</> 
pub fn gif_light(attrs: List(Attribute(a))) -> Element(a)

gif_regular

</> 
pub fn gif_regular(attrs: List(Attribute(a))) -> Element(a)

gif_thin

</> 
pub fn gif_thin(attrs: List(Attribute(a))) -> Element(a)

gift_bold

</> 
pub fn gift_bold(attrs: List(Attribute(a))) -> Element(a)

gift_duotone

</> 
pub fn gift_duotone(attrs: List(Attribute(a))) -> Element(a)

gift_fill

</> 
pub fn gift_fill(attrs: List(Attribute(a))) -> Element(a)

gift_light

</> 
pub fn gift_light(attrs: List(Attribute(a))) -> Element(a)

gift_regular

</> 
pub fn gift_regular(attrs: List(Attribute(a))) -> Element(a)

gift_thin

</> 
pub fn gift_thin(attrs: List(Attribute(a))) -> Element(a)

git_branch_bold

</> 
pub fn git_branch_bold(attrs: List(Attribute(a))) -> Element(a)

git_branch_duotone

</> 
pub fn git_branch_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

git_branch_fill

</> 
pub fn git_branch_fill(attrs: List(Attribute(a))) -> Element(a)

git_branch_light

</> 
pub fn git_branch_light(attrs: List(Attribute(a))) -> Element(a)

git_branch_regular

</> 
pub fn git_branch_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

git_branch_thin

</> 
pub fn git_branch_thin(attrs: List(Attribute(a))) -> Element(a)

git_commit_bold

</> 
pub fn git_commit_bold(attrs: List(Attribute(a))) -> Element(a)

git_commit_duotone

</> 
pub fn git_commit_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

git_commit_fill

</> 
pub fn git_commit_fill(attrs: List(Attribute(a))) -> Element(a)

git_commit_light

</> 
pub fn git_commit_light(attrs: List(Attribute(a))) -> Element(a)

git_commit_regular

</> 
pub fn git_commit_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

git_commit_thin

</> 
pub fn git_commit_thin(attrs: List(Attribute(a))) -> Element(a)

git_diff_bold

</> 
pub fn git_diff_bold(attrs: List(Attribute(a))) -> Element(a)

git_diff_duotone

</> 
pub fn git_diff_duotone(attrs: List(Attribute(a))) -> Element(a)

git_diff_fill

</> 
pub fn git_diff_fill(attrs: List(Attribute(a))) -> Element(a)

git_diff_light

</> 
pub fn git_diff_light(attrs: List(Attribute(a))) -> Element(a)

git_diff_regular

</> 
pub fn git_diff_regular(attrs: List(Attribute(a))) -> Element(a)

git_diff_thin

</> 
pub fn git_diff_thin(attrs: List(Attribute(a))) -> Element(a)

git_fork_bold

</> 
pub fn git_fork_bold(attrs: List(Attribute(a))) -> Element(a)

git_fork_duotone

</> 
pub fn git_fork_duotone(attrs: List(Attribute(a))) -> Element(a)

git_fork_fill

</> 
pub fn git_fork_fill(attrs: List(Attribute(a))) -> Element(a)

git_fork_light

</> 
pub fn git_fork_light(attrs: List(Attribute(a))) -> Element(a)

git_fork_regular

</> 
pub fn git_fork_regular(attrs: List(Attribute(a))) -> Element(a)

git_fork_thin

</> 
pub fn git_fork_thin(attrs: List(Attribute(a))) -> Element(a)

git_merge_bold

</> 
pub fn git_merge_bold(attrs: List(Attribute(a))) -> Element(a)

git_merge_duotone

</> 
pub fn git_merge_duotone(attrs: List(Attribute(a))) -> Element(a)

git_merge_fill

</> 
pub fn git_merge_fill(attrs: List(Attribute(a))) -> Element(a)

git_merge_light

</> 
pub fn git_merge_light(attrs: List(Attribute(a))) -> Element(a)

git_merge_regular

</> 
pub fn git_merge_regular(attrs: List(Attribute(a))) -> Element(a)

git_merge_thin

</> 
pub fn git_merge_thin(attrs: List(Attribute(a))) -> Element(a)

git_pull_request_bold

</> 
pub fn git_pull_request_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

git_pull_request_duotone

</> 
pub fn git_pull_request_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

git_pull_request_fill

</> 
pub fn git_pull_request_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

git_pull_request_light

</> 
pub fn git_pull_request_light(
  attrs: List(Attribute(a)),
) -> Element(a)

git_pull_request_regular

</> 
pub fn git_pull_request_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

git_pull_request_thin

</> 
pub fn git_pull_request_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

github_logo_bold

</> 
pub fn github_logo_bold(attrs: List(Attribute(a))) -> Element(a)

github_logo_duotone

</> 
pub fn github_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

github_logo_fill

</> 
pub fn github_logo_fill(attrs: List(Attribute(a))) -> Element(a)

github_logo_light

</> 
pub fn github_logo_light(attrs: List(Attribute(a))) -> Element(a)

github_logo_regular

</> 
pub fn github_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

github_logo_thin

</> 
pub fn github_logo_thin(attrs: List(Attribute(a))) -> Element(a)

gitlab_logo_bold

</> 
pub fn gitlab_logo_bold(attrs: List(Attribute(a))) -> Element(a)

gitlab_logo_duotone

</> 
pub fn gitlab_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

gitlab_logo_fill

</> 
pub fn gitlab_logo_fill(attrs: List(Attribute(a))) -> Element(a)

gitlab_logo_light

</> 
pub fn gitlab_logo_light(attrs: List(Attribute(a))) -> Element(a)

gitlab_logo_regular

</> 
pub fn gitlab_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

gitlab_logo_simple_bold

</> 
pub fn gitlab_logo_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

gitlab_logo_simple_duotone

</> 
pub fn gitlab_logo_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

gitlab_logo_simple_fill

</> 
pub fn gitlab_logo_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

gitlab_logo_simple_light

</> 
pub fn gitlab_logo_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

gitlab_logo_simple_regular

</> 
pub fn gitlab_logo_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

gitlab_logo_simple_thin

</> 
pub fn gitlab_logo_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

gitlab_logo_thin

</> 
pub fn gitlab_logo_thin(attrs: List(Attribute(a))) -> Element(a)

globe_bold

</> 
pub fn globe_bold(attrs: List(Attribute(a))) -> Element(a)

globe_duotone

</> 
pub fn globe_duotone(attrs: List(Attribute(a))) -> Element(a)

globe_fill

</> 
pub fn globe_fill(attrs: List(Attribute(a))) -> Element(a)

globe_hemisphere_east_bold

</> 
pub fn globe_hemisphere_east_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_east_duotone

</> 
pub fn globe_hemisphere_east_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_east_fill

</> 
pub fn globe_hemisphere_east_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_east_light

</> 
pub fn globe_hemisphere_east_light(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_east_regular

</> 
pub fn globe_hemisphere_east_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_east_thin

</> 
pub fn globe_hemisphere_east_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_west_bold

</> 
pub fn globe_hemisphere_west_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_west_duotone

</> 
pub fn globe_hemisphere_west_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_west_fill

</> 
pub fn globe_hemisphere_west_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_west_light

</> 
pub fn globe_hemisphere_west_light(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_west_regular

</> 
pub fn globe_hemisphere_west_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_hemisphere_west_thin

</> 
pub fn globe_hemisphere_west_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_light

</> 
pub fn globe_light(attrs: List(Attribute(a))) -> Element(a)

globe_regular

</> 
pub fn globe_regular(attrs: List(Attribute(a))) -> Element(a)

globe_simple_bold

</> 
pub fn globe_simple_bold(attrs: List(Attribute(a))) -> Element(a)

globe_simple_duotone

</> 
pub fn globe_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_simple_fill

</> 
pub fn globe_simple_fill(attrs: List(Attribute(a))) -> Element(a)

globe_simple_light

</> 
pub fn globe_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_simple_regular

</> 
pub fn globe_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_simple_thin

</> 
pub fn globe_simple_thin(attrs: List(Attribute(a))) -> Element(a)

globe_simple_x_bold

</> 
pub fn globe_simple_x_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_simple_x_duotone

</> 
pub fn globe_simple_x_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_simple_x_fill

</> 
pub fn globe_simple_x_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_simple_x_light

</> 
pub fn globe_simple_x_light(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_simple_x_regular

</> 
pub fn globe_simple_x_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_simple_x_thin

</> 
pub fn globe_simple_x_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_stand_bold

</> 
pub fn globe_stand_bold(attrs: List(Attribute(a))) -> Element(a)

globe_stand_duotone

</> 
pub fn globe_stand_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_stand_fill

</> 
pub fn globe_stand_fill(attrs: List(Attribute(a))) -> Element(a)

globe_stand_light

</> 
pub fn globe_stand_light(attrs: List(Attribute(a))) -> Element(a)

globe_stand_regular

</> 
pub fn globe_stand_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

globe_stand_thin

</> 
pub fn globe_stand_thin(attrs: List(Attribute(a))) -> Element(a)

globe_thin

</> 
pub fn globe_thin(attrs: List(Attribute(a))) -> Element(a)

globe_x_bold

</> 
pub fn globe_x_bold(attrs: List(Attribute(a))) -> Element(a)

globe_x_duotone

</> 
pub fn globe_x_duotone(attrs: List(Attribute(a))) -> Element(a)

globe_x_fill

</> 
pub fn globe_x_fill(attrs: List(Attribute(a))) -> Element(a)

globe_x_light

</> 
pub fn globe_x_light(attrs: List(Attribute(a))) -> Element(a)

globe_x_regular

</> 
pub fn globe_x_regular(attrs: List(Attribute(a))) -> Element(a)

globe_x_thin

</> 
pub fn globe_x_thin(attrs: List(Attribute(a))) -> Element(a)

goggles_bold

</> 
pub fn goggles_bold(attrs: List(Attribute(a))) -> Element(a)

goggles_duotone

</> 
pub fn goggles_duotone(attrs: List(Attribute(a))) -> Element(a)

goggles_fill

</> 
pub fn goggles_fill(attrs: List(Attribute(a))) -> Element(a)

goggles_light

</> 
pub fn goggles_light(attrs: List(Attribute(a))) -> Element(a)

goggles_regular

</> 
pub fn goggles_regular(attrs: List(Attribute(a))) -> Element(a)

goggles_thin

</> 
pub fn goggles_thin(attrs: List(Attribute(a))) -> Element(a)

golf_bold

</> 
pub fn golf_bold(attrs: List(Attribute(a))) -> Element(a)

golf_duotone

</> 
pub fn golf_duotone(attrs: List(Attribute(a))) -> Element(a)

golf_fill

</> 
pub fn golf_fill(attrs: List(Attribute(a))) -> Element(a)

golf_light

</> 
pub fn golf_light(attrs: List(Attribute(a))) -> Element(a)

golf_regular

</> 
pub fn golf_regular(attrs: List(Attribute(a))) -> Element(a)

golf_thin

</> 
pub fn golf_thin(attrs: List(Attribute(a))) -> Element(a)

goodreads_logo_bold

</> 
pub fn goodreads_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

goodreads_logo_duotone

</> 
pub fn goodreads_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

goodreads_logo_fill

</> 
pub fn goodreads_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

goodreads_logo_light

</> 
pub fn goodreads_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

goodreads_logo_regular

</> 
pub fn goodreads_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

goodreads_logo_thin

</> 
pub fn goodreads_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

google_cardboard_logo_bold

</> 
pub fn google_cardboard_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

google_cardboard_logo_duotone

</> 
pub fn google_cardboard_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

google_cardboard_logo_fill

</> 
pub fn google_cardboard_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

google_cardboard_logo_light

</> 
pub fn google_cardboard_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

google_cardboard_logo_regular

</> 
pub fn google_cardboard_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

google_cardboard_logo_thin

</> 
pub fn google_cardboard_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

google_chrome_logo_bold

</> 
pub fn google_chrome_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

google_chrome_logo_duotone

</> 
pub fn google_chrome_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

google_chrome_logo_fill

</> 
pub fn google_chrome_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

google_chrome_logo_light

</> 
pub fn google_chrome_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

google_chrome_logo_regular

</> 
pub fn google_chrome_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

google_chrome_logo_thin

</> 
pub fn google_chrome_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

google_drive_logo_bold

</> 
pub fn google_drive_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

google_drive_logo_duotone

</> 
pub fn google_drive_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

google_drive_logo_fill

</> 
pub fn google_drive_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

google_drive_logo_light

</> 
pub fn google_drive_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

google_drive_logo_regular

</> 
pub fn google_drive_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

google_drive_logo_thin

</> 
pub fn google_drive_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

google_logo_bold

</> 
pub fn google_logo_bold(attrs: List(Attribute(a))) -> Element(a)

google_logo_duotone

</> 
pub fn google_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

google_logo_fill

</> 
pub fn google_logo_fill(attrs: List(Attribute(a))) -> Element(a)

google_logo_light

</> 
pub fn google_logo_light(attrs: List(Attribute(a))) -> Element(a)

google_logo_regular

</> 
pub fn google_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

google_logo_thin

</> 
pub fn google_logo_thin(attrs: List(Attribute(a))) -> Element(a)

google_photos_logo_bold

</> 
pub fn google_photos_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

google_photos_logo_duotone

</> 
pub fn google_photos_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

google_photos_logo_fill

</> 
pub fn google_photos_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

google_photos_logo_light

</> 
pub fn google_photos_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

google_photos_logo_regular

</> 
pub fn google_photos_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

google_photos_logo_thin

</> 
pub fn google_photos_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

google_play_logo_bold

</> 
pub fn google_play_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

google_play_logo_duotone

</> 
pub fn google_play_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

google_play_logo_fill

</> 
pub fn google_play_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

google_play_logo_light

</> 
pub fn google_play_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

google_play_logo_regular

</> 
pub fn google_play_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

google_play_logo_thin

</> 
pub fn google_play_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

google_podcasts_logo_bold

</> 
pub fn google_podcasts_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

google_podcasts_logo_duotone

</> 
pub fn google_podcasts_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

google_podcasts_logo_fill

</> 
pub fn google_podcasts_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

google_podcasts_logo_light

</> 
pub fn google_podcasts_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

google_podcasts_logo_regular

</> 
pub fn google_podcasts_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

google_podcasts_logo_thin

</> 
pub fn google_podcasts_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

gps_bold

</> 
pub fn gps_bold(attrs: List(Attribute(a))) -> Element(a)

gps_duotone

</> 
pub fn gps_duotone(attrs: List(Attribute(a))) -> Element(a)

gps_fill

</> 
pub fn gps_fill(attrs: List(Attribute(a))) -> Element(a)

gps_fix_bold

</> 
pub fn gps_fix_bold(attrs: List(Attribute(a))) -> Element(a)

gps_fix_duotone

</> 
pub fn gps_fix_duotone(attrs: List(Attribute(a))) -> Element(a)

gps_fix_fill

</> 
pub fn gps_fix_fill(attrs: List(Attribute(a))) -> Element(a)

gps_fix_light

</> 
pub fn gps_fix_light(attrs: List(Attribute(a))) -> Element(a)

gps_fix_regular

</> 
pub fn gps_fix_regular(attrs: List(Attribute(a))) -> Element(a)

gps_fix_thin

</> 
pub fn gps_fix_thin(attrs: List(Attribute(a))) -> Element(a)

gps_light

</> 
pub fn gps_light(attrs: List(Attribute(a))) -> Element(a)

gps_regular

</> 
pub fn gps_regular(attrs: List(Attribute(a))) -> Element(a)

gps_slash_bold

</> 
pub fn gps_slash_bold(attrs: List(Attribute(a))) -> Element(a)

gps_slash_duotone

</> 
pub fn gps_slash_duotone(attrs: List(Attribute(a))) -> Element(a)

gps_slash_fill

</> 
pub fn gps_slash_fill(attrs: List(Attribute(a))) -> Element(a)

gps_slash_light

</> 
pub fn gps_slash_light(attrs: List(Attribute(a))) -> Element(a)

gps_slash_regular

</> 
pub fn gps_slash_regular(attrs: List(Attribute(a))) -> Element(a)

gps_slash_thin

</> 
pub fn gps_slash_thin(attrs: List(Attribute(a))) -> Element(a)

gps_thin

</> 
pub fn gps_thin(attrs: List(Attribute(a))) -> Element(a)

gradient_bold

</> 
pub fn gradient_bold(attrs: List(Attribute(a))) -> Element(a)

gradient_duotone

</> 
pub fn gradient_duotone(attrs: List(Attribute(a))) -> Element(a)

gradient_fill

</> 
pub fn gradient_fill(attrs: List(Attribute(a))) -> Element(a)

gradient_light

</> 
pub fn gradient_light(attrs: List(Attribute(a))) -> Element(a)

gradient_regular

</> 
pub fn gradient_regular(attrs: List(Attribute(a))) -> Element(a)

gradient_thin

</> 
pub fn gradient_thin(attrs: List(Attribute(a))) -> Element(a)

graduation_cap_bold

</> 
pub fn graduation_cap_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

graduation_cap_duotone

</> 
pub fn graduation_cap_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

graduation_cap_fill

</> 
pub fn graduation_cap_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

graduation_cap_light

</> 
pub fn graduation_cap_light(
  attrs: List(Attribute(a)),
) -> Element(a)

graduation_cap_regular

</> 
pub fn graduation_cap_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

graduation_cap_thin

</> 
pub fn graduation_cap_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

grains_bold

</> 
pub fn grains_bold(attrs: List(Attribute(a))) -> Element(a)

grains_duotone

</> 
pub fn grains_duotone(attrs: List(Attribute(a))) -> Element(a)

grains_fill

</> 
pub fn grains_fill(attrs: List(Attribute(a))) -> Element(a)

grains_light

</> 
pub fn grains_light(attrs: List(Attribute(a))) -> Element(a)

grains_regular

</> 
pub fn grains_regular(attrs: List(Attribute(a))) -> Element(a)

grains_slash_bold

</> 
pub fn grains_slash_bold(attrs: List(Attribute(a))) -> Element(a)

grains_slash_duotone

</> 
pub fn grains_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

grains_slash_fill

</> 
pub fn grains_slash_fill(attrs: List(Attribute(a))) -> Element(a)

grains_slash_light

</> 
pub fn grains_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

grains_slash_regular

</> 
pub fn grains_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

grains_slash_thin

</> 
pub fn grains_slash_thin(attrs: List(Attribute(a))) -> Element(a)

grains_thin

</> 
pub fn grains_thin(attrs: List(Attribute(a))) -> Element(a)

graph_bold

</> 
pub fn graph_bold(attrs: List(Attribute(a))) -> Element(a)

graph_duotone

</> 
pub fn graph_duotone(attrs: List(Attribute(a))) -> Element(a)

graph_fill

</> 
pub fn graph_fill(attrs: List(Attribute(a))) -> Element(a)

graph_light

</> 
pub fn graph_light(attrs: List(Attribute(a))) -> Element(a)

graph_regular

</> 
pub fn graph_regular(attrs: List(Attribute(a))) -> Element(a)

graph_thin

</> 
pub fn graph_thin(attrs: List(Attribute(a))) -> Element(a)

graphics_card_bold

</> 
pub fn graphics_card_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

graphics_card_duotone

</> 
pub fn graphics_card_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

graphics_card_fill

</> 
pub fn graphics_card_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

graphics_card_light

</> 
pub fn graphics_card_light(
  attrs: List(Attribute(a)),
) -> Element(a)

graphics_card_regular

</> 
pub fn graphics_card_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

graphics_card_thin

</> 
pub fn graphics_card_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

greater_than_bold

</> 
pub fn greater_than_bold(attrs: List(Attribute(a))) -> Element(a)

greater_than_duotone

</> 
pub fn greater_than_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

greater_than_fill

</> 
pub fn greater_than_fill(attrs: List(Attribute(a))) -> Element(a)

greater_than_light

</> 
pub fn greater_than_light(
  attrs: List(Attribute(a)),
) -> Element(a)

greater_than_or_equal_bold

</> 
pub fn greater_than_or_equal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

greater_than_or_equal_duotone

</> 
pub fn greater_than_or_equal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

greater_than_or_equal_fill

</> 
pub fn greater_than_or_equal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

greater_than_or_equal_light

</> 
pub fn greater_than_or_equal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

greater_than_or_equal_regular

</> 
pub fn greater_than_or_equal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

greater_than_or_equal_thin

</> 
pub fn greater_than_or_equal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

greater_than_regular

</> 
pub fn greater_than_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

greater_than_thin

</> 
pub fn greater_than_thin(attrs: List(Attribute(a))) -> Element(a)

grid_four_bold

</> 
pub fn grid_four_bold(attrs: List(Attribute(a))) -> Element(a)

grid_four_duotone

</> 
pub fn grid_four_duotone(attrs: List(Attribute(a))) -> Element(a)

grid_four_fill

</> 
pub fn grid_four_fill(attrs: List(Attribute(a))) -> Element(a)

grid_four_light

</> 
pub fn grid_four_light(attrs: List(Attribute(a))) -> Element(a)

grid_four_regular

</> 
pub fn grid_four_regular(attrs: List(Attribute(a))) -> Element(a)

grid_four_thin

</> 
pub fn grid_four_thin(attrs: List(Attribute(a))) -> Element(a)

grid_nine_bold

</> 
pub fn grid_nine_bold(attrs: List(Attribute(a))) -> Element(a)

grid_nine_duotone

</> 
pub fn grid_nine_duotone(attrs: List(Attribute(a))) -> Element(a)

grid_nine_fill

</> 
pub fn grid_nine_fill(attrs: List(Attribute(a))) -> Element(a)

grid_nine_light

</> 
pub fn grid_nine_light(attrs: List(Attribute(a))) -> Element(a)

grid_nine_regular

</> 
pub fn grid_nine_regular(attrs: List(Attribute(a))) -> Element(a)

grid_nine_thin

</> 
pub fn grid_nine_thin(attrs: List(Attribute(a))) -> Element(a)

guitar_bold

</> 
pub fn guitar_bold(attrs: List(Attribute(a))) -> Element(a)

guitar_duotone

</> 
pub fn guitar_duotone(attrs: List(Attribute(a))) -> Element(a)

guitar_fill

</> 
pub fn guitar_fill(attrs: List(Attribute(a))) -> Element(a)

guitar_light

</> 
pub fn guitar_light(attrs: List(Attribute(a))) -> Element(a)

guitar_regular

</> 
pub fn guitar_regular(attrs: List(Attribute(a))) -> Element(a)

guitar_thin

</> 
pub fn guitar_thin(attrs: List(Attribute(a))) -> Element(a)

hair_dryer_bold

</> 
pub fn hair_dryer_bold(attrs: List(Attribute(a))) -> Element(a)

hair_dryer_duotone

</> 
pub fn hair_dryer_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hair_dryer_fill

</> 
pub fn hair_dryer_fill(attrs: List(Attribute(a))) -> Element(a)

hair_dryer_light

</> 
pub fn hair_dryer_light(attrs: List(Attribute(a))) -> Element(a)

hair_dryer_regular

</> 
pub fn hair_dryer_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hair_dryer_thin

</> 
pub fn hair_dryer_thin(attrs: List(Attribute(a))) -> Element(a)

hamburger_bold

</> 
pub fn hamburger_bold(attrs: List(Attribute(a))) -> Element(a)

hamburger_duotone

</> 
pub fn hamburger_duotone(attrs: List(Attribute(a))) -> Element(a)

hamburger_fill

</> 
pub fn hamburger_fill(attrs: List(Attribute(a))) -> Element(a)

hamburger_light

</> 
pub fn hamburger_light(attrs: List(Attribute(a))) -> Element(a)

hamburger_regular

</> 
pub fn hamburger_regular(attrs: List(Attribute(a))) -> Element(a)

hamburger_thin

</> 
pub fn hamburger_thin(attrs: List(Attribute(a))) -> Element(a)

hammer_bold

</> 
pub fn hammer_bold(attrs: List(Attribute(a))) -> Element(a)

hammer_duotone

</> 
pub fn hammer_duotone(attrs: List(Attribute(a))) -> Element(a)

hammer_fill

</> 
pub fn hammer_fill(attrs: List(Attribute(a))) -> Element(a)

hammer_light

</> 
pub fn hammer_light(attrs: List(Attribute(a))) -> Element(a)

hammer_regular

</> 
pub fn hammer_regular(attrs: List(Attribute(a))) -> Element(a)

hammer_thin

</> 
pub fn hammer_thin(attrs: List(Attribute(a))) -> Element(a)

hand_arrow_down_bold

</> 
pub fn hand_arrow_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_down_duotone

</> 
pub fn hand_arrow_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_down_fill

</> 
pub fn hand_arrow_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_down_light

</> 
pub fn hand_arrow_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_down_regular

</> 
pub fn hand_arrow_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_down_thin

</> 
pub fn hand_arrow_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_up_bold

</> 
pub fn hand_arrow_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_up_duotone

</> 
pub fn hand_arrow_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_up_fill

</> 
pub fn hand_arrow_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_up_light

</> 
pub fn hand_arrow_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_up_regular

</> 
pub fn hand_arrow_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_arrow_up_thin

</> 
pub fn hand_arrow_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_bold

</> 
pub fn hand_bold(attrs: List(Attribute(a))) -> Element(a)

hand_coins_bold

</> 
pub fn hand_coins_bold(attrs: List(Attribute(a))) -> Element(a)

hand_coins_duotone

</> 
pub fn hand_coins_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_coins_fill

</> 
pub fn hand_coins_fill(attrs: List(Attribute(a))) -> Element(a)

hand_coins_light

</> 
pub fn hand_coins_light(attrs: List(Attribute(a))) -> Element(a)

hand_coins_regular

</> 
pub fn hand_coins_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_coins_thin

</> 
pub fn hand_coins_thin(attrs: List(Attribute(a))) -> Element(a)

hand_deposit_bold

</> 
pub fn hand_deposit_bold(attrs: List(Attribute(a))) -> Element(a)

hand_deposit_duotone

</> 
pub fn hand_deposit_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_deposit_fill

</> 
pub fn hand_deposit_fill(attrs: List(Attribute(a))) -> Element(a)

hand_deposit_light

</> 
pub fn hand_deposit_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_deposit_regular

</> 
pub fn hand_deposit_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_deposit_thin

</> 
pub fn hand_deposit_thin(attrs: List(Attribute(a))) -> Element(a)

hand_duotone

</> 
pub fn hand_duotone(attrs: List(Attribute(a))) -> Element(a)

hand_eye_bold

</> 
pub fn hand_eye_bold(attrs: List(Attribute(a))) -> Element(a)

hand_eye_duotone

</> 
pub fn hand_eye_duotone(attrs: List(Attribute(a))) -> Element(a)

hand_eye_fill

</> 
pub fn hand_eye_fill(attrs: List(Attribute(a))) -> Element(a)

hand_eye_light

</> 
pub fn hand_eye_light(attrs: List(Attribute(a))) -> Element(a)

hand_eye_regular

</> 
pub fn hand_eye_regular(attrs: List(Attribute(a))) -> Element(a)

hand_eye_thin

</> 
pub fn hand_eye_thin(attrs: List(Attribute(a))) -> Element(a)

hand_fill

</> 
pub fn hand_fill(attrs: List(Attribute(a))) -> Element(a)

hand_fist_bold

</> 
pub fn hand_fist_bold(attrs: List(Attribute(a))) -> Element(a)

hand_fist_duotone

</> 
pub fn hand_fist_duotone(attrs: List(Attribute(a))) -> Element(a)

hand_fist_fill

</> 
pub fn hand_fist_fill(attrs: List(Attribute(a))) -> Element(a)

hand_fist_light

</> 
pub fn hand_fist_light(attrs: List(Attribute(a))) -> Element(a)

hand_fist_regular

</> 
pub fn hand_fist_regular(attrs: List(Attribute(a))) -> Element(a)

hand_fist_thin

</> 
pub fn hand_fist_thin(attrs: List(Attribute(a))) -> Element(a)

hand_grabbing_bold

</> 
pub fn hand_grabbing_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_grabbing_duotone

</> 
pub fn hand_grabbing_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_grabbing_fill

</> 
pub fn hand_grabbing_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_grabbing_light

</> 
pub fn hand_grabbing_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_grabbing_regular

</> 
pub fn hand_grabbing_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_grabbing_thin

</> 
pub fn hand_grabbing_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_heart_bold

</> 
pub fn hand_heart_bold(attrs: List(Attribute(a))) -> Element(a)

hand_heart_duotone

</> 
pub fn hand_heart_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_heart_fill

</> 
pub fn hand_heart_fill(attrs: List(Attribute(a))) -> Element(a)

hand_heart_light

</> 
pub fn hand_heart_light(attrs: List(Attribute(a))) -> Element(a)

hand_heart_regular

</> 
pub fn hand_heart_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_heart_thin

</> 
pub fn hand_heart_thin(attrs: List(Attribute(a))) -> Element(a)

hand_light

</> 
pub fn hand_light(attrs: List(Attribute(a))) -> Element(a)

hand_palm_bold

</> 
pub fn hand_palm_bold(attrs: List(Attribute(a))) -> Element(a)

hand_palm_duotone

</> 
pub fn hand_palm_duotone(attrs: List(Attribute(a))) -> Element(a)

hand_palm_fill

</> 
pub fn hand_palm_fill(attrs: List(Attribute(a))) -> Element(a)

hand_palm_light

</> 
pub fn hand_palm_light(attrs: List(Attribute(a))) -> Element(a)

hand_palm_regular

</> 
pub fn hand_palm_regular(attrs: List(Attribute(a))) -> Element(a)

hand_palm_thin

</> 
pub fn hand_palm_thin(attrs: List(Attribute(a))) -> Element(a)

hand_peace_bold

</> 
pub fn hand_peace_bold(attrs: List(Attribute(a))) -> Element(a)

hand_peace_duotone

</> 
pub fn hand_peace_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_peace_fill

</> 
pub fn hand_peace_fill(attrs: List(Attribute(a))) -> Element(a)

hand_peace_light

</> 
pub fn hand_peace_light(attrs: List(Attribute(a))) -> Element(a)

hand_peace_regular

</> 
pub fn hand_peace_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_peace_thin

</> 
pub fn hand_peace_thin(attrs: List(Attribute(a))) -> Element(a)

hand_pointing_bold

</> 
pub fn hand_pointing_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_pointing_duotone

</> 
pub fn hand_pointing_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_pointing_fill

</> 
pub fn hand_pointing_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_pointing_light

</> 
pub fn hand_pointing_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_pointing_regular

</> 
pub fn hand_pointing_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_pointing_thin

</> 
pub fn hand_pointing_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_regular

</> 
pub fn hand_regular(attrs: List(Attribute(a))) -> Element(a)

hand_soap_bold

</> 
pub fn hand_soap_bold(attrs: List(Attribute(a))) -> Element(a)

hand_soap_duotone

</> 
pub fn hand_soap_duotone(attrs: List(Attribute(a))) -> Element(a)

hand_soap_fill

</> 
pub fn hand_soap_fill(attrs: List(Attribute(a))) -> Element(a)

hand_soap_light

</> 
pub fn hand_soap_light(attrs: List(Attribute(a))) -> Element(a)

hand_soap_regular

</> 
pub fn hand_soap_regular(attrs: List(Attribute(a))) -> Element(a)

hand_soap_thin

</> 
pub fn hand_soap_thin(attrs: List(Attribute(a))) -> Element(a)

hand_swipe_left_bold

</> 
pub fn hand_swipe_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_left_duotone

</> 
pub fn hand_swipe_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_left_fill

</> 
pub fn hand_swipe_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_left_light

</> 
pub fn hand_swipe_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_left_regular

</> 
pub fn hand_swipe_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_left_thin

</> 
pub fn hand_swipe_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_right_bold

</> 
pub fn hand_swipe_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_right_duotone

</> 
pub fn hand_swipe_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_right_fill

</> 
pub fn hand_swipe_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_right_light

</> 
pub fn hand_swipe_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_right_regular

</> 
pub fn hand_swipe_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_swipe_right_thin

</> 
pub fn hand_swipe_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_tap_bold

</> 
pub fn hand_tap_bold(attrs: List(Attribute(a))) -> Element(a)

hand_tap_duotone

</> 
pub fn hand_tap_duotone(attrs: List(Attribute(a))) -> Element(a)

hand_tap_fill

</> 
pub fn hand_tap_fill(attrs: List(Attribute(a))) -> Element(a)

hand_tap_light

</> 
pub fn hand_tap_light(attrs: List(Attribute(a))) -> Element(a)

hand_tap_regular

</> 
pub fn hand_tap_regular(attrs: List(Attribute(a))) -> Element(a)

hand_tap_thin

</> 
pub fn hand_tap_thin(attrs: List(Attribute(a))) -> Element(a)

hand_thin

</> 
pub fn hand_thin(attrs: List(Attribute(a))) -> Element(a)

hand_waving_bold

</> 
pub fn hand_waving_bold(attrs: List(Attribute(a))) -> Element(a)

hand_waving_duotone

</> 
pub fn hand_waving_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_waving_fill

</> 
pub fn hand_waving_fill(attrs: List(Attribute(a))) -> Element(a)

hand_waving_light

</> 
pub fn hand_waving_light(attrs: List(Attribute(a))) -> Element(a)

hand_waving_regular

</> 
pub fn hand_waving_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_waving_thin

</> 
pub fn hand_waving_thin(attrs: List(Attribute(a))) -> Element(a)

hand_withdraw_bold

</> 
pub fn hand_withdraw_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_withdraw_duotone

</> 
pub fn hand_withdraw_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_withdraw_fill

</> 
pub fn hand_withdraw_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_withdraw_light

</> 
pub fn hand_withdraw_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_withdraw_regular

</> 
pub fn hand_withdraw_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hand_withdraw_thin

</> 
pub fn hand_withdraw_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

handbag_bold

</> 
pub fn handbag_bold(attrs: List(Attribute(a))) -> Element(a)

handbag_duotone

</> 
pub fn handbag_duotone(attrs: List(Attribute(a))) -> Element(a)

handbag_fill

</> 
pub fn handbag_fill(attrs: List(Attribute(a))) -> Element(a)

handbag_light

</> 
pub fn handbag_light(attrs: List(Attribute(a))) -> Element(a)

handbag_regular

</> 
pub fn handbag_regular(attrs: List(Attribute(a))) -> Element(a)

handbag_simple_bold

</> 
pub fn handbag_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

handbag_simple_duotone

</> 
pub fn handbag_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

handbag_simple_fill

</> 
pub fn handbag_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

handbag_simple_light

</> 
pub fn handbag_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

handbag_simple_regular

</> 
pub fn handbag_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

handbag_simple_thin

</> 
pub fn handbag_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

handbag_thin

</> 
pub fn handbag_thin(attrs: List(Attribute(a))) -> Element(a)

hands_clapping_bold

</> 
pub fn hands_clapping_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_clapping_duotone

</> 
pub fn hands_clapping_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_clapping_fill

</> 
pub fn hands_clapping_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_clapping_light

</> 
pub fn hands_clapping_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_clapping_regular

</> 
pub fn hands_clapping_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_clapping_thin

</> 
pub fn hands_clapping_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_praying_bold

</> 
pub fn hands_praying_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_praying_duotone

</> 
pub fn hands_praying_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_praying_fill

</> 
pub fn hands_praying_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_praying_light

</> 
pub fn hands_praying_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_praying_regular

</> 
pub fn hands_praying_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hands_praying_thin

</> 
pub fn hands_praying_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

handshake_bold

</> 
pub fn handshake_bold(attrs: List(Attribute(a))) -> Element(a)

handshake_duotone

</> 
pub fn handshake_duotone(attrs: List(Attribute(a))) -> Element(a)

handshake_fill

</> 
pub fn handshake_fill(attrs: List(Attribute(a))) -> Element(a)

handshake_light

</> 
pub fn handshake_light(attrs: List(Attribute(a))) -> Element(a)

handshake_regular

</> 
pub fn handshake_regular(attrs: List(Attribute(a))) -> Element(a)

handshake_thin

</> 
pub fn handshake_thin(attrs: List(Attribute(a))) -> Element(a)

hard_drive_bold

</> 
pub fn hard_drive_bold(attrs: List(Attribute(a))) -> Element(a)

hard_drive_duotone

</> 
pub fn hard_drive_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hard_drive_fill

</> 
pub fn hard_drive_fill(attrs: List(Attribute(a))) -> Element(a)

hard_drive_light

</> 
pub fn hard_drive_light(attrs: List(Attribute(a))) -> Element(a)

hard_drive_regular

</> 
pub fn hard_drive_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hard_drive_thin

</> 
pub fn hard_drive_thin(attrs: List(Attribute(a))) -> Element(a)

hard_drives_bold

</> 
pub fn hard_drives_bold(attrs: List(Attribute(a))) -> Element(a)

hard_drives_duotone

</> 
pub fn hard_drives_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hard_drives_fill

</> 
pub fn hard_drives_fill(attrs: List(Attribute(a))) -> Element(a)

hard_drives_light

</> 
pub fn hard_drives_light(attrs: List(Attribute(a))) -> Element(a)

hard_drives_regular

</> 
pub fn hard_drives_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hard_drives_thin

</> 
pub fn hard_drives_thin(attrs: List(Attribute(a))) -> Element(a)

hard_hat_bold

</> 
pub fn hard_hat_bold(attrs: List(Attribute(a))) -> Element(a)

hard_hat_duotone

</> 
pub fn hard_hat_duotone(attrs: List(Attribute(a))) -> Element(a)

hard_hat_fill

</> 
pub fn hard_hat_fill(attrs: List(Attribute(a))) -> Element(a)

hard_hat_light

</> 
pub fn hard_hat_light(attrs: List(Attribute(a))) -> Element(a)

hard_hat_regular

</> 
pub fn hard_hat_regular(attrs: List(Attribute(a))) -> Element(a)

hard_hat_thin

</> 
pub fn hard_hat_thin(attrs: List(Attribute(a))) -> Element(a)

hash_bold

</> 
pub fn hash_bold(attrs: List(Attribute(a))) -> Element(a)

hash_duotone

</> 
pub fn hash_duotone(attrs: List(Attribute(a))) -> Element(a)

hash_fill

</> 
pub fn hash_fill(attrs: List(Attribute(a))) -> Element(a)

hash_light

</> 
pub fn hash_light(attrs: List(Attribute(a))) -> Element(a)

hash_regular

</> 
pub fn hash_regular(attrs: List(Attribute(a))) -> Element(a)

hash_straight_bold

</> 
pub fn hash_straight_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hash_straight_duotone

</> 
pub fn hash_straight_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hash_straight_fill

</> 
pub fn hash_straight_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hash_straight_light

</> 
pub fn hash_straight_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hash_straight_regular

</> 
pub fn hash_straight_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hash_straight_thin

</> 
pub fn hash_straight_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hash_thin

</> 
pub fn hash_thin(attrs: List(Attribute(a))) -> Element(a)

head_circuit_bold

</> 
pub fn head_circuit_bold(attrs: List(Attribute(a))) -> Element(a)

head_circuit_duotone

</> 
pub fn head_circuit_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

head_circuit_fill

</> 
pub fn head_circuit_fill(attrs: List(Attribute(a))) -> Element(a)

head_circuit_light

</> 
pub fn head_circuit_light(
  attrs: List(Attribute(a)),
) -> Element(a)

head_circuit_regular

</> 
pub fn head_circuit_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

head_circuit_thin

</> 
pub fn head_circuit_thin(attrs: List(Attribute(a))) -> Element(a)

headlights_bold

</> 
pub fn headlights_bold(attrs: List(Attribute(a))) -> Element(a)

headlights_duotone

</> 
pub fn headlights_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

headlights_fill

</> 
pub fn headlights_fill(attrs: List(Attribute(a))) -> Element(a)

headlights_light

</> 
pub fn headlights_light(attrs: List(Attribute(a))) -> Element(a)

headlights_regular

</> 
pub fn headlights_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

headlights_thin

</> 
pub fn headlights_thin(attrs: List(Attribute(a))) -> Element(a)

headphones_bold

</> 
pub fn headphones_bold(attrs: List(Attribute(a))) -> Element(a)

headphones_duotone

</> 
pub fn headphones_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

headphones_fill

</> 
pub fn headphones_fill(attrs: List(Attribute(a))) -> Element(a)

headphones_light

</> 
pub fn headphones_light(attrs: List(Attribute(a))) -> Element(a)

headphones_regular

</> 
pub fn headphones_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

headphones_thin

</> 
pub fn headphones_thin(attrs: List(Attribute(a))) -> Element(a)

headset_bold

</> 
pub fn headset_bold(attrs: List(Attribute(a))) -> Element(a)

headset_duotone

</> 
pub fn headset_duotone(attrs: List(Attribute(a))) -> Element(a)

headset_fill

</> 
pub fn headset_fill(attrs: List(Attribute(a))) -> Element(a)

headset_light

</> 
pub fn headset_light(attrs: List(Attribute(a))) -> Element(a)

headset_regular

</> 
pub fn headset_regular(attrs: List(Attribute(a))) -> Element(a)

headset_thin

</> 
pub fn headset_thin(attrs: List(Attribute(a))) -> Element(a)

heart_bold

</> 
pub fn heart_bold(attrs: List(Attribute(a))) -> Element(a)

heart_break_bold

</> 
pub fn heart_break_bold(attrs: List(Attribute(a))) -> Element(a)

heart_break_duotone

</> 
pub fn heart_break_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_break_fill

</> 
pub fn heart_break_fill(attrs: List(Attribute(a))) -> Element(a)

heart_break_light

</> 
pub fn heart_break_light(attrs: List(Attribute(a))) -> Element(a)

heart_break_regular

</> 
pub fn heart_break_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_break_thin

</> 
pub fn heart_break_thin(attrs: List(Attribute(a))) -> Element(a)

heart_duotone

</> 
pub fn heart_duotone(attrs: List(Attribute(a))) -> Element(a)

heart_fill

</> 
pub fn heart_fill(attrs: List(Attribute(a))) -> Element(a)

heart_half_bold

</> 
pub fn heart_half_bold(attrs: List(Attribute(a))) -> Element(a)

heart_half_duotone

</> 
pub fn heart_half_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_half_fill

</> 
pub fn heart_half_fill(attrs: List(Attribute(a))) -> Element(a)

heart_half_light

</> 
pub fn heart_half_light(attrs: List(Attribute(a))) -> Element(a)

heart_half_regular

</> 
pub fn heart_half_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_half_thin

</> 
pub fn heart_half_thin(attrs: List(Attribute(a))) -> Element(a)

heart_light

</> 
pub fn heart_light(attrs: List(Attribute(a))) -> Element(a)

heart_regular

</> 
pub fn heart_regular(attrs: List(Attribute(a))) -> Element(a)

heart_straight_bold

</> 
pub fn heart_straight_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_break_bold

</> 
pub fn heart_straight_break_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_break_duotone

</> 
pub fn heart_straight_break_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_break_fill

</> 
pub fn heart_straight_break_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_break_light

</> 
pub fn heart_straight_break_light(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_break_regular

</> 
pub fn heart_straight_break_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_break_thin

</> 
pub fn heart_straight_break_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_duotone

</> 
pub fn heart_straight_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_fill

</> 
pub fn heart_straight_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_light

</> 
pub fn heart_straight_light(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_regular

</> 
pub fn heart_straight_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_straight_thin

</> 
pub fn heart_straight_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

heart_thin

</> 
pub fn heart_thin(attrs: List(Attribute(a))) -> Element(a)

heartbeat_bold

</> 
pub fn heartbeat_bold(attrs: List(Attribute(a))) -> Element(a)

heartbeat_duotone

</> 
pub fn heartbeat_duotone(attrs: List(Attribute(a))) -> Element(a)

heartbeat_fill

</> 
pub fn heartbeat_fill(attrs: List(Attribute(a))) -> Element(a)

heartbeat_light

</> 
pub fn heartbeat_light(attrs: List(Attribute(a))) -> Element(a)

heartbeat_regular

</> 
pub fn heartbeat_regular(attrs: List(Attribute(a))) -> Element(a)

heartbeat_thin

</> 
pub fn heartbeat_thin(attrs: List(Attribute(a))) -> Element(a)

hexagon_bold

</> 
pub fn hexagon_bold(attrs: List(Attribute(a))) -> Element(a)

hexagon_duotone

</> 
pub fn hexagon_duotone(attrs: List(Attribute(a))) -> Element(a)

hexagon_fill

</> 
pub fn hexagon_fill(attrs: List(Attribute(a))) -> Element(a)

hexagon_light

</> 
pub fn hexagon_light(attrs: List(Attribute(a))) -> Element(a)

hexagon_regular

</> 
pub fn hexagon_regular(attrs: List(Attribute(a))) -> Element(a)

hexagon_thin

</> 
pub fn hexagon_thin(attrs: List(Attribute(a))) -> Element(a)

high_definition_bold

</> 
pub fn high_definition_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

high_definition_duotone

</> 
pub fn high_definition_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

high_definition_fill

</> 
pub fn high_definition_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

high_definition_light

</> 
pub fn high_definition_light(
  attrs: List(Attribute(a)),
) -> Element(a)

high_definition_regular

</> 
pub fn high_definition_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

high_definition_thin

</> 
pub fn high_definition_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

high_heel_bold

</> 
pub fn high_heel_bold(attrs: List(Attribute(a))) -> Element(a)

high_heel_duotone

</> 
pub fn high_heel_duotone(attrs: List(Attribute(a))) -> Element(a)

high_heel_fill

</> 
pub fn high_heel_fill(attrs: List(Attribute(a))) -> Element(a)

high_heel_light

</> 
pub fn high_heel_light(attrs: List(Attribute(a))) -> Element(a)

high_heel_regular

</> 
pub fn high_heel_regular(attrs: List(Attribute(a))) -> Element(a)

high_heel_thin

</> 
pub fn high_heel_thin(attrs: List(Attribute(a))) -> Element(a)

highlighter_bold

</> 
pub fn highlighter_bold(attrs: List(Attribute(a))) -> Element(a)

highlighter_circle_bold

</> 
pub fn highlighter_circle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

highlighter_circle_duotone

</> 
pub fn highlighter_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

highlighter_circle_fill

</> 
pub fn highlighter_circle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

highlighter_circle_light

</> 
pub fn highlighter_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

highlighter_circle_regular

</> 
pub fn highlighter_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

highlighter_circle_thin

</> 
pub fn highlighter_circle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

highlighter_duotone

</> 
pub fn highlighter_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

highlighter_fill

</> 
pub fn highlighter_fill(attrs: List(Attribute(a))) -> Element(a)

highlighter_light

</> 
pub fn highlighter_light(attrs: List(Attribute(a))) -> Element(a)

highlighter_regular

</> 
pub fn highlighter_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

highlighter_thin

</> 
pub fn highlighter_thin(attrs: List(Attribute(a))) -> Element(a)

hockey_bold

</> 
pub fn hockey_bold(attrs: List(Attribute(a))) -> Element(a)

hockey_duotone

</> 
pub fn hockey_duotone(attrs: List(Attribute(a))) -> Element(a)

hockey_fill

</> 
pub fn hockey_fill(attrs: List(Attribute(a))) -> Element(a)

hockey_light

</> 
pub fn hockey_light(attrs: List(Attribute(a))) -> Element(a)

hockey_regular

</> 
pub fn hockey_regular(attrs: List(Attribute(a))) -> Element(a)

hockey_thin

</> 
pub fn hockey_thin(attrs: List(Attribute(a))) -> Element(a)

hoodie_bold

</> 
pub fn hoodie_bold(attrs: List(Attribute(a))) -> Element(a)

hoodie_duotone

</> 
pub fn hoodie_duotone(attrs: List(Attribute(a))) -> Element(a)

hoodie_fill

</> 
pub fn hoodie_fill(attrs: List(Attribute(a))) -> Element(a)

hoodie_light

</> 
pub fn hoodie_light(attrs: List(Attribute(a))) -> Element(a)

hoodie_regular

</> 
pub fn hoodie_regular(attrs: List(Attribute(a))) -> Element(a)

hoodie_thin

</> 
pub fn hoodie_thin(attrs: List(Attribute(a))) -> Element(a)

horse_bold

</> 
pub fn horse_bold(attrs: List(Attribute(a))) -> Element(a)

horse_duotone

</> 
pub fn horse_duotone(attrs: List(Attribute(a))) -> Element(a)

horse_fill

</> 
pub fn horse_fill(attrs: List(Attribute(a))) -> Element(a)

horse_light

</> 
pub fn horse_light(attrs: List(Attribute(a))) -> Element(a)

horse_regular

</> 
pub fn horse_regular(attrs: List(Attribute(a))) -> Element(a)

horse_thin

</> 
pub fn horse_thin(attrs: List(Attribute(a))) -> Element(a)

hospital_bold

</> 
pub fn hospital_bold(attrs: List(Attribute(a))) -> Element(a)

hospital_duotone

</> 
pub fn hospital_duotone(attrs: List(Attribute(a))) -> Element(a)

hospital_fill

</> 
pub fn hospital_fill(attrs: List(Attribute(a))) -> Element(a)

hospital_light

</> 
pub fn hospital_light(attrs: List(Attribute(a))) -> Element(a)

hospital_regular

</> 
pub fn hospital_regular(attrs: List(Attribute(a))) -> Element(a)

hospital_thin

</> 
pub fn hospital_thin(attrs: List(Attribute(a))) -> Element(a)

hourglass_bold

</> 
pub fn hourglass_bold(attrs: List(Attribute(a))) -> Element(a)

hourglass_duotone

</> 
pub fn hourglass_duotone(attrs: List(Attribute(a))) -> Element(a)

hourglass_fill

</> 
pub fn hourglass_fill(attrs: List(Attribute(a))) -> Element(a)

hourglass_high_bold

</> 
pub fn hourglass_high_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_high_duotone

</> 
pub fn hourglass_high_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_high_fill

</> 
pub fn hourglass_high_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_high_light

</> 
pub fn hourglass_high_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_high_regular

</> 
pub fn hourglass_high_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_high_thin

</> 
pub fn hourglass_high_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_light

</> 
pub fn hourglass_light(attrs: List(Attribute(a))) -> Element(a)

hourglass_low_bold

</> 
pub fn hourglass_low_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_low_duotone

</> 
pub fn hourglass_low_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_low_fill

</> 
pub fn hourglass_low_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_low_light

</> 
pub fn hourglass_low_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_low_regular

</> 
pub fn hourglass_low_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_low_thin

</> 
pub fn hourglass_low_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_medium_bold

</> 
pub fn hourglass_medium_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_medium_duotone

</> 
pub fn hourglass_medium_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_medium_fill

</> 
pub fn hourglass_medium_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_medium_light

</> 
pub fn hourglass_medium_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_medium_regular

</> 
pub fn hourglass_medium_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_medium_thin

</> 
pub fn hourglass_medium_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_regular

</> 
pub fn hourglass_regular(attrs: List(Attribute(a))) -> Element(a)

hourglass_simple_bold

</> 
pub fn hourglass_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_duotone

</> 
pub fn hourglass_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_fill

</> 
pub fn hourglass_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_high_bold

</> 
pub fn hourglass_simple_high_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_high_duotone

</> 
pub fn hourglass_simple_high_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_high_fill

</> 
pub fn hourglass_simple_high_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_high_light

</> 
pub fn hourglass_simple_high_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_high_regular

</> 
pub fn hourglass_simple_high_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_high_thin

</> 
pub fn hourglass_simple_high_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_light

</> 
pub fn hourglass_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_low_bold

</> 
pub fn hourglass_simple_low_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_low_duotone

</> 
pub fn hourglass_simple_low_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_low_fill

</> 
pub fn hourglass_simple_low_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_low_light

</> 
pub fn hourglass_simple_low_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_low_regular

</> 
pub fn hourglass_simple_low_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_low_thin

</> 
pub fn hourglass_simple_low_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_medium_bold

</> 
pub fn hourglass_simple_medium_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_medium_duotone

</> 
pub fn hourglass_simple_medium_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_medium_fill

</> 
pub fn hourglass_simple_medium_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_medium_light

</> 
pub fn hourglass_simple_medium_light(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_medium_regular

</> 
pub fn hourglass_simple_medium_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_medium_thin

</> 
pub fn hourglass_simple_medium_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_regular

</> 
pub fn hourglass_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_simple_thin

</> 
pub fn hourglass_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

hourglass_thin

</> 
pub fn hourglass_thin(attrs: List(Attribute(a))) -> Element(a)

house_bold

</> 
pub fn house_bold(attrs: List(Attribute(a))) -> Element(a)

house_duotone

</> 
pub fn house_duotone(attrs: List(Attribute(a))) -> Element(a)

house_fill

</> 
pub fn house_fill(attrs: List(Attribute(a))) -> Element(a)

house_light

</> 
pub fn house_light(attrs: List(Attribute(a))) -> Element(a)

house_line_bold

</> 
pub fn house_line_bold(attrs: List(Attribute(a))) -> Element(a)

house_line_duotone

</> 
pub fn house_line_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

house_line_fill

</> 
pub fn house_line_fill(attrs: List(Attribute(a))) -> Element(a)

house_line_light

</> 
pub fn house_line_light(attrs: List(Attribute(a))) -> Element(a)

house_line_regular

</> 
pub fn house_line_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

house_line_thin

</> 
pub fn house_line_thin(attrs: List(Attribute(a))) -> Element(a)

house_regular

</> 
pub fn house_regular(attrs: List(Attribute(a))) -> Element(a)

house_simple_bold

</> 
pub fn house_simple_bold(attrs: List(Attribute(a))) -> Element(a)

house_simple_duotone

</> 
pub fn house_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

house_simple_fill

</> 
pub fn house_simple_fill(attrs: List(Attribute(a))) -> Element(a)

house_simple_light

</> 
pub fn house_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

house_simple_regular

</> 
pub fn house_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

house_simple_thin

</> 
pub fn house_simple_thin(attrs: List(Attribute(a))) -> Element(a)

house_thin

</> 
pub fn house_thin(attrs: List(Attribute(a))) -> Element(a)

hurricane_bold

</> 
pub fn hurricane_bold(attrs: List(Attribute(a))) -> Element(a)

hurricane_duotone

</> 
pub fn hurricane_duotone(attrs: List(Attribute(a))) -> Element(a)

hurricane_fill

</> 
pub fn hurricane_fill(attrs: List(Attribute(a))) -> Element(a)

hurricane_light

</> 
pub fn hurricane_light(attrs: List(Attribute(a))) -> Element(a)

hurricane_regular

</> 
pub fn hurricane_regular(attrs: List(Attribute(a))) -> Element(a)

hurricane_thin

</> 
pub fn hurricane_thin(attrs: List(Attribute(a))) -> Element(a)

ice_cream_bold

</> 
pub fn ice_cream_bold(attrs: List(Attribute(a))) -> Element(a)

ice_cream_duotone

</> 
pub fn ice_cream_duotone(attrs: List(Attribute(a))) -> Element(a)

ice_cream_fill

</> 
pub fn ice_cream_fill(attrs: List(Attribute(a))) -> Element(a)

ice_cream_light

</> 
pub fn ice_cream_light(attrs: List(Attribute(a))) -> Element(a)

ice_cream_regular

</> 
pub fn ice_cream_regular(attrs: List(Attribute(a))) -> Element(a)

ice_cream_thin

</> 
pub fn ice_cream_thin(attrs: List(Attribute(a))) -> Element(a)

identification_badge_bold

</> 
pub fn identification_badge_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_badge_duotone

</> 
pub fn identification_badge_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_badge_fill

</> 
pub fn identification_badge_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_badge_light

</> 
pub fn identification_badge_light(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_badge_regular

</> 
pub fn identification_badge_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_badge_thin

</> 
pub fn identification_badge_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_card_bold

</> 
pub fn identification_card_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_card_duotone

</> 
pub fn identification_card_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_card_fill

</> 
pub fn identification_card_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_card_light

</> 
pub fn identification_card_light(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_card_regular

</> 
pub fn identification_card_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

identification_card_thin

</> 
pub fn identification_card_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

image_bold

</> 
pub fn image_bold(attrs: List(Attribute(a))) -> Element(a)

image_broken_bold

</> 
pub fn image_broken_bold(attrs: List(Attribute(a))) -> Element(a)

image_broken_duotone

</> 
pub fn image_broken_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

image_broken_fill

</> 
pub fn image_broken_fill(attrs: List(Attribute(a))) -> Element(a)

image_broken_light

</> 
pub fn image_broken_light(
  attrs: List(Attribute(a)),
) -> Element(a)

image_broken_regular

</> 
pub fn image_broken_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

image_broken_thin

</> 
pub fn image_broken_thin(attrs: List(Attribute(a))) -> Element(a)

image_duotone

</> 
pub fn image_duotone(attrs: List(Attribute(a))) -> Element(a)

image_fill

</> 
pub fn image_fill(attrs: List(Attribute(a))) -> Element(a)

image_light

</> 
pub fn image_light(attrs: List(Attribute(a))) -> Element(a)

image_regular

</> 
pub fn image_regular(attrs: List(Attribute(a))) -> Element(a)

image_square_bold

</> 
pub fn image_square_bold(attrs: List(Attribute(a))) -> Element(a)

image_square_duotone

</> 
pub fn image_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

image_square_fill

</> 
pub fn image_square_fill(attrs: List(Attribute(a))) -> Element(a)

image_square_light

</> 
pub fn image_square_light(
  attrs: List(Attribute(a)),
) -> Element(a)

image_square_regular

</> 
pub fn image_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

image_square_thin

</> 
pub fn image_square_thin(attrs: List(Attribute(a))) -> Element(a)

image_thin

</> 
pub fn image_thin(attrs: List(Attribute(a))) -> Element(a)

images_bold

</> 
pub fn images_bold(attrs: List(Attribute(a))) -> Element(a)

images_duotone

</> 
pub fn images_duotone(attrs: List(Attribute(a))) -> Element(a)

images_fill

</> 
pub fn images_fill(attrs: List(Attribute(a))) -> Element(a)

images_light

</> 
pub fn images_light(attrs: List(Attribute(a))) -> Element(a)

images_regular

</> 
pub fn images_regular(attrs: List(Attribute(a))) -> Element(a)

images_square_bold

</> 
pub fn images_square_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

images_square_duotone

</> 
pub fn images_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

images_square_fill

</> 
pub fn images_square_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

images_square_light

</> 
pub fn images_square_light(
  attrs: List(Attribute(a)),
) -> Element(a)

images_square_regular

</> 
pub fn images_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

images_square_thin

</> 
pub fn images_square_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

images_thin

</> 
pub fn images_thin(attrs: List(Attribute(a))) -> Element(a)

infinity_bold

</> 
pub fn infinity_bold(attrs: List(Attribute(a))) -> Element(a)

infinity_duotone

</> 
pub fn infinity_duotone(attrs: List(Attribute(a))) -> Element(a)

infinity_fill

</> 
pub fn infinity_fill(attrs: List(Attribute(a))) -> Element(a)

infinity_light

</> 
pub fn infinity_light(attrs: List(Attribute(a))) -> Element(a)

infinity_regular

</> 
pub fn infinity_regular(attrs: List(Attribute(a))) -> Element(a)

infinity_thin

</> 
pub fn infinity_thin(attrs: List(Attribute(a))) -> Element(a)

info_bold

</> 
pub fn info_bold(attrs: List(Attribute(a))) -> Element(a)

info_duotone

</> 
pub fn info_duotone(attrs: List(Attribute(a))) -> Element(a)

info_fill

</> 
pub fn info_fill(attrs: List(Attribute(a))) -> Element(a)

info_light

</> 
pub fn info_light(attrs: List(Attribute(a))) -> Element(a)

info_regular

</> 
pub fn info_regular(attrs: List(Attribute(a))) -> Element(a)

info_thin

</> 
pub fn info_thin(attrs: List(Attribute(a))) -> Element(a)

instagram_logo_bold

</> 
pub fn instagram_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

instagram_logo_duotone

</> 
pub fn instagram_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

instagram_logo_fill

</> 
pub fn instagram_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

instagram_logo_light

</> 
pub fn instagram_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

instagram_logo_regular

</> 
pub fn instagram_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

instagram_logo_thin

</> 
pub fn instagram_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_bold

</> 
pub fn intersect_bold(attrs: List(Attribute(a))) -> Element(a)

intersect_duotone

</> 
pub fn intersect_duotone(attrs: List(Attribute(a))) -> Element(a)

intersect_fill

</> 
pub fn intersect_fill(attrs: List(Attribute(a))) -> Element(a)

intersect_light

</> 
pub fn intersect_light(attrs: List(Attribute(a))) -> Element(a)

intersect_regular

</> 
pub fn intersect_regular(attrs: List(Attribute(a))) -> Element(a)

intersect_square_bold

</> 
pub fn intersect_square_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_square_duotone

</> 
pub fn intersect_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_square_fill

</> 
pub fn intersect_square_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_square_light

</> 
pub fn intersect_square_light(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_square_regular

</> 
pub fn intersect_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_square_thin

</> 
pub fn intersect_square_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_thin

</> 
pub fn intersect_thin(attrs: List(Attribute(a))) -> Element(a)

intersect_three_bold

</> 
pub fn intersect_three_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_three_duotone

</> 
pub fn intersect_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_three_fill

</> 
pub fn intersect_three_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_three_light

</> 
pub fn intersect_three_light(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_three_regular

</> 
pub fn intersect_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

intersect_three_thin

</> 
pub fn intersect_three_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

intersection_bold

</> 
pub fn intersection_bold(attrs: List(Attribute(a))) -> Element(a)

intersection_duotone

</> 
pub fn intersection_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

intersection_fill

</> 
pub fn intersection_fill(attrs: List(Attribute(a))) -> Element(a)

intersection_light

</> 
pub fn intersection_light(
  attrs: List(Attribute(a)),
) -> Element(a)

intersection_regular

</> 
pub fn intersection_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

intersection_thin

</> 
pub fn intersection_thin(attrs: List(Attribute(a))) -> Element(a)

invoice_bold

</> 
pub fn invoice_bold(attrs: List(Attribute(a))) -> Element(a)

invoice_duotone

</> 
pub fn invoice_duotone(attrs: List(Attribute(a))) -> Element(a)

invoice_fill

</> 
pub fn invoice_fill(attrs: List(Attribute(a))) -> Element(a)

invoice_light

</> 
pub fn invoice_light(attrs: List(Attribute(a))) -> Element(a)

invoice_regular

</> 
pub fn invoice_regular(attrs: List(Attribute(a))) -> Element(a)

invoice_thin

</> 
pub fn invoice_thin(attrs: List(Attribute(a))) -> Element(a)

island_bold

</> 
pub fn island_bold(attrs: List(Attribute(a))) -> Element(a)

island_duotone

</> 
pub fn island_duotone(attrs: List(Attribute(a))) -> Element(a)

island_fill

</> 
pub fn island_fill(attrs: List(Attribute(a))) -> Element(a)

island_light

</> 
pub fn island_light(attrs: List(Attribute(a))) -> Element(a)

island_regular

</> 
pub fn island_regular(attrs: List(Attribute(a))) -> Element(a)

island_thin

</> 
pub fn island_thin(attrs: List(Attribute(a))) -> Element(a)

jar_bold

</> 
pub fn jar_bold(attrs: List(Attribute(a))) -> Element(a)

jar_duotone

</> 
pub fn jar_duotone(attrs: List(Attribute(a))) -> Element(a)

jar_fill

</> 
pub fn jar_fill(attrs: List(Attribute(a))) -> Element(a)

jar_label_bold

</> 
pub fn jar_label_bold(attrs: List(Attribute(a))) -> Element(a)

jar_label_duotone

</> 
pub fn jar_label_duotone(attrs: List(Attribute(a))) -> Element(a)

jar_label_fill

</> 
pub fn jar_label_fill(attrs: List(Attribute(a))) -> Element(a)

jar_label_light

</> 
pub fn jar_label_light(attrs: List(Attribute(a))) -> Element(a)

jar_label_regular

</> 
pub fn jar_label_regular(attrs: List(Attribute(a))) -> Element(a)

jar_label_thin

</> 
pub fn jar_label_thin(attrs: List(Attribute(a))) -> Element(a)

jar_light

</> 
pub fn jar_light(attrs: List(Attribute(a))) -> Element(a)

jar_regular

</> 
pub fn jar_regular(attrs: List(Attribute(a))) -> Element(a)

jar_thin

</> 
pub fn jar_thin(attrs: List(Attribute(a))) -> Element(a)

jeep_bold

</> 
pub fn jeep_bold(attrs: List(Attribute(a))) -> Element(a)

jeep_duotone

</> 
pub fn jeep_duotone(attrs: List(Attribute(a))) -> Element(a)

jeep_fill

</> 
pub fn jeep_fill(attrs: List(Attribute(a))) -> Element(a)

jeep_light

</> 
pub fn jeep_light(attrs: List(Attribute(a))) -> Element(a)

jeep_regular

</> 
pub fn jeep_regular(attrs: List(Attribute(a))) -> Element(a)

jeep_thin

</> 
pub fn jeep_thin(attrs: List(Attribute(a))) -> Element(a)

joystick_bold

</> 
pub fn joystick_bold(attrs: List(Attribute(a))) -> Element(a)

joystick_duotone

</> 
pub fn joystick_duotone(attrs: List(Attribute(a))) -> Element(a)

joystick_fill

</> 
pub fn joystick_fill(attrs: List(Attribute(a))) -> Element(a)

joystick_light

</> 
pub fn joystick_light(attrs: List(Attribute(a))) -> Element(a)

joystick_regular

</> 
pub fn joystick_regular(attrs: List(Attribute(a))) -> Element(a)

joystick_thin

</> 
pub fn joystick_thin(attrs: List(Attribute(a))) -> Element(a)

kanban_bold

</> 
pub fn kanban_bold(attrs: List(Attribute(a))) -> Element(a)

kanban_duotone

</> 
pub fn kanban_duotone(attrs: List(Attribute(a))) -> Element(a)

kanban_fill

</> 
pub fn kanban_fill(attrs: List(Attribute(a))) -> Element(a)

kanban_light

</> 
pub fn kanban_light(attrs: List(Attribute(a))) -> Element(a)

kanban_regular

</> 
pub fn kanban_regular(attrs: List(Attribute(a))) -> Element(a)

kanban_thin

</> 
pub fn kanban_thin(attrs: List(Attribute(a))) -> Element(a)

key_bold

</> 
pub fn key_bold(attrs: List(Attribute(a))) -> Element(a)

key_duotone

</> 
pub fn key_duotone(attrs: List(Attribute(a))) -> Element(a)

key_fill

</> 
pub fn key_fill(attrs: List(Attribute(a))) -> Element(a)

key_light

</> 
pub fn key_light(attrs: List(Attribute(a))) -> Element(a)

key_regular

</> 
pub fn key_regular(attrs: List(Attribute(a))) -> Element(a)

key_return_bold

</> 
pub fn key_return_bold(attrs: List(Attribute(a))) -> Element(a)

key_return_duotone

</> 
pub fn key_return_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

key_return_fill

</> 
pub fn key_return_fill(attrs: List(Attribute(a))) -> Element(a)

key_return_light

</> 
pub fn key_return_light(attrs: List(Attribute(a))) -> Element(a)

key_return_regular

</> 
pub fn key_return_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

key_return_thin

</> 
pub fn key_return_thin(attrs: List(Attribute(a))) -> Element(a)

key_thin

</> 
pub fn key_thin(attrs: List(Attribute(a))) -> Element(a)

keyboard_bold

</> 
pub fn keyboard_bold(attrs: List(Attribute(a))) -> Element(a)

keyboard_duotone

</> 
pub fn keyboard_duotone(attrs: List(Attribute(a))) -> Element(a)

keyboard_fill

</> 
pub fn keyboard_fill(attrs: List(Attribute(a))) -> Element(a)

keyboard_light

</> 
pub fn keyboard_light(attrs: List(Attribute(a))) -> Element(a)

keyboard_regular

</> 
pub fn keyboard_regular(attrs: List(Attribute(a))) -> Element(a)

keyboard_thin

</> 
pub fn keyboard_thin(attrs: List(Attribute(a))) -> Element(a)

keyhole_bold

</> 
pub fn keyhole_bold(attrs: List(Attribute(a))) -> Element(a)

keyhole_duotone

</> 
pub fn keyhole_duotone(attrs: List(Attribute(a))) -> Element(a)

keyhole_fill

</> 
pub fn keyhole_fill(attrs: List(Attribute(a))) -> Element(a)

keyhole_light

</> 
pub fn keyhole_light(attrs: List(Attribute(a))) -> Element(a)

keyhole_regular

</> 
pub fn keyhole_regular(attrs: List(Attribute(a))) -> Element(a)

keyhole_thin

</> 
pub fn keyhole_thin(attrs: List(Attribute(a))) -> Element(a)

knife_bold

</> 
pub fn knife_bold(attrs: List(Attribute(a))) -> Element(a)

knife_duotone

</> 
pub fn knife_duotone(attrs: List(Attribute(a))) -> Element(a)

knife_fill

</> 
pub fn knife_fill(attrs: List(Attribute(a))) -> Element(a)

knife_light

</> 
pub fn knife_light(attrs: List(Attribute(a))) -> Element(a)

knife_regular

</> 
pub fn knife_regular(attrs: List(Attribute(a))) -> Element(a)

knife_thin

</> 
pub fn knife_thin(attrs: List(Attribute(a))) -> Element(a)

ladder_bold

</> 
pub fn ladder_bold(attrs: List(Attribute(a))) -> Element(a)

ladder_duotone

</> 
pub fn ladder_duotone(attrs: List(Attribute(a))) -> Element(a)

ladder_fill

</> 
pub fn ladder_fill(attrs: List(Attribute(a))) -> Element(a)

ladder_light

</> 
pub fn ladder_light(attrs: List(Attribute(a))) -> Element(a)

ladder_regular

</> 
pub fn ladder_regular(attrs: List(Attribute(a))) -> Element(a)

ladder_simple_bold

</> 
pub fn ladder_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

ladder_simple_duotone

</> 
pub fn ladder_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

ladder_simple_fill

</> 
pub fn ladder_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

ladder_simple_light

</> 
pub fn ladder_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

ladder_simple_regular

</> 
pub fn ladder_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

ladder_simple_thin

</> 
pub fn ladder_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

ladder_thin

</> 
pub fn ladder_thin(attrs: List(Attribute(a))) -> Element(a)

lamp_bold

</> 
pub fn lamp_bold(attrs: List(Attribute(a))) -> Element(a)

lamp_duotone

</> 
pub fn lamp_duotone(attrs: List(Attribute(a))) -> Element(a)

lamp_fill

</> 
pub fn lamp_fill(attrs: List(Attribute(a))) -> Element(a)

lamp_light

</> 
pub fn lamp_light(attrs: List(Attribute(a))) -> Element(a)

lamp_pendant_bold

</> 
pub fn lamp_pendant_bold(attrs: List(Attribute(a))) -> Element(a)

lamp_pendant_duotone

</> 
pub fn lamp_pendant_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lamp_pendant_fill

</> 
pub fn lamp_pendant_fill(attrs: List(Attribute(a))) -> Element(a)

lamp_pendant_light

</> 
pub fn lamp_pendant_light(
  attrs: List(Attribute(a)),
) -> Element(a)

lamp_pendant_regular

</> 
pub fn lamp_pendant_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lamp_pendant_thin

</> 
pub fn lamp_pendant_thin(attrs: List(Attribute(a))) -> Element(a)

lamp_regular

</> 
pub fn lamp_regular(attrs: List(Attribute(a))) -> Element(a)

lamp_thin

</> 
pub fn lamp_thin(attrs: List(Attribute(a))) -> Element(a)

laptop_bold

</> 
pub fn laptop_bold(attrs: List(Attribute(a))) -> Element(a)

laptop_duotone

</> 
pub fn laptop_duotone(attrs: List(Attribute(a))) -> Element(a)

laptop_fill

</> 
pub fn laptop_fill(attrs: List(Attribute(a))) -> Element(a)

laptop_light

</> 
pub fn laptop_light(attrs: List(Attribute(a))) -> Element(a)

laptop_regular

</> 
pub fn laptop_regular(attrs: List(Attribute(a))) -> Element(a)

laptop_thin

</> 
pub fn laptop_thin(attrs: List(Attribute(a))) -> Element(a)

lasso_bold

</> 
pub fn lasso_bold(attrs: List(Attribute(a))) -> Element(a)

lasso_duotone

</> 
pub fn lasso_duotone(attrs: List(Attribute(a))) -> Element(a)

lasso_fill

</> 
pub fn lasso_fill(attrs: List(Attribute(a))) -> Element(a)

lasso_light

</> 
pub fn lasso_light(attrs: List(Attribute(a))) -> Element(a)

lasso_regular

</> 
pub fn lasso_regular(attrs: List(Attribute(a))) -> Element(a)

lasso_thin

</> 
pub fn lasso_thin(attrs: List(Attribute(a))) -> Element(a)

lastfm_logo_bold

</> 
pub fn lastfm_logo_bold(attrs: List(Attribute(a))) -> Element(a)

lastfm_logo_duotone

</> 
pub fn lastfm_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lastfm_logo_fill

</> 
pub fn lastfm_logo_fill(attrs: List(Attribute(a))) -> Element(a)

lastfm_logo_light

</> 
pub fn lastfm_logo_light(attrs: List(Attribute(a))) -> Element(a)

lastfm_logo_regular

</> 
pub fn lastfm_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lastfm_logo_thin

</> 
pub fn lastfm_logo_thin(attrs: List(Attribute(a))) -> Element(a)

layout_bold

</> 
pub fn layout_bold(attrs: List(Attribute(a))) -> Element(a)

layout_duotone

</> 
pub fn layout_duotone(attrs: List(Attribute(a))) -> Element(a)

layout_fill

</> 
pub fn layout_fill(attrs: List(Attribute(a))) -> Element(a)

layout_light

</> 
pub fn layout_light(attrs: List(Attribute(a))) -> Element(a)

layout_regular

</> 
pub fn layout_regular(attrs: List(Attribute(a))) -> Element(a)

layout_thin

</> 
pub fn layout_thin(attrs: List(Attribute(a))) -> Element(a)

leaf_bold

</> 
pub fn leaf_bold(attrs: List(Attribute(a))) -> Element(a)

leaf_duotone

</> 
pub fn leaf_duotone(attrs: List(Attribute(a))) -> Element(a)

leaf_fill

</> 
pub fn leaf_fill(attrs: List(Attribute(a))) -> Element(a)

leaf_light

</> 
pub fn leaf_light(attrs: List(Attribute(a))) -> Element(a)

leaf_regular

</> 
pub fn leaf_regular(attrs: List(Attribute(a))) -> Element(a)

leaf_thin

</> 
pub fn leaf_thin(attrs: List(Attribute(a))) -> Element(a)

lectern_bold

</> 
pub fn lectern_bold(attrs: List(Attribute(a))) -> Element(a)

lectern_duotone

</> 
pub fn lectern_duotone(attrs: List(Attribute(a))) -> Element(a)

lectern_fill

</> 
pub fn lectern_fill(attrs: List(Attribute(a))) -> Element(a)

lectern_light

</> 
pub fn lectern_light(attrs: List(Attribute(a))) -> Element(a)

lectern_regular

</> 
pub fn lectern_regular(attrs: List(Attribute(a))) -> Element(a)

lectern_thin

</> 
pub fn lectern_thin(attrs: List(Attribute(a))) -> Element(a)

lego_bold

</> 
pub fn lego_bold(attrs: List(Attribute(a))) -> Element(a)

lego_duotone

</> 
pub fn lego_duotone(attrs: List(Attribute(a))) -> Element(a)

lego_fill

</> 
pub fn lego_fill(attrs: List(Attribute(a))) -> Element(a)

lego_light

</> 
pub fn lego_light(attrs: List(Attribute(a))) -> Element(a)

lego_regular

</> 
pub fn lego_regular(attrs: List(Attribute(a))) -> Element(a)

lego_smiley_bold

</> 
pub fn lego_smiley_bold(attrs: List(Attribute(a))) -> Element(a)

lego_smiley_duotone

</> 
pub fn lego_smiley_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lego_smiley_fill

</> 
pub fn lego_smiley_fill(attrs: List(Attribute(a))) -> Element(a)

lego_smiley_light

</> 
pub fn lego_smiley_light(attrs: List(Attribute(a))) -> Element(a)

lego_smiley_regular

</> 
pub fn lego_smiley_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lego_smiley_thin

</> 
pub fn lego_smiley_thin(attrs: List(Attribute(a))) -> Element(a)

lego_thin

</> 
pub fn lego_thin(attrs: List(Attribute(a))) -> Element(a)

less_than_bold

</> 
pub fn less_than_bold(attrs: List(Attribute(a))) -> Element(a)

less_than_duotone

</> 
pub fn less_than_duotone(attrs: List(Attribute(a))) -> Element(a)

less_than_fill

</> 
pub fn less_than_fill(attrs: List(Attribute(a))) -> Element(a)

less_than_light

</> 
pub fn less_than_light(attrs: List(Attribute(a))) -> Element(a)

less_than_or_equal_bold

</> 
pub fn less_than_or_equal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

less_than_or_equal_duotone

</> 
pub fn less_than_or_equal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

less_than_or_equal_fill

</> 
pub fn less_than_or_equal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

less_than_or_equal_light

</> 
pub fn less_than_or_equal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

less_than_or_equal_regular

</> 
pub fn less_than_or_equal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

less_than_or_equal_thin

</> 
pub fn less_than_or_equal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

less_than_regular

</> 
pub fn less_than_regular(attrs: List(Attribute(a))) -> Element(a)

less_than_thin

</> 
pub fn less_than_thin(attrs: List(Attribute(a))) -> Element(a)

letter_circle_h_bold

</> 
pub fn letter_circle_h_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_h_duotone

</> 
pub fn letter_circle_h_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_h_fill

</> 
pub fn letter_circle_h_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_h_light

</> 
pub fn letter_circle_h_light(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_h_regular

</> 
pub fn letter_circle_h_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_h_thin

</> 
pub fn letter_circle_h_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_p_bold

</> 
pub fn letter_circle_p_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_p_duotone

</> 
pub fn letter_circle_p_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_p_fill

</> 
pub fn letter_circle_p_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_p_light

</> 
pub fn letter_circle_p_light(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_p_regular

</> 
pub fn letter_circle_p_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_p_thin

</> 
pub fn letter_circle_p_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_v_bold

</> 
pub fn letter_circle_v_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_v_duotone

</> 
pub fn letter_circle_v_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_v_fill

</> 
pub fn letter_circle_v_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_v_light

</> 
pub fn letter_circle_v_light(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_v_regular

</> 
pub fn letter_circle_v_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

letter_circle_v_thin

</> 
pub fn letter_circle_v_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

lifebuoy_bold

</> 
pub fn lifebuoy_bold(attrs: List(Attribute(a))) -> Element(a)

lifebuoy_duotone

</> 
pub fn lifebuoy_duotone(attrs: List(Attribute(a))) -> Element(a)

lifebuoy_fill

</> 
pub fn lifebuoy_fill(attrs: List(Attribute(a))) -> Element(a)

lifebuoy_light

</> 
pub fn lifebuoy_light(attrs: List(Attribute(a))) -> Element(a)

lifebuoy_regular

</> 
pub fn lifebuoy_regular(attrs: List(Attribute(a))) -> Element(a)

lifebuoy_thin

</> 
pub fn lifebuoy_thin(attrs: List(Attribute(a))) -> Element(a)

lightbulb_bold

</> 
pub fn lightbulb_bold(attrs: List(Attribute(a))) -> Element(a)

lightbulb_duotone

</> 
pub fn lightbulb_duotone(attrs: List(Attribute(a))) -> Element(a)

lightbulb_filament_bold

</> 
pub fn lightbulb_filament_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

lightbulb_filament_duotone

</> 
pub fn lightbulb_filament_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lightbulb_filament_fill

</> 
pub fn lightbulb_filament_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

lightbulb_filament_light

</> 
pub fn lightbulb_filament_light(
  attrs: List(Attribute(a)),
) -> Element(a)

lightbulb_filament_regular

</> 
pub fn lightbulb_filament_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lightbulb_filament_thin

</> 
pub fn lightbulb_filament_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

lightbulb_fill

</> 
pub fn lightbulb_fill(attrs: List(Attribute(a))) -> Element(a)

lightbulb_light

</> 
pub fn lightbulb_light(attrs: List(Attribute(a))) -> Element(a)

lightbulb_regular

</> 
pub fn lightbulb_regular(attrs: List(Attribute(a))) -> Element(a)

lightbulb_thin

</> 
pub fn lightbulb_thin(attrs: List(Attribute(a))) -> Element(a)

lighthouse_bold

</> 
pub fn lighthouse_bold(attrs: List(Attribute(a))) -> Element(a)

lighthouse_duotone

</> 
pub fn lighthouse_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lighthouse_fill

</> 
pub fn lighthouse_fill(attrs: List(Attribute(a))) -> Element(a)

lighthouse_light

</> 
pub fn lighthouse_light(attrs: List(Attribute(a))) -> Element(a)

lighthouse_regular

</> 
pub fn lighthouse_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lighthouse_thin

</> 
pub fn lighthouse_thin(attrs: List(Attribute(a))) -> Element(a)

lightning_a_bold

</> 
pub fn lightning_a_bold(attrs: List(Attribute(a))) -> Element(a)

lightning_a_duotone

</> 
pub fn lightning_a_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lightning_a_fill

</> 
pub fn lightning_a_fill(attrs: List(Attribute(a))) -> Element(a)

lightning_a_light

</> 
pub fn lightning_a_light(attrs: List(Attribute(a))) -> Element(a)

lightning_a_regular

</> 
pub fn lightning_a_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lightning_a_thin

</> 
pub fn lightning_a_thin(attrs: List(Attribute(a))) -> Element(a)

lightning_bold

</> 
pub fn lightning_bold(attrs: List(Attribute(a))) -> Element(a)

lightning_duotone

</> 
pub fn lightning_duotone(attrs: List(Attribute(a))) -> Element(a)

lightning_fill

</> 
pub fn lightning_fill(attrs: List(Attribute(a))) -> Element(a)

lightning_light

</> 
pub fn lightning_light(attrs: List(Attribute(a))) -> Element(a)

lightning_regular

</> 
pub fn lightning_regular(attrs: List(Attribute(a))) -> Element(a)

lightning_slash_bold

</> 
pub fn lightning_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

lightning_slash_duotone

</> 
pub fn lightning_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lightning_slash_fill

</> 
pub fn lightning_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

lightning_slash_light

</> 
pub fn lightning_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

lightning_slash_regular

</> 
pub fn lightning_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lightning_slash_thin

</> 
pub fn lightning_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

lightning_thin

</> 
pub fn lightning_thin(attrs: List(Attribute(a))) -> Element(a)

line_segment_bold

</> 
pub fn line_segment_bold(attrs: List(Attribute(a))) -> Element(a)

line_segment_duotone

</> 
pub fn line_segment_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

line_segment_fill

</> 
pub fn line_segment_fill(attrs: List(Attribute(a))) -> Element(a)

line_segment_light

</> 
pub fn line_segment_light(
  attrs: List(Attribute(a)),
) -> Element(a)

line_segment_regular

</> 
pub fn line_segment_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

line_segment_thin

</> 
pub fn line_segment_thin(attrs: List(Attribute(a))) -> Element(a)

line_segments_bold

</> 
pub fn line_segments_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

line_segments_duotone

</> 
pub fn line_segments_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

line_segments_fill

</> 
pub fn line_segments_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

line_segments_light

</> 
pub fn line_segments_light(
  attrs: List(Attribute(a)),
) -> Element(a)

line_segments_regular

</> 
pub fn line_segments_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

line_segments_thin

</> 
pub fn line_segments_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

line_vertical_bold

</> 
pub fn line_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

line_vertical_duotone

</> 
pub fn line_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

line_vertical_fill

</> 
pub fn line_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

line_vertical_light

</> 
pub fn line_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

line_vertical_regular

</> 
pub fn line_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

line_vertical_thin

</> 
pub fn line_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_bold(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_break_bold(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_break_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_break_fill(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_break_light(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_break_regular(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_break_thin(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_duotone(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_fill(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_light(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_regular(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_simple_bold(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_simple_break_bold(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_break_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_break_fill(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_break_light(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_break_regular(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_break_thin(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_fill(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_simple_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_break_bold(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_break_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_break_fill(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_break_light(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_break_regular(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_break_thin(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_light(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn link_simple_thin(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn link_thin(attrs: List(Attribute(a))) -> Element(a)

linkedin_logo_bold

</> 
pub fn linkedin_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

linkedin_logo_duotone

</> 
pub fn linkedin_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

linkedin_logo_fill

</> 
pub fn linkedin_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

linkedin_logo_light

</> 
pub fn linkedin_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

linkedin_logo_regular

</> 
pub fn linkedin_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

linkedin_logo_thin

</> 
pub fn linkedin_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

linktree_logo_bold

</> 
pub fn linktree_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

linktree_logo_duotone

</> 
pub fn linktree_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

linktree_logo_fill

</> 
pub fn linktree_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

linktree_logo_light

</> 
pub fn linktree_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

linktree_logo_regular

</> 
pub fn linktree_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

linktree_logo_thin

</> 
pub fn linktree_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

linux_logo_bold

</> 
pub fn linux_logo_bold(attrs: List(Attribute(a))) -> Element(a)

linux_logo_duotone

</> 
pub fn linux_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

linux_logo_fill

</> 
pub fn linux_logo_fill(attrs: List(Attribute(a))) -> Element(a)

linux_logo_light

</> 
pub fn linux_logo_light(attrs: List(Attribute(a))) -> Element(a)

linux_logo_regular

</> 
pub fn linux_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

linux_logo_thin

</> 
pub fn linux_logo_thin(attrs: List(Attribute(a))) -> Element(a)

list_bold

</> 
pub fn list_bold(attrs: List(Attribute(a))) -> Element(a)

list_bullets_bold

</> 
pub fn list_bullets_bold(attrs: List(Attribute(a))) -> Element(a)

list_bullets_duotone

</> 
pub fn list_bullets_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

list_bullets_fill

</> 
pub fn list_bullets_fill(attrs: List(Attribute(a))) -> Element(a)

list_bullets_light

</> 
pub fn list_bullets_light(
  attrs: List(Attribute(a)),
) -> Element(a)

list_bullets_regular

</> 
pub fn list_bullets_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

list_bullets_thin

</> 
pub fn list_bullets_thin(attrs: List(Attribute(a))) -> Element(a)

list_checks_bold

</> 
pub fn list_checks_bold(attrs: List(Attribute(a))) -> Element(a)

list_checks_duotone

</> 
pub fn list_checks_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

list_checks_fill

</> 
pub fn list_checks_fill(attrs: List(Attribute(a))) -> Element(a)

list_checks_light

</> 
pub fn list_checks_light(attrs: List(Attribute(a))) -> Element(a)

list_checks_regular

</> 
pub fn list_checks_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

list_checks_thin

</> 
pub fn list_checks_thin(attrs: List(Attribute(a))) -> Element(a)

list_dashes_bold

</> 
pub fn list_dashes_bold(attrs: List(Attribute(a))) -> Element(a)

list_dashes_duotone

</> 
pub fn list_dashes_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

list_dashes_fill

</> 
pub fn list_dashes_fill(attrs: List(Attribute(a))) -> Element(a)

list_dashes_light

</> 
pub fn list_dashes_light(attrs: List(Attribute(a))) -> Element(a)

list_dashes_regular

</> 
pub fn list_dashes_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

list_dashes_thin

</> 
pub fn list_dashes_thin(attrs: List(Attribute(a))) -> Element(a)

list_duotone

</> 
pub fn list_duotone(attrs: List(Attribute(a))) -> Element(a)

list_fill

</> 
pub fn list_fill(attrs: List(Attribute(a))) -> Element(a)

list_heart_bold

</> 
pub fn list_heart_bold(attrs: List(Attribute(a))) -> Element(a)

list_heart_duotone

</> 
pub fn list_heart_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

list_heart_fill

</> 
pub fn list_heart_fill(attrs: List(Attribute(a))) -> Element(a)

list_heart_light

</> 
pub fn list_heart_light(attrs: List(Attribute(a))) -> Element(a)

list_heart_regular

</> 
pub fn list_heart_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

list_heart_thin

</> 
pub fn list_heart_thin(attrs: List(Attribute(a))) -> Element(a)

list_light

</> 
pub fn list_light(attrs: List(Attribute(a))) -> Element(a)

list_magnifying_glass_bold

</> 
pub fn list_magnifying_glass_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

list_magnifying_glass_duotone

</> 
pub fn list_magnifying_glass_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

list_magnifying_glass_fill

</> 
pub fn list_magnifying_glass_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

list_magnifying_glass_light

</> 
pub fn list_magnifying_glass_light(
  attrs: List(Attribute(a)),
) -> Element(a)

list_magnifying_glass_regular

</> 
pub fn list_magnifying_glass_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

list_magnifying_glass_thin

</> 
pub fn list_magnifying_glass_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

list_numbers_bold

</> 
pub fn list_numbers_bold(attrs: List(Attribute(a))) -> Element(a)

list_numbers_duotone

</> 
pub fn list_numbers_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

list_numbers_fill

</> 
pub fn list_numbers_fill(attrs: List(Attribute(a))) -> Element(a)

list_numbers_light

</> 
pub fn list_numbers_light(
  attrs: List(Attribute(a)),
) -> Element(a)

list_numbers_regular

</> 
pub fn list_numbers_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

list_numbers_thin

</> 
pub fn list_numbers_thin(attrs: List(Attribute(a))) -> Element(a)

list_plus_bold

</> 
pub fn list_plus_bold(attrs: List(Attribute(a))) -> Element(a)

list_plus_duotone

</> 
pub fn list_plus_duotone(attrs: List(Attribute(a))) -> Element(a)

list_plus_fill

</> 
pub fn list_plus_fill(attrs: List(Attribute(a))) -> Element(a)

list_plus_light

</> 
pub fn list_plus_light(attrs: List(Attribute(a))) -> Element(a)

list_plus_regular

</> 
pub fn list_plus_regular(attrs: List(Attribute(a))) -> Element(a)

list_plus_thin

</> 
pub fn list_plus_thin(attrs: List(Attribute(a))) -> Element(a)

list_regular

</> 
pub fn list_regular(attrs: List(Attribute(a))) -> Element(a)

list_star_bold

</> 
pub fn list_star_bold(attrs: List(Attribute(a))) -> Element(a)

list_star_duotone

</> 
pub fn list_star_duotone(attrs: List(Attribute(a))) -> Element(a)

list_star_fill

</> 
pub fn list_star_fill(attrs: List(Attribute(a))) -> Element(a)

list_star_light

</> 
pub fn list_star_light(attrs: List(Attribute(a))) -> Element(a)

list_star_regular

</> 
pub fn list_star_regular(attrs: List(Attribute(a))) -> Element(a)

list_star_thin

</> 
pub fn list_star_thin(attrs: List(Attribute(a))) -> Element(a)

list_thin

</> 
pub fn list_thin(attrs: List(Attribute(a))) -> Element(a)

lock_bold

</> 
pub fn lock_bold(attrs: List(Attribute(a))) -> Element(a)

lock_duotone

</> 
pub fn lock_duotone(attrs: List(Attribute(a))) -> Element(a)

lock_fill

</> 
pub fn lock_fill(attrs: List(Attribute(a))) -> Element(a)

lock_key_bold

</> 
pub fn lock_key_bold(attrs: List(Attribute(a))) -> Element(a)

lock_key_duotone

</> 
pub fn lock_key_duotone(attrs: List(Attribute(a))) -> Element(a)

lock_key_fill

</> 
pub fn lock_key_fill(attrs: List(Attribute(a))) -> Element(a)

lock_key_light

</> 
pub fn lock_key_light(attrs: List(Attribute(a))) -> Element(a)

lock_key_open_bold

</> 
pub fn lock_key_open_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_key_open_duotone

</> 
pub fn lock_key_open_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_key_open_fill

</> 
pub fn lock_key_open_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_key_open_light

</> 
pub fn lock_key_open_light(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_key_open_regular

</> 
pub fn lock_key_open_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_key_open_thin

</> 
pub fn lock_key_open_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_key_regular

</> 
pub fn lock_key_regular(attrs: List(Attribute(a))) -> Element(a)

lock_key_thin

</> 
pub fn lock_key_thin(attrs: List(Attribute(a))) -> Element(a)

lock_laminated_bold

</> 
pub fn lock_laminated_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_duotone

</> 
pub fn lock_laminated_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_fill

</> 
pub fn lock_laminated_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_light

</> 
pub fn lock_laminated_light(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_open_bold

</> 
pub fn lock_laminated_open_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_open_duotone

</> 
pub fn lock_laminated_open_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_open_fill

</> 
pub fn lock_laminated_open_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_open_light

</> 
pub fn lock_laminated_open_light(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_open_regular

</> 
pub fn lock_laminated_open_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_open_thin

</> 
pub fn lock_laminated_open_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_regular

</> 
pub fn lock_laminated_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_laminated_thin

</> 
pub fn lock_laminated_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_light

</> 
pub fn lock_light(attrs: List(Attribute(a))) -> Element(a)

lock_open_bold

</> 
pub fn lock_open_bold(attrs: List(Attribute(a))) -> Element(a)

lock_open_duotone

</> 
pub fn lock_open_duotone(attrs: List(Attribute(a))) -> Element(a)

lock_open_fill

</> 
pub fn lock_open_fill(attrs: List(Attribute(a))) -> Element(a)

lock_open_light

</> 
pub fn lock_open_light(attrs: List(Attribute(a))) -> Element(a)

lock_open_regular

</> 
pub fn lock_open_regular(attrs: List(Attribute(a))) -> Element(a)

lock_open_thin

</> 
pub fn lock_open_thin(attrs: List(Attribute(a))) -> Element(a)

lock_regular

</> 
pub fn lock_regular(attrs: List(Attribute(a))) -> Element(a)

lock_simple_bold

</> 
pub fn lock_simple_bold(attrs: List(Attribute(a))) -> Element(a)

lock_simple_duotone

</> 
pub fn lock_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_simple_fill

</> 
pub fn lock_simple_fill(attrs: List(Attribute(a))) -> Element(a)

lock_simple_light

</> 
pub fn lock_simple_light(attrs: List(Attribute(a))) -> Element(a)

lock_simple_open_bold

</> 
pub fn lock_simple_open_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_simple_open_duotone

</> 
pub fn lock_simple_open_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_simple_open_fill

</> 
pub fn lock_simple_open_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_simple_open_light

</> 
pub fn lock_simple_open_light(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_simple_open_regular

</> 
pub fn lock_simple_open_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_simple_open_thin

</> 
pub fn lock_simple_open_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_simple_regular

</> 
pub fn lock_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

lock_simple_thin

</> 
pub fn lock_simple_thin(attrs: List(Attribute(a))) -> Element(a)

lock_thin

</> 
pub fn lock_thin(attrs: List(Attribute(a))) -> Element(a)

lockers_bold

</> 
pub fn lockers_bold(attrs: List(Attribute(a))) -> Element(a)

lockers_duotone

</> 
pub fn lockers_duotone(attrs: List(Attribute(a))) -> Element(a)

lockers_fill

</> 
pub fn lockers_fill(attrs: List(Attribute(a))) -> Element(a)

lockers_light

</> 
pub fn lockers_light(attrs: List(Attribute(a))) -> Element(a)

lockers_regular

</> 
pub fn lockers_regular(attrs: List(Attribute(a))) -> Element(a)

lockers_thin

</> 
pub fn lockers_thin(attrs: List(Attribute(a))) -> Element(a)

log_bold

</> 
pub fn log_bold(attrs: List(Attribute(a))) -> Element(a)

log_duotone

</> 
pub fn log_duotone(attrs: List(Attribute(a))) -> Element(a)

log_fill

</> 
pub fn log_fill(attrs: List(Attribute(a))) -> Element(a)

log_light

</> 
pub fn log_light(attrs: List(Attribute(a))) -> Element(a)

log_regular

</> 
pub fn log_regular(attrs: List(Attribute(a))) -> Element(a)

log_thin

</> 
pub fn log_thin(attrs: List(Attribute(a))) -> Element(a)

magic_wand_bold

</> 
pub fn magic_wand_bold(attrs: List(Attribute(a))) -> Element(a)

magic_wand_duotone

</> 
pub fn magic_wand_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

magic_wand_fill

</> 
pub fn magic_wand_fill(attrs: List(Attribute(a))) -> Element(a)

magic_wand_light

</> 
pub fn magic_wand_light(attrs: List(Attribute(a))) -> Element(a)

magic_wand_regular

</> 
pub fn magic_wand_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

magic_wand_thin

</> 
pub fn magic_wand_thin(attrs: List(Attribute(a))) -> Element(a)

magnet_bold

</> 
pub fn magnet_bold(attrs: List(Attribute(a))) -> Element(a)

magnet_duotone

</> 
pub fn magnet_duotone(attrs: List(Attribute(a))) -> Element(a)

magnet_fill

</> 
pub fn magnet_fill(attrs: List(Attribute(a))) -> Element(a)

magnet_light

</> 
pub fn magnet_light(attrs: List(Attribute(a))) -> Element(a)

magnet_regular

</> 
pub fn magnet_regular(attrs: List(Attribute(a))) -> Element(a)

magnet_straight_bold

</> 
pub fn magnet_straight_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

magnet_straight_duotone

</> 
pub fn magnet_straight_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

magnet_straight_fill

</> 
pub fn magnet_straight_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

magnet_straight_light

</> 
pub fn magnet_straight_light(
  attrs: List(Attribute(a)),
) -> Element(a)

magnet_straight_regular

</> 
pub fn magnet_straight_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

magnet_straight_thin

</> 
pub fn magnet_straight_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

magnet_thin

</> 
pub fn magnet_thin(attrs: List(Attribute(a))) -> Element(a)

magnifying_glass_bold

</> 
pub fn magnifying_glass_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_duotone

</> 
pub fn magnifying_glass_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_fill

</> 
pub fn magnifying_glass_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_light

</> 
pub fn magnifying_glass_light(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_minus_bold

</> 
pub fn magnifying_glass_minus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_minus_duotone

</> 
pub fn magnifying_glass_minus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_minus_fill

</> 
pub fn magnifying_glass_minus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_minus_light

</> 
pub fn magnifying_glass_minus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_minus_regular

</> 
pub fn magnifying_glass_minus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_minus_thin

</> 
pub fn magnifying_glass_minus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_plus_bold

</> 
pub fn magnifying_glass_plus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_plus_duotone

</> 
pub fn magnifying_glass_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_plus_fill

</> 
pub fn magnifying_glass_plus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_plus_light

</> 
pub fn magnifying_glass_plus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_plus_regular

</> 
pub fn magnifying_glass_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_plus_thin

</> 
pub fn magnifying_glass_plus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_regular

</> 
pub fn magnifying_glass_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

magnifying_glass_thin

</> 
pub fn magnifying_glass_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

mailbox_bold

</> 
pub fn mailbox_bold(attrs: List(Attribute(a))) -> Element(a)

mailbox_duotone

</> 
pub fn mailbox_duotone(attrs: List(Attribute(a))) -> Element(a)

mailbox_fill

</> 
pub fn mailbox_fill(attrs: List(Attribute(a))) -> Element(a)

mailbox_light

</> 
pub fn mailbox_light(attrs: List(Attribute(a))) -> Element(a)

mailbox_regular

</> 
pub fn mailbox_regular(attrs: List(Attribute(a))) -> Element(a)

mailbox_thin

</> 
pub fn mailbox_thin(attrs: List(Attribute(a))) -> Element(a)

map_pin_area_bold

</> 
pub fn map_pin_area_bold(attrs: List(Attribute(a))) -> Element(a)

map_pin_area_duotone

</> 
pub fn map_pin_area_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_area_fill

</> 
pub fn map_pin_area_fill(attrs: List(Attribute(a))) -> Element(a)

map_pin_area_light

</> 
pub fn map_pin_area_light(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_area_regular

</> 
pub fn map_pin_area_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_area_thin

</> 
pub fn map_pin_area_thin(attrs: List(Attribute(a))) -> Element(a)

map_pin_bold

</> 
pub fn map_pin_bold(attrs: List(Attribute(a))) -> Element(a)

map_pin_duotone

</> 
pub fn map_pin_duotone(attrs: List(Attribute(a))) -> Element(a)

map_pin_fill

</> 
pub fn map_pin_fill(attrs: List(Attribute(a))) -> Element(a)

map_pin_light

</> 
pub fn map_pin_light(attrs: List(Attribute(a))) -> Element(a)

map_pin_line_bold

</> 
pub fn map_pin_line_bold(attrs: List(Attribute(a))) -> Element(a)

map_pin_line_duotone

</> 
pub fn map_pin_line_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_line_fill

</> 
pub fn map_pin_line_fill(attrs: List(Attribute(a))) -> Element(a)

map_pin_line_light

</> 
pub fn map_pin_line_light(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_line_regular

</> 
pub fn map_pin_line_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_line_thin

</> 
pub fn map_pin_line_thin(attrs: List(Attribute(a))) -> Element(a)

map_pin_plus_bold

</> 
pub fn map_pin_plus_bold(attrs: List(Attribute(a))) -> Element(a)

map_pin_plus_duotone

</> 
pub fn map_pin_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_plus_fill

</> 
pub fn map_pin_plus_fill(attrs: List(Attribute(a))) -> Element(a)

map_pin_plus_light

</> 
pub fn map_pin_plus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_plus_regular

</> 
pub fn map_pin_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_plus_thin

</> 
pub fn map_pin_plus_thin(attrs: List(Attribute(a))) -> Element(a)

map_pin_regular

</> 
pub fn map_pin_regular(attrs: List(Attribute(a))) -> Element(a)

map_pin_simple_area_bold

</> 
pub fn map_pin_simple_area_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_area_duotone

</> 
pub fn map_pin_simple_area_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_area_fill

</> 
pub fn map_pin_simple_area_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_area_light

</> 
pub fn map_pin_simple_area_light(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_area_regular

</> 
pub fn map_pin_simple_area_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_area_thin

</> 
pub fn map_pin_simple_area_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_bold

</> 
pub fn map_pin_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_duotone

</> 
pub fn map_pin_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_fill

</> 
pub fn map_pin_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_light

</> 
pub fn map_pin_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_line_bold

</> 
pub fn map_pin_simple_line_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_line_duotone

</> 
pub fn map_pin_simple_line_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_line_fill

</> 
pub fn map_pin_simple_line_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_line_light

</> 
pub fn map_pin_simple_line_light(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_line_regular

</> 
pub fn map_pin_simple_line_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_line_thin

</> 
pub fn map_pin_simple_line_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_regular

</> 
pub fn map_pin_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_simple_thin

</> 
pub fn map_pin_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

map_pin_thin

</> 
pub fn map_pin_thin(attrs: List(Attribute(a))) -> Element(a)

map_trifold_bold

</> 
pub fn map_trifold_bold(attrs: List(Attribute(a))) -> Element(a)

map_trifold_duotone

</> 
pub fn map_trifold_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

map_trifold_fill

</> 
pub fn map_trifold_fill(attrs: List(Attribute(a))) -> Element(a)

map_trifold_light

</> 
pub fn map_trifold_light(attrs: List(Attribute(a))) -> Element(a)

map_trifold_regular

</> 
pub fn map_trifold_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

map_trifold_thin

</> 
pub fn map_trifold_thin(attrs: List(Attribute(a))) -> Element(a)

markdown_logo_bold

</> 
pub fn markdown_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

markdown_logo_duotone

</> 
pub fn markdown_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

markdown_logo_fill

</> 
pub fn markdown_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

markdown_logo_light

</> 
pub fn markdown_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

markdown_logo_regular

</> 
pub fn markdown_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

markdown_logo_thin

</> 
pub fn markdown_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

marker_circle_bold

</> 
pub fn marker_circle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

marker_circle_duotone

</> 
pub fn marker_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

marker_circle_fill

</> 
pub fn marker_circle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

marker_circle_light

</> 
pub fn marker_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

marker_circle_regular

</> 
pub fn marker_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

marker_circle_thin

</> 
pub fn marker_circle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

martini_bold

</> 
pub fn martini_bold(attrs: List(Attribute(a))) -> Element(a)

martini_duotone

</> 
pub fn martini_duotone(attrs: List(Attribute(a))) -> Element(a)

martini_fill

</> 
pub fn martini_fill(attrs: List(Attribute(a))) -> Element(a)

martini_light

</> 
pub fn martini_light(attrs: List(Attribute(a))) -> Element(a)

martini_regular

</> 
pub fn martini_regular(attrs: List(Attribute(a))) -> Element(a)

martini_thin

</> 
pub fn martini_thin(attrs: List(Attribute(a))) -> Element(a)

mask_happy_bold

</> 
pub fn mask_happy_bold(attrs: List(Attribute(a))) -> Element(a)

mask_happy_duotone

</> 
pub fn mask_happy_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

mask_happy_fill

</> 
pub fn mask_happy_fill(attrs: List(Attribute(a))) -> Element(a)

mask_happy_light

</> 
pub fn mask_happy_light(attrs: List(Attribute(a))) -> Element(a)

mask_happy_regular

</> 
pub fn mask_happy_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

mask_happy_thin

</> 
pub fn mask_happy_thin(attrs: List(Attribute(a))) -> Element(a)

mask_sad_bold

</> 
pub fn mask_sad_bold(attrs: List(Attribute(a))) -> Element(a)

mask_sad_duotone

</> 
pub fn mask_sad_duotone(attrs: List(Attribute(a))) -> Element(a)

mask_sad_fill

</> 
pub fn mask_sad_fill(attrs: List(Attribute(a))) -> Element(a)

mask_sad_light

</> 
pub fn mask_sad_light(attrs: List(Attribute(a))) -> Element(a)

mask_sad_regular

</> 
pub fn mask_sad_regular(attrs: List(Attribute(a))) -> Element(a)

mask_sad_thin

</> 
pub fn mask_sad_thin(attrs: List(Attribute(a))) -> Element(a)

mastodon_logo_bold

</> 
pub fn mastodon_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

mastodon_logo_duotone

</> 
pub fn mastodon_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

mastodon_logo_fill

</> 
pub fn mastodon_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

mastodon_logo_light

</> 
pub fn mastodon_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

mastodon_logo_regular

</> 
pub fn mastodon_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

mastodon_logo_thin

</> 
pub fn mastodon_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

math_operations_bold

</> 
pub fn math_operations_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

math_operations_duotone

</> 
pub fn math_operations_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

math_operations_fill

</> 
pub fn math_operations_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

math_operations_light

</> 
pub fn math_operations_light(
  attrs: List(Attribute(a)),
) -> Element(a)

math_operations_regular

</> 
pub fn math_operations_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

math_operations_thin

</> 
pub fn math_operations_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

matrix_logo_bold

</> 
pub fn matrix_logo_bold(attrs: List(Attribute(a))) -> Element(a)

matrix_logo_duotone

</> 
pub fn matrix_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

matrix_logo_fill

</> 
pub fn matrix_logo_fill(attrs: List(Attribute(a))) -> Element(a)

matrix_logo_light

</> 
pub fn matrix_logo_light(attrs: List(Attribute(a))) -> Element(a)

matrix_logo_regular

</> 
pub fn matrix_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

matrix_logo_thin

</> 
pub fn matrix_logo_thin(attrs: List(Attribute(a))) -> Element(a)

medal_bold

</> 
pub fn medal_bold(attrs: List(Attribute(a))) -> Element(a)

medal_duotone

</> 
pub fn medal_duotone(attrs: List(Attribute(a))) -> Element(a)

medal_fill

</> 
pub fn medal_fill(attrs: List(Attribute(a))) -> Element(a)

medal_light

</> 
pub fn medal_light(attrs: List(Attribute(a))) -> Element(a)

medal_military_bold

</> 
pub fn medal_military_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

medal_military_duotone

</> 
pub fn medal_military_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

medal_military_fill

</> 
pub fn medal_military_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

medal_military_light

</> 
pub fn medal_military_light(
  attrs: List(Attribute(a)),
) -> Element(a)

medal_military_regular

</> 
pub fn medal_military_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

medal_military_thin

</> 
pub fn medal_military_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

medal_regular

</> 
pub fn medal_regular(attrs: List(Attribute(a))) -> Element(a)

medal_thin

</> 
pub fn medal_thin(attrs: List(Attribute(a))) -> Element(a)

medium_logo_bold

</> 
pub fn medium_logo_bold(attrs: List(Attribute(a))) -> Element(a)

medium_logo_duotone

</> 
pub fn medium_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

medium_logo_fill

</> 
pub fn medium_logo_fill(attrs: List(Attribute(a))) -> Element(a)

medium_logo_light

</> 
pub fn medium_logo_light(attrs: List(Attribute(a))) -> Element(a)

medium_logo_regular

</> 
pub fn medium_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

medium_logo_thin

</> 
pub fn medium_logo_thin(attrs: List(Attribute(a))) -> Element(a)

megaphone_bold

</> 
pub fn megaphone_bold(attrs: List(Attribute(a))) -> Element(a)

megaphone_duotone

</> 
pub fn megaphone_duotone(attrs: List(Attribute(a))) -> Element(a)

megaphone_fill

</> 
pub fn megaphone_fill(attrs: List(Attribute(a))) -> Element(a)

megaphone_light

</> 
pub fn megaphone_light(attrs: List(Attribute(a))) -> Element(a)

megaphone_regular

</> 
pub fn megaphone_regular(attrs: List(Attribute(a))) -> Element(a)

megaphone_simple_bold

</> 
pub fn megaphone_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

megaphone_simple_duotone

</> 
pub fn megaphone_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

megaphone_simple_fill

</> 
pub fn megaphone_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

megaphone_simple_light

</> 
pub fn megaphone_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

megaphone_simple_regular

</> 
pub fn megaphone_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

megaphone_simple_thin

</> 
pub fn megaphone_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

megaphone_thin

</> 
pub fn megaphone_thin(attrs: List(Attribute(a))) -> Element(a)

member_of_bold

</> 
pub fn member_of_bold(attrs: List(Attribute(a))) -> Element(a)

member_of_duotone

</> 
pub fn member_of_duotone(attrs: List(Attribute(a))) -> Element(a)

member_of_fill

</> 
pub fn member_of_fill(attrs: List(Attribute(a))) -> Element(a)

member_of_light

</> 
pub fn member_of_light(attrs: List(Attribute(a))) -> Element(a)

member_of_regular

</> 
pub fn member_of_regular(attrs: List(Attribute(a))) -> Element(a)

member_of_thin

</> 
pub fn member_of_thin(attrs: List(Attribute(a))) -> Element(a)

memory_bold

</> 
pub fn memory_bold(attrs: List(Attribute(a))) -> Element(a)

memory_duotone

</> 
pub fn memory_duotone(attrs: List(Attribute(a))) -> Element(a)

memory_fill

</> 
pub fn memory_fill(attrs: List(Attribute(a))) -> Element(a)

memory_light

</> 
pub fn memory_light(attrs: List(Attribute(a))) -> Element(a)

memory_regular

</> 
pub fn memory_regular(attrs: List(Attribute(a))) -> Element(a)

memory_thin

</> 
pub fn memory_thin(attrs: List(Attribute(a))) -> Element(a)

messenger_logo_bold

</> 
pub fn messenger_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

messenger_logo_duotone

</> 
pub fn messenger_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

messenger_logo_fill

</> 
pub fn messenger_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

messenger_logo_light

</> 
pub fn messenger_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

messenger_logo_regular

</> 
pub fn messenger_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

messenger_logo_thin

</> 
pub fn messenger_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

meta_logo_bold

</> 
pub fn meta_logo_bold(attrs: List(Attribute(a))) -> Element(a)

meta_logo_duotone

</> 
pub fn meta_logo_duotone(attrs: List(Attribute(a))) -> Element(a)

meta_logo_fill

</> 
pub fn meta_logo_fill(attrs: List(Attribute(a))) -> Element(a)

meta_logo_light

</> 
pub fn meta_logo_light(attrs: List(Attribute(a))) -> Element(a)

meta_logo_regular

</> 
pub fn meta_logo_regular(attrs: List(Attribute(a))) -> Element(a)

meta_logo_thin

</> 
pub fn meta_logo_thin(attrs: List(Attribute(a))) -> Element(a)

meteor_bold

</> 
pub fn meteor_bold(attrs: List(Attribute(a))) -> Element(a)

meteor_duotone

</> 
pub fn meteor_duotone(attrs: List(Attribute(a))) -> Element(a)

meteor_fill

</> 
pub fn meteor_fill(attrs: List(Attribute(a))) -> Element(a)

meteor_light

</> 
pub fn meteor_light(attrs: List(Attribute(a))) -> Element(a)

meteor_regular

</> 
pub fn meteor_regular(attrs: List(Attribute(a))) -> Element(a)

meteor_thin

</> 
pub fn meteor_thin(attrs: List(Attribute(a))) -> Element(a)

metronome_bold

</> 
pub fn metronome_bold(attrs: List(Attribute(a))) -> Element(a)

metronome_duotone

</> 
pub fn metronome_duotone(attrs: List(Attribute(a))) -> Element(a)

metronome_fill

</> 
pub fn metronome_fill(attrs: List(Attribute(a))) -> Element(a)

metronome_light

</> 
pub fn metronome_light(attrs: List(Attribute(a))) -> Element(a)

metronome_regular

</> 
pub fn metronome_regular(attrs: List(Attribute(a))) -> Element(a)

metronome_thin

</> 
pub fn metronome_thin(attrs: List(Attribute(a))) -> Element(a)

microphone_bold

</> 
pub fn microphone_bold(attrs: List(Attribute(a))) -> Element(a)

microphone_duotone

</> 
pub fn microphone_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_fill

</> 
pub fn microphone_fill(attrs: List(Attribute(a))) -> Element(a)

microphone_light

</> 
pub fn microphone_light(attrs: List(Attribute(a))) -> Element(a)

microphone_regular

</> 
pub fn microphone_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_slash_bold

</> 
pub fn microphone_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_slash_duotone

</> 
pub fn microphone_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_slash_fill

</> 
pub fn microphone_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_slash_light

</> 
pub fn microphone_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_slash_regular

</> 
pub fn microphone_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_slash_thin

</> 
pub fn microphone_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_stage_bold

</> 
pub fn microphone_stage_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_stage_duotone

</> 
pub fn microphone_stage_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_stage_fill

</> 
pub fn microphone_stage_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_stage_light

</> 
pub fn microphone_stage_light(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_stage_regular

</> 
pub fn microphone_stage_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_stage_thin

</> 
pub fn microphone_stage_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

microphone_thin

</> 
pub fn microphone_thin(attrs: List(Attribute(a))) -> Element(a)

microscope_bold

</> 
pub fn microscope_bold(attrs: List(Attribute(a))) -> Element(a)

microscope_duotone

</> 
pub fn microscope_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

microscope_fill

</> 
pub fn microscope_fill(attrs: List(Attribute(a))) -> Element(a)

microscope_light

</> 
pub fn microscope_light(attrs: List(Attribute(a))) -> Element(a)

microscope_regular

</> 
pub fn microscope_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

microscope_thin

</> 
pub fn microscope_thin(attrs: List(Attribute(a))) -> Element(a)

microsoft_excel_logo_bold

</> 
pub fn microsoft_excel_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_excel_logo_duotone

</> 
pub fn microsoft_excel_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_excel_logo_fill

</> 
pub fn microsoft_excel_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_excel_logo_light

</> 
pub fn microsoft_excel_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_excel_logo_regular

</> 
pub fn microsoft_excel_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_excel_logo_thin

</> 
pub fn microsoft_excel_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_outlook_logo_bold

</> 
pub fn microsoft_outlook_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_outlook_logo_duotone

</> 
pub fn microsoft_outlook_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_outlook_logo_fill

</> 
pub fn microsoft_outlook_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_outlook_logo_light

</> 
pub fn microsoft_outlook_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_outlook_logo_regular

</> 
pub fn microsoft_outlook_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_outlook_logo_thin

</> 
pub fn microsoft_outlook_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_powerpoint_logo_bold

</> 
pub fn microsoft_powerpoint_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_powerpoint_logo_duotone

</> 
pub fn microsoft_powerpoint_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_powerpoint_logo_fill

</> 
pub fn microsoft_powerpoint_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_powerpoint_logo_light

</> 
pub fn microsoft_powerpoint_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_powerpoint_logo_regular

</> 
pub fn microsoft_powerpoint_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_powerpoint_logo_thin

</> 
pub fn microsoft_powerpoint_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_teams_logo_bold

</> 
pub fn microsoft_teams_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_teams_logo_duotone

</> 
pub fn microsoft_teams_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_teams_logo_fill

</> 
pub fn microsoft_teams_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_teams_logo_light

</> 
pub fn microsoft_teams_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_teams_logo_regular

</> 
pub fn microsoft_teams_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_teams_logo_thin

</> 
pub fn microsoft_teams_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_word_logo_bold

</> 
pub fn microsoft_word_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_word_logo_duotone

</> 
pub fn microsoft_word_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_word_logo_fill

</> 
pub fn microsoft_word_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_word_logo_light

</> 
pub fn microsoft_word_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_word_logo_regular

</> 
pub fn microsoft_word_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

microsoft_word_logo_thin

</> 
pub fn microsoft_word_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

minus_bold

</> 
pub fn minus_bold(attrs: List(Attribute(a))) -> Element(a)

minus_circle_bold

</> 
pub fn minus_circle_bold(attrs: List(Attribute(a))) -> Element(a)

minus_circle_duotone

</> 
pub fn minus_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

minus_circle_fill

</> 
pub fn minus_circle_fill(attrs: List(Attribute(a))) -> Element(a)

minus_circle_light

</> 
pub fn minus_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

minus_circle_regular

</> 
pub fn minus_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

minus_circle_thin

</> 
pub fn minus_circle_thin(attrs: List(Attribute(a))) -> Element(a)

minus_duotone

</> 
pub fn minus_duotone(attrs: List(Attribute(a))) -> Element(a)

minus_fill

</> 
pub fn minus_fill(attrs: List(Attribute(a))) -> Element(a)

minus_light

</> 
pub fn minus_light(attrs: List(Attribute(a))) -> Element(a)

minus_regular

</> 
pub fn minus_regular(attrs: List(Attribute(a))) -> Element(a)

minus_square_bold

</> 
pub fn minus_square_bold(attrs: List(Attribute(a))) -> Element(a)

minus_square_duotone

</> 
pub fn minus_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

minus_square_fill

</> 
pub fn minus_square_fill(attrs: List(Attribute(a))) -> Element(a)

minus_square_light

</> 
pub fn minus_square_light(
  attrs: List(Attribute(a)),
) -> Element(a)

minus_square_regular

</> 
pub fn minus_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

minus_square_thin

</> 
pub fn minus_square_thin(attrs: List(Attribute(a))) -> Element(a)

minus_thin

</> 
pub fn minus_thin(attrs: List(Attribute(a))) -> Element(a)

money_bold

</> 
pub fn money_bold(attrs: List(Attribute(a))) -> Element(a)

money_duotone

</> 
pub fn money_duotone(attrs: List(Attribute(a))) -> Element(a)

money_fill

</> 
pub fn money_fill(attrs: List(Attribute(a))) -> Element(a)

money_light

</> 
pub fn money_light(attrs: List(Attribute(a))) -> Element(a)

money_regular

</> 
pub fn money_regular(attrs: List(Attribute(a))) -> Element(a)

money_thin

</> 
pub fn money_thin(attrs: List(Attribute(a))) -> Element(a)

money_wavy_bold

</> 
pub fn money_wavy_bold(attrs: List(Attribute(a))) -> Element(a)

money_wavy_duotone

</> 
pub fn money_wavy_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

money_wavy_fill

</> 
pub fn money_wavy_fill(attrs: List(Attribute(a))) -> Element(a)

money_wavy_light

</> 
pub fn money_wavy_light(attrs: List(Attribute(a))) -> Element(a)

money_wavy_regular

</> 
pub fn money_wavy_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

money_wavy_thin

</> 
pub fn money_wavy_thin(attrs: List(Attribute(a))) -> Element(a)

monitor_arrow_up_bold

</> 
pub fn monitor_arrow_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

monitor_arrow_up_duotone

</> 
pub fn monitor_arrow_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

monitor_arrow_up_fill

</> 
pub fn monitor_arrow_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

monitor_arrow_up_light

</> 
pub fn monitor_arrow_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

monitor_arrow_up_regular

</> 
pub fn monitor_arrow_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

monitor_arrow_up_thin

</> 
pub fn monitor_arrow_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

monitor_bold

</> 
pub fn monitor_bold(attrs: List(Attribute(a))) -> Element(a)

monitor_duotone

</> 
pub fn monitor_duotone(attrs: List(Attribute(a))) -> Element(a)

monitor_fill

</> 
pub fn monitor_fill(attrs: List(Attribute(a))) -> Element(a)

monitor_light

</> 
pub fn monitor_light(attrs: List(Attribute(a))) -> Element(a)

monitor_play_bold

</> 
pub fn monitor_play_bold(attrs: List(Attribute(a))) -> Element(a)

monitor_play_duotone

</> 
pub fn monitor_play_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

monitor_play_fill

</> 
pub fn monitor_play_fill(attrs: List(Attribute(a))) -> Element(a)

monitor_play_light

</> 
pub fn monitor_play_light(
  attrs: List(Attribute(a)),
) -> Element(a)

monitor_play_regular

</> 
pub fn monitor_play_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

monitor_play_thin

</> 
pub fn monitor_play_thin(attrs: List(Attribute(a))) -> Element(a)

monitor_regular

</> 
pub fn monitor_regular(attrs: List(Attribute(a))) -> Element(a)

monitor_thin

</> 
pub fn monitor_thin(attrs: List(Attribute(a))) -> Element(a)

moon_bold

</> 
pub fn moon_bold(attrs: List(Attribute(a))) -> Element(a)

moon_duotone

</> 
pub fn moon_duotone(attrs: List(Attribute(a))) -> Element(a)

moon_fill

</> 
pub fn moon_fill(attrs: List(Attribute(a))) -> Element(a)

moon_light

</> 
pub fn moon_light(attrs: List(Attribute(a))) -> Element(a)

moon_regular

</> 
pub fn moon_regular(attrs: List(Attribute(a))) -> Element(a)

moon_stars_bold

</> 
pub fn moon_stars_bold(attrs: List(Attribute(a))) -> Element(a)

moon_stars_duotone

</> 
pub fn moon_stars_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

moon_stars_fill

</> 
pub fn moon_stars_fill(attrs: List(Attribute(a))) -> Element(a)

moon_stars_light

</> 
pub fn moon_stars_light(attrs: List(Attribute(a))) -> Element(a)

moon_stars_regular

</> 
pub fn moon_stars_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

moon_stars_thin

</> 
pub fn moon_stars_thin(attrs: List(Attribute(a))) -> Element(a)

moon_thin

</> 
pub fn moon_thin(attrs: List(Attribute(a))) -> Element(a)

moped_bold

</> 
pub fn moped_bold(attrs: List(Attribute(a))) -> Element(a)

moped_duotone

</> 
pub fn moped_duotone(attrs: List(Attribute(a))) -> Element(a)

moped_fill

</> 
pub fn moped_fill(attrs: List(Attribute(a))) -> Element(a)

moped_front_bold

</> 
pub fn moped_front_bold(attrs: List(Attribute(a))) -> Element(a)

moped_front_duotone

</> 
pub fn moped_front_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

moped_front_fill

</> 
pub fn moped_front_fill(attrs: List(Attribute(a))) -> Element(a)

moped_front_light

</> 
pub fn moped_front_light(attrs: List(Attribute(a))) -> Element(a)

moped_front_regular

</> 
pub fn moped_front_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

moped_front_thin

</> 
pub fn moped_front_thin(attrs: List(Attribute(a))) -> Element(a)

moped_light

</> 
pub fn moped_light(attrs: List(Attribute(a))) -> Element(a)

moped_regular

</> 
pub fn moped_regular(attrs: List(Attribute(a))) -> Element(a)

moped_thin

</> 
pub fn moped_thin(attrs: List(Attribute(a))) -> Element(a)

mosque_bold

</> 
pub fn mosque_bold(attrs: List(Attribute(a))) -> Element(a)

mosque_duotone

</> 
pub fn mosque_duotone(attrs: List(Attribute(a))) -> Element(a)

mosque_fill

</> 
pub fn mosque_fill(attrs: List(Attribute(a))) -> Element(a)

mosque_light

</> 
pub fn mosque_light(attrs: List(Attribute(a))) -> Element(a)

mosque_regular

</> 
pub fn mosque_regular(attrs: List(Attribute(a))) -> Element(a)

mosque_thin

</> 
pub fn mosque_thin(attrs: List(Attribute(a))) -> Element(a)

motorcycle_bold

</> 
pub fn motorcycle_bold(attrs: List(Attribute(a))) -> Element(a)

motorcycle_duotone

</> 
pub fn motorcycle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

motorcycle_fill

</> 
pub fn motorcycle_fill(attrs: List(Attribute(a))) -> Element(a)

motorcycle_light

</> 
pub fn motorcycle_light(attrs: List(Attribute(a))) -> Element(a)

motorcycle_regular

</> 
pub fn motorcycle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

motorcycle_thin

</> 
pub fn motorcycle_thin(attrs: List(Attribute(a))) -> Element(a)

mountains_bold

</> 
pub fn mountains_bold(attrs: List(Attribute(a))) -> Element(a)

mountains_duotone

</> 
pub fn mountains_duotone(attrs: List(Attribute(a))) -> Element(a)

mountains_fill

</> 
pub fn mountains_fill(attrs: List(Attribute(a))) -> Element(a)

mountains_light

</> 
pub fn mountains_light(attrs: List(Attribute(a))) -> Element(a)

mountains_regular

</> 
pub fn mountains_regular(attrs: List(Attribute(a))) -> Element(a)

mountains_thin

</> 
pub fn mountains_thin(attrs: List(Attribute(a))) -> Element(a)

mouse_bold

</> 
pub fn mouse_bold(attrs: List(Attribute(a))) -> Element(a)

mouse_duotone

</> 
pub fn mouse_duotone(attrs: List(Attribute(a))) -> Element(a)

mouse_fill

</> 
pub fn mouse_fill(attrs: List(Attribute(a))) -> Element(a)

mouse_left_click_bold

</> 
pub fn mouse_left_click_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_left_click_duotone

</> 
pub fn mouse_left_click_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_left_click_fill

</> 
pub fn mouse_left_click_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_left_click_light

</> 
pub fn mouse_left_click_light(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_left_click_regular

</> 
pub fn mouse_left_click_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_left_click_thin

</> 
pub fn mouse_left_click_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_light

</> 
pub fn mouse_light(attrs: List(Attribute(a))) -> Element(a)

mouse_middle_click_bold

</> 
pub fn mouse_middle_click_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_middle_click_duotone

</> 
pub fn mouse_middle_click_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_middle_click_fill

</> 
pub fn mouse_middle_click_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_middle_click_light

</> 
pub fn mouse_middle_click_light(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_middle_click_regular

</> 
pub fn mouse_middle_click_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_middle_click_thin

</> 
pub fn mouse_middle_click_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_regular

</> 
pub fn mouse_regular(attrs: List(Attribute(a))) -> Element(a)

mouse_right_click_bold

</> 
pub fn mouse_right_click_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_right_click_duotone

</> 
pub fn mouse_right_click_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_right_click_fill

</> 
pub fn mouse_right_click_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_right_click_light

</> 
pub fn mouse_right_click_light(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_right_click_regular

</> 
pub fn mouse_right_click_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_right_click_thin

</> 
pub fn mouse_right_click_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_scroll_bold

</> 
pub fn mouse_scroll_bold(attrs: List(Attribute(a))) -> Element(a)

mouse_scroll_duotone

</> 
pub fn mouse_scroll_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_scroll_fill

</> 
pub fn mouse_scroll_fill(attrs: List(Attribute(a))) -> Element(a)

mouse_scroll_light

</> 
pub fn mouse_scroll_light(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_scroll_regular

</> 
pub fn mouse_scroll_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_scroll_thin

</> 
pub fn mouse_scroll_thin(attrs: List(Attribute(a))) -> Element(a)

mouse_simple_bold

</> 
pub fn mouse_simple_bold(attrs: List(Attribute(a))) -> Element(a)

mouse_simple_duotone

</> 
pub fn mouse_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_simple_fill

</> 
pub fn mouse_simple_fill(attrs: List(Attribute(a))) -> Element(a)

mouse_simple_light

</> 
pub fn mouse_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_simple_regular

</> 
pub fn mouse_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

mouse_simple_thin

</> 
pub fn mouse_simple_thin(attrs: List(Attribute(a))) -> Element(a)

mouse_thin

</> 
pub fn mouse_thin(attrs: List(Attribute(a))) -> Element(a)

music_note_bold

</> 
pub fn music_note_bold(attrs: List(Attribute(a))) -> Element(a)

music_note_duotone

</> 
pub fn music_note_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

music_note_fill

</> 
pub fn music_note_fill(attrs: List(Attribute(a))) -> Element(a)

music_note_light

</> 
pub fn music_note_light(attrs: List(Attribute(a))) -> Element(a)

music_note_regular

</> 
pub fn music_note_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

music_note_simple_bold

</> 
pub fn music_note_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

music_note_simple_duotone

</> 
pub fn music_note_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

music_note_simple_fill

</> 
pub fn music_note_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

music_note_simple_light

</> 
pub fn music_note_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

music_note_simple_regular

</> 
pub fn music_note_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

music_note_simple_thin

</> 
pub fn music_note_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

music_note_thin

</> 
pub fn music_note_thin(attrs: List(Attribute(a))) -> Element(a)

music_notes_bold

</> 
pub fn music_notes_bold(attrs: List(Attribute(a))) -> Element(a)

music_notes_duotone

</> 
pub fn music_notes_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_fill

</> 
pub fn music_notes_fill(attrs: List(Attribute(a))) -> Element(a)

music_notes_light

</> 
pub fn music_notes_light(attrs: List(Attribute(a))) -> Element(a)

music_notes_minus_bold

</> 
pub fn music_notes_minus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_minus_duotone

</> 
pub fn music_notes_minus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_minus_fill

</> 
pub fn music_notes_minus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_minus_light

</> 
pub fn music_notes_minus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_minus_regular

</> 
pub fn music_notes_minus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_minus_thin

</> 
pub fn music_notes_minus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_plus_bold

</> 
pub fn music_notes_plus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_plus_duotone

</> 
pub fn music_notes_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_plus_fill

</> 
pub fn music_notes_plus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_plus_light

</> 
pub fn music_notes_plus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_plus_regular

</> 
pub fn music_notes_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_plus_thin

</> 
pub fn music_notes_plus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_regular

</> 
pub fn music_notes_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_simple_bold

</> 
pub fn music_notes_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_simple_duotone

</> 
pub fn music_notes_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_simple_fill

</> 
pub fn music_notes_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_simple_light

</> 
pub fn music_notes_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_simple_regular

</> 
pub fn music_notes_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_simple_thin

</> 
pub fn music_notes_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

music_notes_thin

</> 
pub fn music_notes_thin(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn navigation_arrow_bold(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn navigation_arrow_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn navigation_arrow_fill(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn navigation_arrow_light(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn navigation_arrow_regular(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn navigation_arrow_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

needle_bold

</> 
pub fn needle_bold(attrs: List(Attribute(a))) -> Element(a)

needle_duotone

</> 
pub fn needle_duotone(attrs: List(Attribute(a))) -> Element(a)

needle_fill

</> 
pub fn needle_fill(attrs: List(Attribute(a))) -> Element(a)

needle_light

</> 
pub fn needle_light(attrs: List(Attribute(a))) -> Element(a)

needle_regular

</> 
pub fn needle_regular(attrs: List(Attribute(a))) -> Element(a)

needle_thin

</> 
pub fn needle_thin(attrs: List(Attribute(a))) -> Element(a)

network_bold

</> 
pub fn network_bold(attrs: List(Attribute(a))) -> Element(a)

network_duotone

</> 
pub fn network_duotone(attrs: List(Attribute(a))) -> Element(a)

network_fill

</> 
pub fn network_fill(attrs: List(Attribute(a))) -> Element(a)

network_light

</> 
pub fn network_light(attrs: List(Attribute(a))) -> Element(a)

network_regular

</> 
pub fn network_regular(attrs: List(Attribute(a))) -> Element(a)

network_slash_bold

</> 
pub fn network_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

network_slash_duotone

</> 
pub fn network_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

network_slash_fill

</> 
pub fn network_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

network_slash_light

</> 
pub fn network_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

network_slash_regular

</> 
pub fn network_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

network_slash_thin

</> 
pub fn network_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

network_thin

</> 
pub fn network_thin(attrs: List(Attribute(a))) -> Element(a)

network_x_bold

</> 
pub fn network_x_bold(attrs: List(Attribute(a))) -> Element(a)

network_x_duotone

</> 
pub fn network_x_duotone(attrs: List(Attribute(a))) -> Element(a)

network_x_fill

</> 
pub fn network_x_fill(attrs: List(Attribute(a))) -> Element(a)

network_x_light

</> 
pub fn network_x_light(attrs: List(Attribute(a))) -> Element(a)

network_x_regular

</> 
pub fn network_x_regular(attrs: List(Attribute(a))) -> Element(a)

network_x_thin

</> 
pub fn network_x_thin(attrs: List(Attribute(a))) -> Element(a)

newspaper_bold

</> 
pub fn newspaper_bold(attrs: List(Attribute(a))) -> Element(a)

newspaper_clipping_bold

</> 
pub fn newspaper_clipping_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

newspaper_clipping_duotone

</> 
pub fn newspaper_clipping_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

newspaper_clipping_fill

</> 
pub fn newspaper_clipping_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

newspaper_clipping_light

</> 
pub fn newspaper_clipping_light(
  attrs: List(Attribute(a)),
) -> Element(a)

newspaper_clipping_regular

</> 
pub fn newspaper_clipping_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

newspaper_clipping_thin

</> 
pub fn newspaper_clipping_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

newspaper_duotone

</> 
pub fn newspaper_duotone(attrs: List(Attribute(a))) -> Element(a)

newspaper_fill

</> 
pub fn newspaper_fill(attrs: List(Attribute(a))) -> Element(a)

newspaper_light

</> 
pub fn newspaper_light(attrs: List(Attribute(a))) -> Element(a)

newspaper_regular

</> 
pub fn newspaper_regular(attrs: List(Attribute(a))) -> Element(a)

newspaper_thin

</> 
pub fn newspaper_thin(attrs: List(Attribute(a))) -> Element(a)

not_equals_bold

</> 
pub fn not_equals_bold(attrs: List(Attribute(a))) -> Element(a)

not_equals_duotone

</> 
pub fn not_equals_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

not_equals_fill

</> 
pub fn not_equals_fill(attrs: List(Attribute(a))) -> Element(a)

not_equals_light

</> 
pub fn not_equals_light(attrs: List(Attribute(a))) -> Element(a)

not_equals_regular

</> 
pub fn not_equals_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

not_equals_thin

</> 
pub fn not_equals_thin(attrs: List(Attribute(a))) -> Element(a)

not_member_of_bold

</> 
pub fn not_member_of_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

not_member_of_duotone

</> 
pub fn not_member_of_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

not_member_of_fill

</> 
pub fn not_member_of_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

not_member_of_light

</> 
pub fn not_member_of_light(
  attrs: List(Attribute(a)),
) -> Element(a)

not_member_of_regular

</> 
pub fn not_member_of_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

not_member_of_thin

</> 
pub fn not_member_of_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

not_subset_of_bold

</> 
pub fn not_subset_of_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

not_subset_of_duotone

</> 
pub fn not_subset_of_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

not_subset_of_fill

</> 
pub fn not_subset_of_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

not_subset_of_light

</> 
pub fn not_subset_of_light(
  attrs: List(Attribute(a)),
) -> Element(a)

not_subset_of_regular

</> 
pub fn not_subset_of_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

not_subset_of_thin

</> 
pub fn not_subset_of_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

not_superset_of_bold

</> 
pub fn not_superset_of_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

not_superset_of_duotone

</> 
pub fn not_superset_of_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

not_superset_of_fill

</> 
pub fn not_superset_of_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

not_superset_of_light

</> 
pub fn not_superset_of_light(
  attrs: List(Attribute(a)),
) -> Element(a)

not_superset_of_regular

</> 
pub fn not_superset_of_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

not_superset_of_thin

</> 
pub fn not_superset_of_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

notches_bold

</> 
pub fn notches_bold(attrs: List(Attribute(a))) -> Element(a)

notches_duotone

</> 
pub fn notches_duotone(attrs: List(Attribute(a))) -> Element(a)

notches_fill

</> 
pub fn notches_fill(attrs: List(Attribute(a))) -> Element(a)

notches_light

</> 
pub fn notches_light(attrs: List(Attribute(a))) -> Element(a)

notches_regular

</> 
pub fn notches_regular(attrs: List(Attribute(a))) -> Element(a)

notches_thin

</> 
pub fn notches_thin(attrs: List(Attribute(a))) -> Element(a)

note_blank_bold

</> 
pub fn note_blank_bold(attrs: List(Attribute(a))) -> Element(a)

note_blank_duotone

</> 
pub fn note_blank_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

note_blank_fill

</> 
pub fn note_blank_fill(attrs: List(Attribute(a))) -> Element(a)

note_blank_light

</> 
pub fn note_blank_light(attrs: List(Attribute(a))) -> Element(a)

note_blank_regular

</> 
pub fn note_blank_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

note_blank_thin

</> 
pub fn note_blank_thin(attrs: List(Attribute(a))) -> Element(a)

note_bold

</> 
pub fn note_bold(attrs: List(Attribute(a))) -> Element(a)

note_duotone

</> 
pub fn note_duotone(attrs: List(Attribute(a))) -> Element(a)

note_fill

</> 
pub fn note_fill(attrs: List(Attribute(a))) -> Element(a)

note_light

</> 
pub fn note_light(attrs: List(Attribute(a))) -> Element(a)

note_pencil_bold

</> 
pub fn note_pencil_bold(attrs: List(Attribute(a))) -> Element(a)

note_pencil_duotone

</> 
pub fn note_pencil_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

note_pencil_fill

</> 
pub fn note_pencil_fill(attrs: List(Attribute(a))) -> Element(a)

note_pencil_light

</> 
pub fn note_pencil_light(attrs: List(Attribute(a))) -> Element(a)

note_pencil_regular

</> 
pub fn note_pencil_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

note_pencil_thin

</> 
pub fn note_pencil_thin(attrs: List(Attribute(a))) -> Element(a)

note_regular

</> 
pub fn note_regular(attrs: List(Attribute(a))) -> Element(a)

note_thin

</> 
pub fn note_thin(attrs: List(Attribute(a))) -> Element(a)

notebook_bold

</> 
pub fn notebook_bold(attrs: List(Attribute(a))) -> Element(a)

notebook_duotone

</> 
pub fn notebook_duotone(attrs: List(Attribute(a))) -> Element(a)

notebook_fill

</> 
pub fn notebook_fill(attrs: List(Attribute(a))) -> Element(a)

notebook_light

</> 
pub fn notebook_light(attrs: List(Attribute(a))) -> Element(a)

notebook_regular

</> 
pub fn notebook_regular(attrs: List(Attribute(a))) -> Element(a)

notebook_thin

</> 
pub fn notebook_thin(attrs: List(Attribute(a))) -> Element(a)

notepad_bold

</> 
pub fn notepad_bold(attrs: List(Attribute(a))) -> Element(a)

notepad_duotone

</> 
pub fn notepad_duotone(attrs: List(Attribute(a))) -> Element(a)

notepad_fill

</> 
pub fn notepad_fill(attrs: List(Attribute(a))) -> Element(a)

notepad_light

</> 
pub fn notepad_light(attrs: List(Attribute(a))) -> Element(a)

notepad_regular

</> 
pub fn notepad_regular(attrs: List(Attribute(a))) -> Element(a)

notepad_thin

</> 
pub fn notepad_thin(attrs: List(Attribute(a))) -> Element(a)

notification_bold

</> 
pub fn notification_bold(attrs: List(Attribute(a))) -> Element(a)

notification_duotone

</> 
pub fn notification_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

notification_fill

</> 
pub fn notification_fill(attrs: List(Attribute(a))) -> Element(a)

notification_light

</> 
pub fn notification_light(
  attrs: List(Attribute(a)),
) -> Element(a)

notification_regular

</> 
pub fn notification_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

notification_thin

</> 
pub fn notification_thin(attrs: List(Attribute(a))) -> Element(a)

notion_logo_bold

</> 
pub fn notion_logo_bold(attrs: List(Attribute(a))) -> Element(a)

notion_logo_duotone

</> 
pub fn notion_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

notion_logo_fill

</> 
pub fn notion_logo_fill(attrs: List(Attribute(a))) -> Element(a)

notion_logo_light

</> 
pub fn notion_logo_light(attrs: List(Attribute(a))) -> Element(a)

notion_logo_regular

</> 
pub fn notion_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

notion_logo_thin

</> 
pub fn notion_logo_thin(attrs: List(Attribute(a))) -> Element(a)

nuclear_plant_bold

</> 
pub fn nuclear_plant_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

nuclear_plant_duotone

</> 
pub fn nuclear_plant_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

nuclear_plant_fill

</> 
pub fn nuclear_plant_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

nuclear_plant_light

</> 
pub fn nuclear_plant_light(
  attrs: List(Attribute(a)),
) -> Element(a)

nuclear_plant_regular

</> 
pub fn nuclear_plant_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

nuclear_plant_thin

</> 
pub fn nuclear_plant_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_eight_bold

</> 
pub fn number_circle_eight_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_eight_duotone

</> 
pub fn number_circle_eight_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_eight_fill

</> 
pub fn number_circle_eight_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_eight_light

</> 
pub fn number_circle_eight_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_eight_regular

</> 
pub fn number_circle_eight_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_eight_thin

</> 
pub fn number_circle_eight_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_five_bold

</> 
pub fn number_circle_five_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_five_duotone

</> 
pub fn number_circle_five_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_five_fill

</> 
pub fn number_circle_five_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_five_light

</> 
pub fn number_circle_five_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_five_regular

</> 
pub fn number_circle_five_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_five_thin

</> 
pub fn number_circle_five_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_four_bold

</> 
pub fn number_circle_four_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_four_duotone

</> 
pub fn number_circle_four_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_four_fill

</> 
pub fn number_circle_four_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_four_light

</> 
pub fn number_circle_four_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_four_regular

</> 
pub fn number_circle_four_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_four_thin

</> 
pub fn number_circle_four_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_nine_bold

</> 
pub fn number_circle_nine_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_nine_duotone

</> 
pub fn number_circle_nine_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_nine_fill

</> 
pub fn number_circle_nine_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_nine_light

</> 
pub fn number_circle_nine_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_nine_regular

</> 
pub fn number_circle_nine_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_nine_thin

</> 
pub fn number_circle_nine_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_one_bold

</> 
pub fn number_circle_one_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_one_duotone

</> 
pub fn number_circle_one_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_one_fill

</> 
pub fn number_circle_one_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_one_light

</> 
pub fn number_circle_one_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_one_regular

</> 
pub fn number_circle_one_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_one_thin

</> 
pub fn number_circle_one_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_seven_bold

</> 
pub fn number_circle_seven_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_seven_duotone

</> 
pub fn number_circle_seven_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_seven_fill

</> 
pub fn number_circle_seven_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_seven_light

</> 
pub fn number_circle_seven_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_seven_regular

</> 
pub fn number_circle_seven_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_seven_thin

</> 
pub fn number_circle_seven_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_six_bold

</> 
pub fn number_circle_six_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_six_duotone

</> 
pub fn number_circle_six_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_six_fill

</> 
pub fn number_circle_six_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_six_light

</> 
pub fn number_circle_six_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_six_regular

</> 
pub fn number_circle_six_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_six_thin

</> 
pub fn number_circle_six_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_three_bold

</> 
pub fn number_circle_three_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_three_duotone

</> 
pub fn number_circle_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_three_fill

</> 
pub fn number_circle_three_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_three_light

</> 
pub fn number_circle_three_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_three_regular

</> 
pub fn number_circle_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_three_thin

</> 
pub fn number_circle_three_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_two_bold

</> 
pub fn number_circle_two_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_two_duotone

</> 
pub fn number_circle_two_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_two_fill

</> 
pub fn number_circle_two_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_two_light

</> 
pub fn number_circle_two_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_two_regular

</> 
pub fn number_circle_two_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_two_thin

</> 
pub fn number_circle_two_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_zero_bold

</> 
pub fn number_circle_zero_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_zero_duotone

</> 
pub fn number_circle_zero_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_zero_fill

</> 
pub fn number_circle_zero_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_zero_light

</> 
pub fn number_circle_zero_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_zero_regular

</> 
pub fn number_circle_zero_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_circle_zero_thin

</> 
pub fn number_circle_zero_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_eight_bold

</> 
pub fn number_eight_bold(attrs: List(Attribute(a))) -> Element(a)

number_eight_duotone

</> 
pub fn number_eight_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_eight_fill

</> 
pub fn number_eight_fill(attrs: List(Attribute(a))) -> Element(a)

number_eight_light

</> 
pub fn number_eight_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_eight_regular

</> 
pub fn number_eight_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_eight_thin

</> 
pub fn number_eight_thin(attrs: List(Attribute(a))) -> Element(a)

number_five_bold

</> 
pub fn number_five_bold(attrs: List(Attribute(a))) -> Element(a)

number_five_duotone

</> 
pub fn number_five_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_five_fill

</> 
pub fn number_five_fill(attrs: List(Attribute(a))) -> Element(a)

number_five_light

</> 
pub fn number_five_light(attrs: List(Attribute(a))) -> Element(a)

number_five_regular

</> 
pub fn number_five_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_five_thin

</> 
pub fn number_five_thin(attrs: List(Attribute(a))) -> Element(a)

number_four_bold

</> 
pub fn number_four_bold(attrs: List(Attribute(a))) -> Element(a)

number_four_duotone

</> 
pub fn number_four_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_four_fill

</> 
pub fn number_four_fill(attrs: List(Attribute(a))) -> Element(a)

number_four_light

</> 
pub fn number_four_light(attrs: List(Attribute(a))) -> Element(a)

number_four_regular

</> 
pub fn number_four_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_four_thin

</> 
pub fn number_four_thin(attrs: List(Attribute(a))) -> Element(a)

number_nine_bold

</> 
pub fn number_nine_bold(attrs: List(Attribute(a))) -> Element(a)

number_nine_duotone

</> 
pub fn number_nine_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_nine_fill

</> 
pub fn number_nine_fill(attrs: List(Attribute(a))) -> Element(a)

number_nine_light

</> 
pub fn number_nine_light(attrs: List(Attribute(a))) -> Element(a)

number_nine_regular

</> 
pub fn number_nine_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_nine_thin

</> 
pub fn number_nine_thin(attrs: List(Attribute(a))) -> Element(a)

number_one_bold

</> 
pub fn number_one_bold(attrs: List(Attribute(a))) -> Element(a)

number_one_duotone

</> 
pub fn number_one_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_one_fill

</> 
pub fn number_one_fill(attrs: List(Attribute(a))) -> Element(a)

number_one_light

</> 
pub fn number_one_light(attrs: List(Attribute(a))) -> Element(a)

number_one_regular

</> 
pub fn number_one_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_one_thin

</> 
pub fn number_one_thin(attrs: List(Attribute(a))) -> Element(a)

number_seven_bold

</> 
pub fn number_seven_bold(attrs: List(Attribute(a))) -> Element(a)

number_seven_duotone

</> 
pub fn number_seven_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_seven_fill

</> 
pub fn number_seven_fill(attrs: List(Attribute(a))) -> Element(a)

number_seven_light

</> 
pub fn number_seven_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_seven_regular

</> 
pub fn number_seven_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_seven_thin

</> 
pub fn number_seven_thin(attrs: List(Attribute(a))) -> Element(a)

number_six_bold

</> 
pub fn number_six_bold(attrs: List(Attribute(a))) -> Element(a)

number_six_duotone

</> 
pub fn number_six_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_six_fill

</> 
pub fn number_six_fill(attrs: List(Attribute(a))) -> Element(a)

number_six_light

</> 
pub fn number_six_light(attrs: List(Attribute(a))) -> Element(a)

number_six_regular

</> 
pub fn number_six_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_six_thin

</> 
pub fn number_six_thin(attrs: List(Attribute(a))) -> Element(a)

number_square_eight_bold

</> 
pub fn number_square_eight_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_eight_duotone

</> 
pub fn number_square_eight_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_eight_fill

</> 
pub fn number_square_eight_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_eight_light

</> 
pub fn number_square_eight_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_eight_regular

</> 
pub fn number_square_eight_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_eight_thin

</> 
pub fn number_square_eight_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_five_bold

</> 
pub fn number_square_five_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_five_duotone

</> 
pub fn number_square_five_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_five_fill

</> 
pub fn number_square_five_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_five_light

</> 
pub fn number_square_five_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_five_regular

</> 
pub fn number_square_five_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_five_thin

</> 
pub fn number_square_five_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_four_bold

</> 
pub fn number_square_four_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_four_duotone

</> 
pub fn number_square_four_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_four_fill

</> 
pub fn number_square_four_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_four_light

</> 
pub fn number_square_four_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_four_regular

</> 
pub fn number_square_four_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_four_thin

</> 
pub fn number_square_four_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_nine_bold

</> 
pub fn number_square_nine_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_nine_duotone

</> 
pub fn number_square_nine_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_nine_fill

</> 
pub fn number_square_nine_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_nine_light

</> 
pub fn number_square_nine_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_nine_regular

</> 
pub fn number_square_nine_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_nine_thin

</> 
pub fn number_square_nine_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_one_bold

</> 
pub fn number_square_one_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_one_duotone

</> 
pub fn number_square_one_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_one_fill

</> 
pub fn number_square_one_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_one_light

</> 
pub fn number_square_one_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_one_regular

</> 
pub fn number_square_one_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_one_thin

</> 
pub fn number_square_one_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_seven_bold

</> 
pub fn number_square_seven_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_seven_duotone

</> 
pub fn number_square_seven_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_seven_fill

</> 
pub fn number_square_seven_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_seven_light

</> 
pub fn number_square_seven_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_seven_regular

</> 
pub fn number_square_seven_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_seven_thin

</> 
pub fn number_square_seven_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_six_bold

</> 
pub fn number_square_six_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_six_duotone

</> 
pub fn number_square_six_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_six_fill

</> 
pub fn number_square_six_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_six_light

</> 
pub fn number_square_six_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_six_regular

</> 
pub fn number_square_six_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_six_thin

</> 
pub fn number_square_six_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_three_bold

</> 
pub fn number_square_three_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_three_duotone

</> 
pub fn number_square_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_three_fill

</> 
pub fn number_square_three_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_three_light

</> 
pub fn number_square_three_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_three_regular

</> 
pub fn number_square_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_three_thin

</> 
pub fn number_square_three_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_two_bold

</> 
pub fn number_square_two_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_two_duotone

</> 
pub fn number_square_two_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_two_fill

</> 
pub fn number_square_two_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_two_light

</> 
pub fn number_square_two_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_two_regular

</> 
pub fn number_square_two_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_two_thin

</> 
pub fn number_square_two_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_zero_bold

</> 
pub fn number_square_zero_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_zero_duotone

</> 
pub fn number_square_zero_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_zero_fill

</> 
pub fn number_square_zero_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_zero_light

</> 
pub fn number_square_zero_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_zero_regular

</> 
pub fn number_square_zero_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_square_zero_thin

</> 
pub fn number_square_zero_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

number_three_bold

</> 
pub fn number_three_bold(attrs: List(Attribute(a))) -> Element(a)

number_three_duotone

</> 
pub fn number_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_three_fill

</> 
pub fn number_three_fill(attrs: List(Attribute(a))) -> Element(a)

number_three_light

</> 
pub fn number_three_light(
  attrs: List(Attribute(a)),
) -> Element(a)

number_three_regular

</> 
pub fn number_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_three_thin

</> 
pub fn number_three_thin(attrs: List(Attribute(a))) -> Element(a)

number_two_bold

</> 
pub fn number_two_bold(attrs: List(Attribute(a))) -> Element(a)

number_two_duotone

</> 
pub fn number_two_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_two_fill

</> 
pub fn number_two_fill(attrs: List(Attribute(a))) -> Element(a)

number_two_light

</> 
pub fn number_two_light(attrs: List(Attribute(a))) -> Element(a)

number_two_regular

</> 
pub fn number_two_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_two_thin

</> 
pub fn number_two_thin(attrs: List(Attribute(a))) -> Element(a)

number_zero_bold

</> 
pub fn number_zero_bold(attrs: List(Attribute(a))) -> Element(a)

number_zero_duotone

</> 
pub fn number_zero_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

number_zero_fill

</> 
pub fn number_zero_fill(attrs: List(Attribute(a))) -> Element(a)

number_zero_light

</> 
pub fn number_zero_light(attrs: List(Attribute(a))) -> Element(a)

number_zero_regular

</> 
pub fn number_zero_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

number_zero_thin

</> 
pub fn number_zero_thin(attrs: List(Attribute(a))) -> Element(a)

numpad_bold

</> 
pub fn numpad_bold(attrs: List(Attribute(a))) -> Element(a)

numpad_duotone

</> 
pub fn numpad_duotone(attrs: List(Attribute(a))) -> Element(a)

numpad_fill

</> 
pub fn numpad_fill(attrs: List(Attribute(a))) -> Element(a)

numpad_light

</> 
pub fn numpad_light(attrs: List(Attribute(a))) -> Element(a)

numpad_regular

</> 
pub fn numpad_regular(attrs: List(Attribute(a))) -> Element(a)

numpad_thin

</> 
pub fn numpad_thin(attrs: List(Attribute(a))) -> Element(a)

nut_bold

</> 
pub fn nut_bold(attrs: List(Attribute(a))) -> Element(a)

nut_duotone

</> 
pub fn nut_duotone(attrs: List(Attribute(a))) -> Element(a)

nut_fill

</> 
pub fn nut_fill(attrs: List(Attribute(a))) -> Element(a)

nut_light

</> 
pub fn nut_light(attrs: List(Attribute(a))) -> Element(a)

nut_regular

</> 
pub fn nut_regular(attrs: List(Attribute(a))) -> Element(a)

nut_thin

</> 
pub fn nut_thin(attrs: List(Attribute(a))) -> Element(a)

ny_times_logo_bold

</> 
pub fn ny_times_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

ny_times_logo_duotone

</> 
pub fn ny_times_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

ny_times_logo_fill

</> 
pub fn ny_times_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

ny_times_logo_light

</> 
pub fn ny_times_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

ny_times_logo_regular

</> 
pub fn ny_times_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

ny_times_logo_thin

</> 
pub fn ny_times_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

octagon_bold

</> 
pub fn octagon_bold(attrs: List(Attribute(a))) -> Element(a)

octagon_duotone

</> 
pub fn octagon_duotone(attrs: List(Attribute(a))) -> Element(a)

octagon_fill

</> 
pub fn octagon_fill(attrs: List(Attribute(a))) -> Element(a)

octagon_light

</> 
pub fn octagon_light(attrs: List(Attribute(a))) -> Element(a)

octagon_regular

</> 
pub fn octagon_regular(attrs: List(Attribute(a))) -> Element(a)

octagon_thin

</> 
pub fn octagon_thin(attrs: List(Attribute(a))) -> Element(a)

office_chair_bold

</> 
pub fn office_chair_bold(attrs: List(Attribute(a))) -> Element(a)

office_chair_duotone

</> 
pub fn office_chair_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

office_chair_fill

</> 
pub fn office_chair_fill(attrs: List(Attribute(a))) -> Element(a)

office_chair_light

</> 
pub fn office_chair_light(
  attrs: List(Attribute(a)),
) -> Element(a)

office_chair_regular

</> 
pub fn office_chair_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

office_chair_thin

</> 
pub fn office_chair_thin(attrs: List(Attribute(a))) -> Element(a)

onigiri_bold

</> 
pub fn onigiri_bold(attrs: List(Attribute(a))) -> Element(a)

onigiri_duotone

</> 
pub fn onigiri_duotone(attrs: List(Attribute(a))) -> Element(a)

onigiri_fill

</> 
pub fn onigiri_fill(attrs: List(Attribute(a))) -> Element(a)

onigiri_light

</> 
pub fn onigiri_light(attrs: List(Attribute(a))) -> Element(a)

onigiri_regular

</> 
pub fn onigiri_regular(attrs: List(Attribute(a))) -> Element(a)

onigiri_thin

</> 
pub fn onigiri_thin(attrs: List(Attribute(a))) -> Element(a)

open_ai_logo_bold

</> 
pub fn open_ai_logo_bold(attrs: List(Attribute(a))) -> Element(a)

open_ai_logo_duotone

</> 
pub fn open_ai_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

open_ai_logo_fill

</> 
pub fn open_ai_logo_fill(attrs: List(Attribute(a))) -> Element(a)

open_ai_logo_light

</> 
pub fn open_ai_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

open_ai_logo_regular

</> 
pub fn open_ai_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

open_ai_logo_thin

</> 
pub fn open_ai_logo_thin(attrs: List(Attribute(a))) -> Element(a)

option_bold

</> 
pub fn option_bold(attrs: List(Attribute(a))) -> Element(a)

option_duotone

</> 
pub fn option_duotone(attrs: List(Attribute(a))) -> Element(a)

option_fill

</> 
pub fn option_fill(attrs: List(Attribute(a))) -> Element(a)

option_light

</> 
pub fn option_light(attrs: List(Attribute(a))) -> Element(a)

option_regular

</> 
pub fn option_regular(attrs: List(Attribute(a))) -> Element(a)

option_thin

</> 
pub fn option_thin(attrs: List(Attribute(a))) -> Element(a)

orange_bold

</> 
pub fn orange_bold(attrs: List(Attribute(a))) -> Element(a)

orange_duotone

</> 
pub fn orange_duotone(attrs: List(Attribute(a))) -> Element(a)

orange_fill

</> 
pub fn orange_fill(attrs: List(Attribute(a))) -> Element(a)

orange_light

</> 
pub fn orange_light(attrs: List(Attribute(a))) -> Element(a)

orange_regular

</> 
pub fn orange_regular(attrs: List(Attribute(a))) -> Element(a)

orange_slice_bold

</> 
pub fn orange_slice_bold(attrs: List(Attribute(a))) -> Element(a)

orange_slice_duotone

</> 
pub fn orange_slice_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

orange_slice_fill

</> 
pub fn orange_slice_fill(attrs: List(Attribute(a))) -> Element(a)

orange_slice_light

</> 
pub fn orange_slice_light(
  attrs: List(Attribute(a)),
) -> Element(a)

orange_slice_regular

</> 
pub fn orange_slice_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

orange_slice_thin

</> 
pub fn orange_slice_thin(attrs: List(Attribute(a))) -> Element(a)

orange_thin

</> 
pub fn orange_thin(attrs: List(Attribute(a))) -> Element(a)

oven_bold

</> 
pub fn oven_bold(attrs: List(Attribute(a))) -> Element(a)

oven_duotone

</> 
pub fn oven_duotone(attrs: List(Attribute(a))) -> Element(a)

oven_fill

</> 
pub fn oven_fill(attrs: List(Attribute(a))) -> Element(a)

oven_light

</> 
pub fn oven_light(attrs: List(Attribute(a))) -> Element(a)

oven_regular

</> 
pub fn oven_regular(attrs: List(Attribute(a))) -> Element(a)

oven_thin

</> 
pub fn oven_thin(attrs: List(Attribute(a))) -> Element(a)

package_bold

</> 
pub fn package_bold(attrs: List(Attribute(a))) -> Element(a)

package_duotone

</> 
pub fn package_duotone(attrs: List(Attribute(a))) -> Element(a)

package_fill

</> 
pub fn package_fill(attrs: List(Attribute(a))) -> Element(a)

package_light

</> 
pub fn package_light(attrs: List(Attribute(a))) -> Element(a)

package_regular

</> 
pub fn package_regular(attrs: List(Attribute(a))) -> Element(a)

package_thin

</> 
pub fn package_thin(attrs: List(Attribute(a))) -> Element(a)

paint_brush_bold

</> 
pub fn paint_brush_bold(attrs: List(Attribute(a))) -> Element(a)

paint_brush_broad_bold

</> 
pub fn paint_brush_broad_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_broad_duotone

</> 
pub fn paint_brush_broad_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_broad_fill

</> 
pub fn paint_brush_broad_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_broad_light

</> 
pub fn paint_brush_broad_light(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_broad_regular

</> 
pub fn paint_brush_broad_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_broad_thin

</> 
pub fn paint_brush_broad_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_duotone

</> 
pub fn paint_brush_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_fill

</> 
pub fn paint_brush_fill(attrs: List(Attribute(a))) -> Element(a)

paint_brush_household_bold

</> 
pub fn paint_brush_household_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_household_duotone

</> 
pub fn paint_brush_household_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_household_fill

</> 
pub fn paint_brush_household_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_household_light

</> 
pub fn paint_brush_household_light(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_household_regular

</> 
pub fn paint_brush_household_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_household_thin

</> 
pub fn paint_brush_household_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_light

</> 
pub fn paint_brush_light(attrs: List(Attribute(a))) -> Element(a)

paint_brush_regular

</> 
pub fn paint_brush_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_brush_thin

</> 
pub fn paint_brush_thin(attrs: List(Attribute(a))) -> Element(a)

paint_bucket_bold

</> 
pub fn paint_bucket_bold(attrs: List(Attribute(a))) -> Element(a)

paint_bucket_duotone

</> 
pub fn paint_bucket_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_bucket_fill

</> 
pub fn paint_bucket_fill(attrs: List(Attribute(a))) -> Element(a)

paint_bucket_light

</> 
pub fn paint_bucket_light(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_bucket_regular

</> 
pub fn paint_bucket_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_bucket_thin

</> 
pub fn paint_bucket_thin(attrs: List(Attribute(a))) -> Element(a)

paint_roller_bold

</> 
pub fn paint_roller_bold(attrs: List(Attribute(a))) -> Element(a)

paint_roller_duotone

</> 
pub fn paint_roller_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_roller_fill

</> 
pub fn paint_roller_fill(attrs: List(Attribute(a))) -> Element(a)

paint_roller_light

</> 
pub fn paint_roller_light(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_roller_regular

</> 
pub fn paint_roller_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

paint_roller_thin

</> 
pub fn paint_roller_thin(attrs: List(Attribute(a))) -> Element(a)

palette_bold

</> 
pub fn palette_bold(attrs: List(Attribute(a))) -> Element(a)

palette_duotone

</> 
pub fn palette_duotone(attrs: List(Attribute(a))) -> Element(a)

palette_fill

</> 
pub fn palette_fill(attrs: List(Attribute(a))) -> Element(a)

palette_light

</> 
pub fn palette_light(attrs: List(Attribute(a))) -> Element(a)

palette_regular

</> 
pub fn palette_regular(attrs: List(Attribute(a))) -> Element(a)

palette_thin

</> 
pub fn palette_thin(attrs: List(Attribute(a))) -> Element(a)

panorama_bold

</> 
pub fn panorama_bold(attrs: List(Attribute(a))) -> Element(a)

panorama_duotone

</> 
pub fn panorama_duotone(attrs: List(Attribute(a))) -> Element(a)

panorama_fill

</> 
pub fn panorama_fill(attrs: List(Attribute(a))) -> Element(a)

panorama_light

</> 
pub fn panorama_light(attrs: List(Attribute(a))) -> Element(a)

panorama_regular

</> 
pub fn panorama_regular(attrs: List(Attribute(a))) -> Element(a)

panorama_thin

</> 
pub fn panorama_thin(attrs: List(Attribute(a))) -> Element(a)

pants_bold

</> 
pub fn pants_bold(attrs: List(Attribute(a))) -> Element(a)

pants_duotone

</> 
pub fn pants_duotone(attrs: List(Attribute(a))) -> Element(a)

pants_fill

</> 
pub fn pants_fill(attrs: List(Attribute(a))) -> Element(a)

pants_light

</> 
pub fn pants_light(attrs: List(Attribute(a))) -> Element(a)

pants_regular

</> 
pub fn pants_regular(attrs: List(Attribute(a))) -> Element(a)

pants_thin

</> 
pub fn pants_thin(attrs: List(Attribute(a))) -> Element(a)

paper_plane_bold

</> 
pub fn paper_plane_bold(attrs: List(Attribute(a))) -> Element(a)

paper_plane_duotone

</> 
pub fn paper_plane_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_fill

</> 
pub fn paper_plane_fill(attrs: List(Attribute(a))) -> Element(a)

paper_plane_light

</> 
pub fn paper_plane_light(attrs: List(Attribute(a))) -> Element(a)

paper_plane_regular

</> 
pub fn paper_plane_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_right_bold

</> 
pub fn paper_plane_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_right_duotone

</> 
pub fn paper_plane_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_right_fill

</> 
pub fn paper_plane_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_right_light

</> 
pub fn paper_plane_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_right_regular

</> 
pub fn paper_plane_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_right_thin

</> 
pub fn paper_plane_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_thin

</> 
pub fn paper_plane_thin(attrs: List(Attribute(a))) -> Element(a)

paper_plane_tilt_bold

</> 
pub fn paper_plane_tilt_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_tilt_duotone

</> 
pub fn paper_plane_tilt_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_tilt_fill

</> 
pub fn paper_plane_tilt_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_tilt_light

</> 
pub fn paper_plane_tilt_light(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_tilt_regular

</> 
pub fn paper_plane_tilt_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

paper_plane_tilt_thin

</> 
pub fn paper_plane_tilt_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

paperclip_bold

</> 
pub fn paperclip_bold(attrs: List(Attribute(a))) -> Element(a)

paperclip_duotone

</> 
pub fn paperclip_duotone(attrs: List(Attribute(a))) -> Element(a)

paperclip_fill

</> 
pub fn paperclip_fill(attrs: List(Attribute(a))) -> Element(a)

paperclip_horizontal_bold

</> 
pub fn paperclip_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

paperclip_horizontal_duotone

</> 
pub fn paperclip_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

paperclip_horizontal_fill

</> 
pub fn paperclip_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

paperclip_horizontal_light

</> 
pub fn paperclip_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

paperclip_horizontal_regular

</> 
pub fn paperclip_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

paperclip_horizontal_thin

</> 
pub fn paperclip_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

paperclip_light

</> 
pub fn paperclip_light(attrs: List(Attribute(a))) -> Element(a)

paperclip_regular

</> 
pub fn paperclip_regular(attrs: List(Attribute(a))) -> Element(a)

paperclip_thin

</> 
pub fn paperclip_thin(attrs: List(Attribute(a))) -> Element(a)

parachute_bold

</> 
pub fn parachute_bold(attrs: List(Attribute(a))) -> Element(a)

parachute_duotone

</> 
pub fn parachute_duotone(attrs: List(Attribute(a))) -> Element(a)

parachute_fill

</> 
pub fn parachute_fill(attrs: List(Attribute(a))) -> Element(a)

parachute_light

</> 
pub fn parachute_light(attrs: List(Attribute(a))) -> Element(a)

parachute_regular

</> 
pub fn parachute_regular(attrs: List(Attribute(a))) -> Element(a)

parachute_thin

</> 
pub fn parachute_thin(attrs: List(Attribute(a))) -> Element(a)

paragraph_bold

</> 
pub fn paragraph_bold(attrs: List(Attribute(a))) -> Element(a)

paragraph_duotone

</> 
pub fn paragraph_duotone(attrs: List(Attribute(a))) -> Element(a)

paragraph_fill

</> 
pub fn paragraph_fill(attrs: List(Attribute(a))) -> Element(a)

paragraph_light

</> 
pub fn paragraph_light(attrs: List(Attribute(a))) -> Element(a)

paragraph_regular

</> 
pub fn paragraph_regular(attrs: List(Attribute(a))) -> Element(a)

paragraph_thin

</> 
pub fn paragraph_thin(attrs: List(Attribute(a))) -> Element(a)

parallelogram_bold

</> 
pub fn parallelogram_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

parallelogram_duotone

</> 
pub fn parallelogram_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

parallelogram_fill

</> 
pub fn parallelogram_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

parallelogram_light

</> 
pub fn parallelogram_light(
  attrs: List(Attribute(a)),
) -> Element(a)

parallelogram_regular

</> 
pub fn parallelogram_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

parallelogram_thin

</> 
pub fn parallelogram_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

park_bold

</> 
pub fn park_bold(attrs: List(Attribute(a))) -> Element(a)

park_duotone

</> 
pub fn park_duotone(attrs: List(Attribute(a))) -> Element(a)

park_fill

</> 
pub fn park_fill(attrs: List(Attribute(a))) -> Element(a)

park_light

</> 
pub fn park_light(attrs: List(Attribute(a))) -> Element(a)

park_regular

</> 
pub fn park_regular(attrs: List(Attribute(a))) -> Element(a)

park_thin

</> 
pub fn park_thin(attrs: List(Attribute(a))) -> Element(a)

password_bold

</> 
pub fn password_bold(attrs: List(Attribute(a))) -> Element(a)

password_duotone

</> 
pub fn password_duotone(attrs: List(Attribute(a))) -> Element(a)

password_fill

</> 
pub fn password_fill(attrs: List(Attribute(a))) -> Element(a)

password_light

</> 
pub fn password_light(attrs: List(Attribute(a))) -> Element(a)

password_regular

</> 
pub fn password_regular(attrs: List(Attribute(a))) -> Element(a)

password_thin

</> 
pub fn password_thin(attrs: List(Attribute(a))) -> Element(a)

path_bold

</> 
pub fn path_bold(attrs: List(Attribute(a))) -> Element(a)

path_duotone

</> 
pub fn path_duotone(attrs: List(Attribute(a))) -> Element(a)

path_fill

</> 
pub fn path_fill(attrs: List(Attribute(a))) -> Element(a)

path_light

</> 
pub fn path_light(attrs: List(Attribute(a))) -> Element(a)

path_regular

</> 
pub fn path_regular(attrs: List(Attribute(a))) -> Element(a)

path_thin

</> 
pub fn path_thin(attrs: List(Attribute(a))) -> Element(a)

patreon_logo_bold

</> 
pub fn patreon_logo_bold(attrs: List(Attribute(a))) -> Element(a)

patreon_logo_duotone

</> 
pub fn patreon_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

patreon_logo_fill

</> 
pub fn patreon_logo_fill(attrs: List(Attribute(a))) -> Element(a)

patreon_logo_light

</> 
pub fn patreon_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

patreon_logo_regular

</> 
pub fn patreon_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

patreon_logo_thin

</> 
pub fn patreon_logo_thin(attrs: List(Attribute(a))) -> Element(a)

pause_bold

</> 
pub fn pause_bold(attrs: List(Attribute(a))) -> Element(a)

pause_circle_bold

</> 
pub fn pause_circle_bold(attrs: List(Attribute(a))) -> Element(a)

pause_circle_duotone

</> 
pub fn pause_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pause_circle_fill

</> 
pub fn pause_circle_fill(attrs: List(Attribute(a))) -> Element(a)

pause_circle_light

</> 
pub fn pause_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

pause_circle_regular

</> 
pub fn pause_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pause_circle_thin

</> 
pub fn pause_circle_thin(attrs: List(Attribute(a))) -> Element(a)

pause_duotone

</> 
pub fn pause_duotone(attrs: List(Attribute(a))) -> Element(a)

pause_fill

</> 
pub fn pause_fill(attrs: List(Attribute(a))) -> Element(a)

pause_light

</> 
pub fn pause_light(attrs: List(Attribute(a))) -> Element(a)

pause_regular

</> 
pub fn pause_regular(attrs: List(Attribute(a))) -> Element(a)

pause_thin

</> 
pub fn pause_thin(attrs: List(Attribute(a))) -> Element(a)

paw_print_bold

</> 
pub fn paw_print_bold(attrs: List(Attribute(a))) -> Element(a)

paw_print_duotone

</> 
pub fn paw_print_duotone(attrs: List(Attribute(a))) -> Element(a)

paw_print_fill

</> 
pub fn paw_print_fill(attrs: List(Attribute(a))) -> Element(a)

paw_print_light

</> 
pub fn paw_print_light(attrs: List(Attribute(a))) -> Element(a)

paw_print_regular

</> 
pub fn paw_print_regular(attrs: List(Attribute(a))) -> Element(a)

paw_print_thin

</> 
pub fn paw_print_thin(attrs: List(Attribute(a))) -> Element(a)

paypal_logo_bold

</> 
pub fn paypal_logo_bold(attrs: List(Attribute(a))) -> Element(a)

paypal_logo_duotone

</> 
pub fn paypal_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

paypal_logo_fill

</> 
pub fn paypal_logo_fill(attrs: List(Attribute(a))) -> Element(a)

paypal_logo_light

</> 
pub fn paypal_logo_light(attrs: List(Attribute(a))) -> Element(a)

paypal_logo_regular

</> 
pub fn paypal_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

paypal_logo_thin

</> 
pub fn paypal_logo_thin(attrs: List(Attribute(a))) -> Element(a)

peace_bold

</> 
pub fn peace_bold(attrs: List(Attribute(a))) -> Element(a)

peace_duotone

</> 
pub fn peace_duotone(attrs: List(Attribute(a))) -> Element(a)

peace_fill

</> 
pub fn peace_fill(attrs: List(Attribute(a))) -> Element(a)

peace_light

</> 
pub fn peace_light(attrs: List(Attribute(a))) -> Element(a)

peace_regular

</> 
pub fn peace_regular(attrs: List(Attribute(a))) -> Element(a)

peace_thin

</> 
pub fn peace_thin(attrs: List(Attribute(a))) -> Element(a)

pen_bold

</> 
pub fn pen_bold(attrs: List(Attribute(a))) -> Element(a)

pen_duotone

</> 
pub fn pen_duotone(attrs: List(Attribute(a))) -> Element(a)

pen_fill

</> 
pub fn pen_fill(attrs: List(Attribute(a))) -> Element(a)

pen_light

</> 
pub fn pen_light(attrs: List(Attribute(a))) -> Element(a)

pen_nib_bold

</> 
pub fn pen_nib_bold(attrs: List(Attribute(a))) -> Element(a)

pen_nib_duotone

</> 
pub fn pen_nib_duotone(attrs: List(Attribute(a))) -> Element(a)

pen_nib_fill

</> 
pub fn pen_nib_fill(attrs: List(Attribute(a))) -> Element(a)

pen_nib_light

</> 
pub fn pen_nib_light(attrs: List(Attribute(a))) -> Element(a)

pen_nib_regular

</> 
pub fn pen_nib_regular(attrs: List(Attribute(a))) -> Element(a)

pen_nib_straight_bold

</> 
pub fn pen_nib_straight_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

pen_nib_straight_duotone

</> 
pub fn pen_nib_straight_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pen_nib_straight_fill

</> 
pub fn pen_nib_straight_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

pen_nib_straight_light

</> 
pub fn pen_nib_straight_light(
  attrs: List(Attribute(a)),
) -> Element(a)

pen_nib_straight_regular

</> 
pub fn pen_nib_straight_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pen_nib_straight_thin

</> 
pub fn pen_nib_straight_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

pen_nib_thin

</> 
pub fn pen_nib_thin(attrs: List(Attribute(a))) -> Element(a)

pen_regular

</> 
pub fn pen_regular(attrs: List(Attribute(a))) -> Element(a)

pen_thin

</> 
pub fn pen_thin(attrs: List(Attribute(a))) -> Element(a)

pencil_bold

</> 
pub fn pencil_bold(attrs: List(Attribute(a))) -> Element(a)

pencil_circle_bold

</> 
pub fn pencil_circle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_circle_duotone

</> 
pub fn pencil_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_circle_fill

</> 
pub fn pencil_circle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_circle_light

</> 
pub fn pencil_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_circle_regular

</> 
pub fn pencil_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_circle_thin

</> 
pub fn pencil_circle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_duotone

</> 
pub fn pencil_duotone(attrs: List(Attribute(a))) -> Element(a)

pencil_fill

</> 
pub fn pencil_fill(attrs: List(Attribute(a))) -> Element(a)

pencil_light

</> 
pub fn pencil_light(attrs: List(Attribute(a))) -> Element(a)

pencil_line_bold

</> 
pub fn pencil_line_bold(attrs: List(Attribute(a))) -> Element(a)

pencil_line_duotone

</> 
pub fn pencil_line_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_line_fill

</> 
pub fn pencil_line_fill(attrs: List(Attribute(a))) -> Element(a)

pencil_line_light

</> 
pub fn pencil_line_light(attrs: List(Attribute(a))) -> Element(a)

pencil_line_regular

</> 
pub fn pencil_line_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_line_thin

</> 
pub fn pencil_line_thin(attrs: List(Attribute(a))) -> Element(a)

pencil_regular

</> 
pub fn pencil_regular(attrs: List(Attribute(a))) -> Element(a)

pencil_ruler_bold

</> 
pub fn pencil_ruler_bold(attrs: List(Attribute(a))) -> Element(a)

pencil_ruler_duotone

</> 
pub fn pencil_ruler_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_ruler_fill

</> 
pub fn pencil_ruler_fill(attrs: List(Attribute(a))) -> Element(a)

pencil_ruler_light

</> 
pub fn pencil_ruler_light(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_ruler_regular

</> 
pub fn pencil_ruler_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_ruler_thin

</> 
pub fn pencil_ruler_thin(attrs: List(Attribute(a))) -> Element(a)

pencil_simple_bold

</> 
pub fn pencil_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_duotone

</> 
pub fn pencil_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_fill

</> 
pub fn pencil_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_light

</> 
pub fn pencil_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_line_bold

</> 
pub fn pencil_simple_line_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_line_duotone

</> 
pub fn pencil_simple_line_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_line_fill

</> 
pub fn pencil_simple_line_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_line_light

</> 
pub fn pencil_simple_line_light(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_line_regular

</> 
pub fn pencil_simple_line_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_line_thin

</> 
pub fn pencil_simple_line_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_regular

</> 
pub fn pencil_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_slash_bold

</> 
pub fn pencil_simple_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_slash_duotone

</> 
pub fn pencil_simple_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_slash_fill

</> 
pub fn pencil_simple_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_slash_light

</> 
pub fn pencil_simple_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_slash_regular

</> 
pub fn pencil_simple_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_slash_thin

</> 
pub fn pencil_simple_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_simple_thin

</> 
pub fn pencil_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_slash_bold

</> 
pub fn pencil_slash_bold(attrs: List(Attribute(a))) -> Element(a)

pencil_slash_duotone

</> 
pub fn pencil_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_slash_fill

</> 
pub fn pencil_slash_fill(attrs: List(Attribute(a))) -> Element(a)

pencil_slash_light

</> 
pub fn pencil_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_slash_regular

</> 
pub fn pencil_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pencil_slash_thin

</> 
pub fn pencil_slash_thin(attrs: List(Attribute(a))) -> Element(a)

pencil_thin

</> 
pub fn pencil_thin(attrs: List(Attribute(a))) -> Element(a)

pentagon_bold

</> 
pub fn pentagon_bold(attrs: List(Attribute(a))) -> Element(a)

pentagon_duotone

</> 
pub fn pentagon_duotone(attrs: List(Attribute(a))) -> Element(a)

pentagon_fill

</> 
pub fn pentagon_fill(attrs: List(Attribute(a))) -> Element(a)

pentagon_light

</> 
pub fn pentagon_light(attrs: List(Attribute(a))) -> Element(a)

pentagon_regular

</> 
pub fn pentagon_regular(attrs: List(Attribute(a))) -> Element(a)

pentagon_thin

</> 
pub fn pentagon_thin(attrs: List(Attribute(a))) -> Element(a)

pentagram_bold

</> 
pub fn pentagram_bold(attrs: List(Attribute(a))) -> Element(a)

pentagram_duotone

</> 
pub fn pentagram_duotone(attrs: List(Attribute(a))) -> Element(a)

pentagram_fill

</> 
pub fn pentagram_fill(attrs: List(Attribute(a))) -> Element(a)

pentagram_light

</> 
pub fn pentagram_light(attrs: List(Attribute(a))) -> Element(a)

pentagram_regular

</> 
pub fn pentagram_regular(attrs: List(Attribute(a))) -> Element(a)

pentagram_thin

</> 
pub fn pentagram_thin(attrs: List(Attribute(a))) -> Element(a)

pepper_bold

</> 
pub fn pepper_bold(attrs: List(Attribute(a))) -> Element(a)

pepper_duotone

</> 
pub fn pepper_duotone(attrs: List(Attribute(a))) -> Element(a)

pepper_fill

</> 
pub fn pepper_fill(attrs: List(Attribute(a))) -> Element(a)

pepper_light

</> 
pub fn pepper_light(attrs: List(Attribute(a))) -> Element(a)

pepper_regular

</> 
pub fn pepper_regular(attrs: List(Attribute(a))) -> Element(a)

pepper_thin

</> 
pub fn pepper_thin(attrs: List(Attribute(a))) -> Element(a)

percent_bold

</> 
pub fn percent_bold(attrs: List(Attribute(a))) -> Element(a)

percent_duotone

</> 
pub fn percent_duotone(attrs: List(Attribute(a))) -> Element(a)

percent_fill

</> 
pub fn percent_fill(attrs: List(Attribute(a))) -> Element(a)

percent_light

</> 
pub fn percent_light(attrs: List(Attribute(a))) -> Element(a)

percent_regular

</> 
pub fn percent_regular(attrs: List(Attribute(a))) -> Element(a)

percent_thin

</> 
pub fn percent_thin(attrs: List(Attribute(a))) -> Element(a)

person_arms_spread_bold

</> 
pub fn person_arms_spread_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_arms_spread_duotone

</> 
pub fn person_arms_spread_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_arms_spread_fill

</> 
pub fn person_arms_spread_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_arms_spread_light

</> 
pub fn person_arms_spread_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_arms_spread_regular

</> 
pub fn person_arms_spread_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_arms_spread_thin

</> 
pub fn person_arms_spread_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_bold

</> 
pub fn person_bold(attrs: List(Attribute(a))) -> Element(a)

person_duotone

</> 
pub fn person_duotone(attrs: List(Attribute(a))) -> Element(a)

person_fill

</> 
pub fn person_fill(attrs: List(Attribute(a))) -> Element(a)

person_light

</> 
pub fn person_light(attrs: List(Attribute(a))) -> Element(a)

person_regular

</> 
pub fn person_regular(attrs: List(Attribute(a))) -> Element(a)

person_simple_bike_bold

</> 
pub fn person_simple_bike_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_bike_duotone

</> 
pub fn person_simple_bike_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_bike_fill

</> 
pub fn person_simple_bike_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_bike_light

</> 
pub fn person_simple_bike_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_bike_regular

</> 
pub fn person_simple_bike_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_bike_thin

</> 
pub fn person_simple_bike_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_bold

</> 
pub fn person_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_circle_bold

</> 
pub fn person_simple_circle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_circle_duotone

</> 
pub fn person_simple_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_circle_fill

</> 
pub fn person_simple_circle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_circle_light

</> 
pub fn person_simple_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_circle_regular

</> 
pub fn person_simple_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_circle_thin

</> 
pub fn person_simple_circle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_duotone

</> 
pub fn person_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_fill

</> 
pub fn person_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_hike_bold

</> 
pub fn person_simple_hike_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_hike_duotone

</> 
pub fn person_simple_hike_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_hike_fill

</> 
pub fn person_simple_hike_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_hike_light

</> 
pub fn person_simple_hike_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_hike_regular

</> 
pub fn person_simple_hike_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_hike_thin

</> 
pub fn person_simple_hike_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_light

</> 
pub fn person_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_regular

</> 
pub fn person_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_run_bold

</> 
pub fn person_simple_run_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_run_duotone

</> 
pub fn person_simple_run_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_run_fill

</> 
pub fn person_simple_run_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_run_light

</> 
pub fn person_simple_run_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_run_regular

</> 
pub fn person_simple_run_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_run_thin

</> 
pub fn person_simple_run_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_ski_bold

</> 
pub fn person_simple_ski_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_ski_duotone

</> 
pub fn person_simple_ski_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_ski_fill

</> 
pub fn person_simple_ski_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_ski_light

</> 
pub fn person_simple_ski_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_ski_regular

</> 
pub fn person_simple_ski_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_ski_thin

</> 
pub fn person_simple_ski_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_snowboard_bold

</> 
pub fn person_simple_snowboard_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_snowboard_duotone

</> 
pub fn person_simple_snowboard_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_snowboard_fill

</> 
pub fn person_simple_snowboard_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_snowboard_light

</> 
pub fn person_simple_snowboard_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_snowboard_regular

</> 
pub fn person_simple_snowboard_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_snowboard_thin

</> 
pub fn person_simple_snowboard_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_swim_bold

</> 
pub fn person_simple_swim_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_swim_duotone

</> 
pub fn person_simple_swim_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_swim_fill

</> 
pub fn person_simple_swim_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_swim_light

</> 
pub fn person_simple_swim_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_swim_regular

</> 
pub fn person_simple_swim_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_swim_thin

</> 
pub fn person_simple_swim_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_tai_chi_bold

</> 
pub fn person_simple_tai_chi_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_tai_chi_duotone

</> 
pub fn person_simple_tai_chi_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_tai_chi_fill

</> 
pub fn person_simple_tai_chi_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_tai_chi_light

</> 
pub fn person_simple_tai_chi_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_tai_chi_regular

</> 
pub fn person_simple_tai_chi_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_tai_chi_thin

</> 
pub fn person_simple_tai_chi_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_thin

</> 
pub fn person_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_throw_bold

</> 
pub fn person_simple_throw_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_throw_duotone

</> 
pub fn person_simple_throw_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_throw_fill

</> 
pub fn person_simple_throw_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_throw_light

</> 
pub fn person_simple_throw_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_throw_regular

</> 
pub fn person_simple_throw_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_throw_thin

</> 
pub fn person_simple_throw_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_walk_bold

</> 
pub fn person_simple_walk_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_walk_duotone

</> 
pub fn person_simple_walk_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_walk_fill

</> 
pub fn person_simple_walk_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_walk_light

</> 
pub fn person_simple_walk_light(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_walk_regular

</> 
pub fn person_simple_walk_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

person_simple_walk_thin

</> 
pub fn person_simple_walk_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

person_thin

</> 
pub fn person_thin(attrs: List(Attribute(a))) -> Element(a)

perspective_bold

</> 
pub fn perspective_bold(attrs: List(Attribute(a))) -> Element(a)

perspective_duotone

</> 
pub fn perspective_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

perspective_fill

</> 
pub fn perspective_fill(attrs: List(Attribute(a))) -> Element(a)

perspective_light

</> 
pub fn perspective_light(attrs: List(Attribute(a))) -> Element(a)

perspective_regular

</> 
pub fn perspective_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

perspective_thin

</> 
pub fn perspective_thin(attrs: List(Attribute(a))) -> Element(a)

phone_bold

</> 
pub fn phone_bold(attrs: List(Attribute(a))) -> Element(a)

phone_call_bold

</> 
pub fn phone_call_bold(attrs: List(Attribute(a))) -> Element(a)

phone_call_duotone

</> 
pub fn phone_call_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_call_fill

</> 
pub fn phone_call_fill(attrs: List(Attribute(a))) -> Element(a)

phone_call_light

</> 
pub fn phone_call_light(attrs: List(Attribute(a))) -> Element(a)

phone_call_regular

</> 
pub fn phone_call_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_call_thin

</> 
pub fn phone_call_thin(attrs: List(Attribute(a))) -> Element(a)

phone_disconnect_bold

</> 
pub fn phone_disconnect_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_disconnect_duotone

</> 
pub fn phone_disconnect_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_disconnect_fill

</> 
pub fn phone_disconnect_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_disconnect_light

</> 
pub fn phone_disconnect_light(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_disconnect_regular

</> 
pub fn phone_disconnect_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_disconnect_thin

</> 
pub fn phone_disconnect_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_duotone

</> 
pub fn phone_duotone(attrs: List(Attribute(a))) -> Element(a)

phone_fill

</> 
pub fn phone_fill(attrs: List(Attribute(a))) -> Element(a)

phone_incoming_bold

</> 
pub fn phone_incoming_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_incoming_duotone

</> 
pub fn phone_incoming_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_incoming_fill

</> 
pub fn phone_incoming_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_incoming_light

</> 
pub fn phone_incoming_light(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_incoming_regular

</> 
pub fn phone_incoming_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_incoming_thin

</> 
pub fn phone_incoming_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_light

</> 
pub fn phone_light(attrs: List(Attribute(a))) -> Element(a)

phone_list_bold

</> 
pub fn phone_list_bold(attrs: List(Attribute(a))) -> Element(a)

phone_list_duotone

</> 
pub fn phone_list_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_list_fill

</> 
pub fn phone_list_fill(attrs: List(Attribute(a))) -> Element(a)

phone_list_light

</> 
pub fn phone_list_light(attrs: List(Attribute(a))) -> Element(a)

phone_list_regular

</> 
pub fn phone_list_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_list_thin

</> 
pub fn phone_list_thin(attrs: List(Attribute(a))) -> Element(a)

phone_outgoing_bold

</> 
pub fn phone_outgoing_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_outgoing_duotone

</> 
pub fn phone_outgoing_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_outgoing_fill

</> 
pub fn phone_outgoing_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_outgoing_light

</> 
pub fn phone_outgoing_light(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_outgoing_regular

</> 
pub fn phone_outgoing_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_outgoing_thin

</> 
pub fn phone_outgoing_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_pause_bold

</> 
pub fn phone_pause_bold(attrs: List(Attribute(a))) -> Element(a)

phone_pause_duotone

</> 
pub fn phone_pause_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_pause_fill

</> 
pub fn phone_pause_fill(attrs: List(Attribute(a))) -> Element(a)

phone_pause_light

</> 
pub fn phone_pause_light(attrs: List(Attribute(a))) -> Element(a)

phone_pause_regular

</> 
pub fn phone_pause_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_pause_thin

</> 
pub fn phone_pause_thin(attrs: List(Attribute(a))) -> Element(a)

phone_plus_bold

</> 
pub fn phone_plus_bold(attrs: List(Attribute(a))) -> Element(a)

phone_plus_duotone

</> 
pub fn phone_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_plus_fill

</> 
pub fn phone_plus_fill(attrs: List(Attribute(a))) -> Element(a)

phone_plus_light

</> 
pub fn phone_plus_light(attrs: List(Attribute(a))) -> Element(a)

phone_plus_regular

</> 
pub fn phone_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_plus_thin

</> 
pub fn phone_plus_thin(attrs: List(Attribute(a))) -> Element(a)

phone_regular

</> 
pub fn phone_regular(attrs: List(Attribute(a))) -> Element(a)

phone_slash_bold

</> 
pub fn phone_slash_bold(attrs: List(Attribute(a))) -> Element(a)

phone_slash_duotone

</> 
pub fn phone_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_slash_fill

</> 
pub fn phone_slash_fill(attrs: List(Attribute(a))) -> Element(a)

phone_slash_light

</> 
pub fn phone_slash_light(attrs: List(Attribute(a))) -> Element(a)

phone_slash_regular

</> 
pub fn phone_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_slash_thin

</> 
pub fn phone_slash_thin(attrs: List(Attribute(a))) -> Element(a)

phone_thin

</> 
pub fn phone_thin(attrs: List(Attribute(a))) -> Element(a)

phone_transfer_bold

</> 
pub fn phone_transfer_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_transfer_duotone

</> 
pub fn phone_transfer_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_transfer_fill

</> 
pub fn phone_transfer_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_transfer_light

</> 
pub fn phone_transfer_light(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_transfer_regular

</> 
pub fn phone_transfer_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_transfer_thin

</> 
pub fn phone_transfer_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

phone_x_bold

</> 
pub fn phone_x_bold(attrs: List(Attribute(a))) -> Element(a)

phone_x_duotone

</> 
pub fn phone_x_duotone(attrs: List(Attribute(a))) -> Element(a)

phone_x_fill

</> 
pub fn phone_x_fill(attrs: List(Attribute(a))) -> Element(a)

phone_x_light

</> 
pub fn phone_x_light(attrs: List(Attribute(a))) -> Element(a)

phone_x_regular

</> 
pub fn phone_x_regular(attrs: List(Attribute(a))) -> Element(a)

phone_x_thin

</> 
pub fn phone_x_thin(attrs: List(Attribute(a))) -> Element(a)

phosphor_logo_bold

</> 
pub fn phosphor_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

phosphor_logo_duotone

</> 
pub fn phosphor_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

phosphor_logo_fill

</> 
pub fn phosphor_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

phosphor_logo_light

</> 
pub fn phosphor_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

phosphor_logo_regular

</> 
pub fn phosphor_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

phosphor_logo_thin

</> 
pub fn phosphor_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

pi_bold

</> 
pub fn pi_bold(attrs: List(Attribute(a))) -> Element(a)

pi_duotone

</> 
pub fn pi_duotone(attrs: List(Attribute(a))) -> Element(a)

pi_fill

</> 
pub fn pi_fill(attrs: List(Attribute(a))) -> Element(a)

pi_light

</> 
pub fn pi_light(attrs: List(Attribute(a))) -> Element(a)

pi_regular

</> 
pub fn pi_regular(attrs: List(Attribute(a))) -> Element(a)

pi_thin

</> 
pub fn pi_thin(attrs: List(Attribute(a))) -> Element(a)

piano_keys_bold

</> 
pub fn piano_keys_bold(attrs: List(Attribute(a))) -> Element(a)

piano_keys_duotone

</> 
pub fn piano_keys_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

piano_keys_fill

</> 
pub fn piano_keys_fill(attrs: List(Attribute(a))) -> Element(a)

piano_keys_light

</> 
pub fn piano_keys_light(attrs: List(Attribute(a))) -> Element(a)

piano_keys_regular

</> 
pub fn piano_keys_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

piano_keys_thin

</> 
pub fn piano_keys_thin(attrs: List(Attribute(a))) -> Element(a)

picnic_table_bold

</> 
pub fn picnic_table_bold(attrs: List(Attribute(a))) -> Element(a)

picnic_table_duotone

</> 
pub fn picnic_table_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

picnic_table_fill

</> 
pub fn picnic_table_fill(attrs: List(Attribute(a))) -> Element(a)

picnic_table_light

</> 
pub fn picnic_table_light(
  attrs: List(Attribute(a)),
) -> Element(a)

picnic_table_regular

</> 
pub fn picnic_table_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

picnic_table_thin

</> 
pub fn picnic_table_thin(attrs: List(Attribute(a))) -> Element(a)

picture_in_picture_bold

</> 
pub fn picture_in_picture_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

picture_in_picture_duotone

</> 
pub fn picture_in_picture_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

picture_in_picture_fill

</> 
pub fn picture_in_picture_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

picture_in_picture_light

</> 
pub fn picture_in_picture_light(
  attrs: List(Attribute(a)),
) -> Element(a)

picture_in_picture_regular

</> 
pub fn picture_in_picture_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

picture_in_picture_thin

</> 
pub fn picture_in_picture_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

piggy_bank_bold

</> 
pub fn piggy_bank_bold(attrs: List(Attribute(a))) -> Element(a)

piggy_bank_duotone

</> 
pub fn piggy_bank_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

piggy_bank_fill

</> 
pub fn piggy_bank_fill(attrs: List(Attribute(a))) -> Element(a)

piggy_bank_light

</> 
pub fn piggy_bank_light(attrs: List(Attribute(a))) -> Element(a)

piggy_bank_regular

</> 
pub fn piggy_bank_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

piggy_bank_thin

</> 
pub fn piggy_bank_thin(attrs: List(Attribute(a))) -> Element(a)

pill_bold

</> 
pub fn pill_bold(attrs: List(Attribute(a))) -> Element(a)

pill_duotone

</> 
pub fn pill_duotone(attrs: List(Attribute(a))) -> Element(a)

pill_fill

</> 
pub fn pill_fill(attrs: List(Attribute(a))) -> Element(a)

pill_light

</> 
pub fn pill_light(attrs: List(Attribute(a))) -> Element(a)

pill_regular

</> 
pub fn pill_regular(attrs: List(Attribute(a))) -> Element(a)

pill_thin

</> 
pub fn pill_thin(attrs: List(Attribute(a))) -> Element(a)

ping_pong_bold

</> 
pub fn ping_pong_bold(attrs: List(Attribute(a))) -> Element(a)

ping_pong_duotone

</> 
pub fn ping_pong_duotone(attrs: List(Attribute(a))) -> Element(a)

ping_pong_fill

</> 
pub fn ping_pong_fill(attrs: List(Attribute(a))) -> Element(a)

ping_pong_light

</> 
pub fn ping_pong_light(attrs: List(Attribute(a))) -> Element(a)

ping_pong_regular

</> 
pub fn ping_pong_regular(attrs: List(Attribute(a))) -> Element(a)

ping_pong_thin

</> 
pub fn ping_pong_thin(attrs: List(Attribute(a))) -> Element(a)

pint_glass_bold

</> 
pub fn pint_glass_bold(attrs: List(Attribute(a))) -> Element(a)

pint_glass_duotone

</> 
pub fn pint_glass_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pint_glass_fill

</> 
pub fn pint_glass_fill(attrs: List(Attribute(a))) -> Element(a)

pint_glass_light

</> 
pub fn pint_glass_light(attrs: List(Attribute(a))) -> Element(a)

pint_glass_regular

</> 
pub fn pint_glass_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pint_glass_thin

</> 
pub fn pint_glass_thin(attrs: List(Attribute(a))) -> Element(a)

pinterest_logo_bold

</> 
pub fn pinterest_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

pinterest_logo_duotone

</> 
pub fn pinterest_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pinterest_logo_fill

</> 
pub fn pinterest_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

pinterest_logo_light

</> 
pub fn pinterest_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

pinterest_logo_regular

</> 
pub fn pinterest_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pinterest_logo_thin

</> 
pub fn pinterest_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

pinwheel_bold

</> 
pub fn pinwheel_bold(attrs: List(Attribute(a))) -> Element(a)

pinwheel_duotone

</> 
pub fn pinwheel_duotone(attrs: List(Attribute(a))) -> Element(a)

pinwheel_fill

</> 
pub fn pinwheel_fill(attrs: List(Attribute(a))) -> Element(a)

pinwheel_light

</> 
pub fn pinwheel_light(attrs: List(Attribute(a))) -> Element(a)

pinwheel_regular

</> 
pub fn pinwheel_regular(attrs: List(Attribute(a))) -> Element(a)

pinwheel_thin

</> 
pub fn pinwheel_thin(attrs: List(Attribute(a))) -> Element(a)

pipe_bold

</> 
pub fn pipe_bold(attrs: List(Attribute(a))) -> Element(a)

pipe_duotone

</> 
pub fn pipe_duotone(attrs: List(Attribute(a))) -> Element(a)

pipe_fill

</> 
pub fn pipe_fill(attrs: List(Attribute(a))) -> Element(a)

pipe_light

</> 
pub fn pipe_light(attrs: List(Attribute(a))) -> Element(a)

pipe_regular

</> 
pub fn pipe_regular(attrs: List(Attribute(a))) -> Element(a)

pipe_thin

</> 
pub fn pipe_thin(attrs: List(Attribute(a))) -> Element(a)

pipe_wrench_bold

</> 
pub fn pipe_wrench_bold(attrs: List(Attribute(a))) -> Element(a)

pipe_wrench_duotone

</> 
pub fn pipe_wrench_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

pipe_wrench_fill

</> 
pub fn pipe_wrench_fill(attrs: List(Attribute(a))) -> Element(a)

pipe_wrench_light

</> 
pub fn pipe_wrench_light(attrs: List(Attribute(a))) -> Element(a)

pipe_wrench_regular

</> 
pub fn pipe_wrench_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

pipe_wrench_thin

</> 
pub fn pipe_wrench_thin(attrs: List(Attribute(a))) -> Element(a)

pix_logo_bold

</> 
pub fn pix_logo_bold(attrs: List(Attribute(a))) -> Element(a)

pix_logo_duotone

</> 
pub fn pix_logo_duotone(attrs: List(Attribute(a))) -> Element(a)

pix_logo_fill

</> 
pub fn pix_logo_fill(attrs: List(Attribute(a))) -> Element(a)

pix_logo_light

</> 
pub fn pix_logo_light(attrs: List(Attribute(a))) -> Element(a)

pix_logo_regular

</> 
pub fn pix_logo_regular(attrs: List(Attribute(a))) -> Element(a)

pix_logo_thin

</> 
pub fn pix_logo_thin(attrs: List(Attribute(a))) -> Element(a)

pizza_bold

</> 
pub fn pizza_bold(attrs: List(Attribute(a))) -> Element(a)

pizza_duotone

</> 
pub fn pizza_duotone(attrs: List(Attribute(a))) -> Element(a)

pizza_fill

</> 
pub fn pizza_fill(attrs: List(Attribute(a))) -> Element(a)

pizza_light

</> 
pub fn pizza_light(attrs: List(Attribute(a))) -> Element(a)

pizza_regular

</> 
pub fn pizza_regular(attrs: List(Attribute(a))) -> Element(a)

pizza_thin

</> 
pub fn pizza_thin(attrs: List(Attribute(a))) -> Element(a)

placeholder_bold

</> 
pub fn placeholder_bold(attrs: List(Attribute(a))) -> Element(a)

placeholder_duotone

</> 
pub fn placeholder_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

placeholder_fill

</> 
pub fn placeholder_fill(attrs: List(Attribute(a))) -> Element(a)

placeholder_light

</> 
pub fn placeholder_light(attrs: List(Attribute(a))) -> Element(a)

placeholder_regular

</> 
pub fn placeholder_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

placeholder_thin

</> 
pub fn placeholder_thin(attrs: List(Attribute(a))) -> Element(a)

planet_bold

</> 
pub fn planet_bold(attrs: List(Attribute(a))) -> Element(a)

planet_duotone

</> 
pub fn planet_duotone(attrs: List(Attribute(a))) -> Element(a)

planet_fill

</> 
pub fn planet_fill(attrs: List(Attribute(a))) -> Element(a)

planet_light

</> 
pub fn planet_light(attrs: List(Attribute(a))) -> Element(a)

planet_regular

</> 
pub fn planet_regular(attrs: List(Attribute(a))) -> Element(a)

planet_thin

</> 
pub fn planet_thin(attrs: List(Attribute(a))) -> Element(a)

plant_bold

</> 
pub fn plant_bold(attrs: List(Attribute(a))) -> Element(a)

plant_duotone

</> 
pub fn plant_duotone(attrs: List(Attribute(a))) -> Element(a)

plant_fill

</> 
pub fn plant_fill(attrs: List(Attribute(a))) -> Element(a)

plant_light

</> 
pub fn plant_light(attrs: List(Attribute(a))) -> Element(a)

plant_regular

</> 
pub fn plant_regular(attrs: List(Attribute(a))) -> Element(a)

plant_thin

</> 
pub fn plant_thin(attrs: List(Attribute(a))) -> Element(a)

play_bold

</> 
pub fn play_bold(attrs: List(Attribute(a))) -> Element(a)

play_circle_bold

</> 
pub fn play_circle_bold(attrs: List(Attribute(a))) -> Element(a)

play_circle_duotone

</> 
pub fn play_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

play_circle_fill

</> 
pub fn play_circle_fill(attrs: List(Attribute(a))) -> Element(a)

play_circle_light

</> 
pub fn play_circle_light(attrs: List(Attribute(a))) -> Element(a)

play_circle_regular

</> 
pub fn play_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

play_circle_thin

</> 
pub fn play_circle_thin(attrs: List(Attribute(a))) -> Element(a)

play_duotone

</> 
pub fn play_duotone(attrs: List(Attribute(a))) -> Element(a)

play_fill

</> 
pub fn play_fill(attrs: List(Attribute(a))) -> Element(a)

play_light

</> 
pub fn play_light(attrs: List(Attribute(a))) -> Element(a)

play_pause_bold

</> 
pub fn play_pause_bold(attrs: List(Attribute(a))) -> Element(a)

play_pause_duotone

</> 
pub fn play_pause_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

play_pause_fill

</> 
pub fn play_pause_fill(attrs: List(Attribute(a))) -> Element(a)

play_pause_light

</> 
pub fn play_pause_light(attrs: List(Attribute(a))) -> Element(a)

play_pause_regular

</> 
pub fn play_pause_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

play_pause_thin

</> 
pub fn play_pause_thin(attrs: List(Attribute(a))) -> Element(a)

play_regular

</> 
pub fn play_regular(attrs: List(Attribute(a))) -> Element(a)

play_thin

</> 
pub fn play_thin(attrs: List(Attribute(a))) -> Element(a)

playlist_bold

</> 
pub fn playlist_bold(attrs: List(Attribute(a))) -> Element(a)

playlist_duotone

</> 
pub fn playlist_duotone(attrs: List(Attribute(a))) -> Element(a)

playlist_fill

</> 
pub fn playlist_fill(attrs: List(Attribute(a))) -> Element(a)

playlist_light

</> 
pub fn playlist_light(attrs: List(Attribute(a))) -> Element(a)

playlist_regular

</> 
pub fn playlist_regular(attrs: List(Attribute(a))) -> Element(a)

playlist_thin

</> 
pub fn playlist_thin(attrs: List(Attribute(a))) -> Element(a)

plug_bold

</> 
pub fn plug_bold(attrs: List(Attribute(a))) -> Element(a)

plug_charging_bold

</> 
pub fn plug_charging_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

plug_charging_duotone

</> 
pub fn plug_charging_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

plug_charging_fill

</> 
pub fn plug_charging_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

plug_charging_light

</> 
pub fn plug_charging_light(
  attrs: List(Attribute(a)),
) -> Element(a)

plug_charging_regular

</> 
pub fn plug_charging_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

plug_charging_thin

</> 
pub fn plug_charging_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

plug_duotone

</> 
pub fn plug_duotone(attrs: List(Attribute(a))) -> Element(a)

plug_fill

</> 
pub fn plug_fill(attrs: List(Attribute(a))) -> Element(a)

plug_light

</> 
pub fn plug_light(attrs: List(Attribute(a))) -> Element(a)

plug_regular

</> 
pub fn plug_regular(attrs: List(Attribute(a))) -> Element(a)

plug_thin

</> 
pub fn plug_thin(attrs: List(Attribute(a))) -> Element(a)

plugs_bold

</> 
pub fn plugs_bold(attrs: List(Attribute(a))) -> Element(a)

plugs_connected_bold

</> 
pub fn plugs_connected_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

plugs_connected_duotone

</> 
pub fn plugs_connected_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

plugs_connected_fill

</> 
pub fn plugs_connected_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

plugs_connected_light

</> 
pub fn plugs_connected_light(
  attrs: List(Attribute(a)),
) -> Element(a)

plugs_connected_regular

</> 
pub fn plugs_connected_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

plugs_connected_thin

</> 
pub fn plugs_connected_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

plugs_duotone

</> 
pub fn plugs_duotone(attrs: List(Attribute(a))) -> Element(a)

plugs_fill

</> 
pub fn plugs_fill(attrs: List(Attribute(a))) -> Element(a)

plugs_light

</> 
pub fn plugs_light(attrs: List(Attribute(a))) -> Element(a)

plugs_regular

</> 
pub fn plugs_regular(attrs: List(Attribute(a))) -> Element(a)

plugs_thin

</> 
pub fn plugs_thin(attrs: List(Attribute(a))) -> Element(a)

plus_bold

</> 
pub fn plus_bold(attrs: List(Attribute(a))) -> Element(a)

plus_circle_bold

</> 
pub fn plus_circle_bold(attrs: List(Attribute(a))) -> Element(a)

plus_circle_duotone

</> 
pub fn plus_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

plus_circle_fill

</> 
pub fn plus_circle_fill(attrs: List(Attribute(a))) -> Element(a)

plus_circle_light

</> 
pub fn plus_circle_light(attrs: List(Attribute(a))) -> Element(a)

plus_circle_regular

</> 
pub fn plus_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

plus_circle_thin

</> 
pub fn plus_circle_thin(attrs: List(Attribute(a))) -> Element(a)

plus_duotone

</> 
pub fn plus_duotone(attrs: List(Attribute(a))) -> Element(a)

plus_fill

</> 
pub fn plus_fill(attrs: List(Attribute(a))) -> Element(a)

plus_light

</> 
pub fn plus_light(attrs: List(Attribute(a))) -> Element(a)

plus_minus_bold

</> 
pub fn plus_minus_bold(attrs: List(Attribute(a))) -> Element(a)

plus_minus_duotone

</> 
pub fn plus_minus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

plus_minus_fill

</> 
pub fn plus_minus_fill(attrs: List(Attribute(a))) -> Element(a)

plus_minus_light

</> 
pub fn plus_minus_light(attrs: List(Attribute(a))) -> Element(a)

plus_minus_regular

</> 
pub fn plus_minus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

plus_minus_thin

</> 
pub fn plus_minus_thin(attrs: List(Attribute(a))) -> Element(a)

plus_regular

</> 
pub fn plus_regular(attrs: List(Attribute(a))) -> Element(a)

plus_square_bold

</> 
pub fn plus_square_bold(attrs: List(Attribute(a))) -> Element(a)

plus_square_duotone

</> 
pub fn plus_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

plus_square_fill

</> 
pub fn plus_square_fill(attrs: List(Attribute(a))) -> Element(a)

plus_square_light

</> 
pub fn plus_square_light(attrs: List(Attribute(a))) -> Element(a)

plus_square_regular

</> 
pub fn plus_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

plus_square_thin

</> 
pub fn plus_square_thin(attrs: List(Attribute(a))) -> Element(a)

plus_thin

</> 
pub fn plus_thin(attrs: List(Attribute(a))) -> Element(a)

poker_chip_bold

</> 
pub fn poker_chip_bold(attrs: List(Attribute(a))) -> Element(a)

poker_chip_duotone

</> 
pub fn poker_chip_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

poker_chip_fill

</> 
pub fn poker_chip_fill(attrs: List(Attribute(a))) -> Element(a)

poker_chip_light

</> 
pub fn poker_chip_light(attrs: List(Attribute(a))) -> Element(a)

poker_chip_regular

</> 
pub fn poker_chip_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

poker_chip_thin

</> 
pub fn poker_chip_thin(attrs: List(Attribute(a))) -> Element(a)

police_car_bold

</> 
pub fn police_car_bold(attrs: List(Attribute(a))) -> Element(a)

police_car_duotone

</> 
pub fn police_car_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

police_car_fill

</> 
pub fn police_car_fill(attrs: List(Attribute(a))) -> Element(a)

police_car_light

</> 
pub fn police_car_light(attrs: List(Attribute(a))) -> Element(a)

police_car_regular

</> 
pub fn police_car_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

police_car_thin

</> 
pub fn police_car_thin(attrs: List(Attribute(a))) -> Element(a)

polygon_bold

</> 
pub fn polygon_bold(attrs: List(Attribute(a))) -> Element(a)

polygon_duotone

</> 
pub fn polygon_duotone(attrs: List(Attribute(a))) -> Element(a)

polygon_fill

</> 
pub fn polygon_fill(attrs: List(Attribute(a))) -> Element(a)

polygon_light

</> 
pub fn polygon_light(attrs: List(Attribute(a))) -> Element(a)

polygon_regular

</> 
pub fn polygon_regular(attrs: List(Attribute(a))) -> Element(a)

polygon_thin

</> 
pub fn polygon_thin(attrs: List(Attribute(a))) -> Element(a)

popcorn_bold

</> 
pub fn popcorn_bold(attrs: List(Attribute(a))) -> Element(a)

popcorn_duotone

</> 
pub fn popcorn_duotone(attrs: List(Attribute(a))) -> Element(a)

popcorn_fill

</> 
pub fn popcorn_fill(attrs: List(Attribute(a))) -> Element(a)

popcorn_light

</> 
pub fn popcorn_light(attrs: List(Attribute(a))) -> Element(a)

popcorn_regular

</> 
pub fn popcorn_regular(attrs: List(Attribute(a))) -> Element(a)

popcorn_thin

</> 
pub fn popcorn_thin(attrs: List(Attribute(a))) -> Element(a)

popsicle_bold

</> 
pub fn popsicle_bold(attrs: List(Attribute(a))) -> Element(a)

popsicle_duotone

</> 
pub fn popsicle_duotone(attrs: List(Attribute(a))) -> Element(a)

popsicle_fill

</> 
pub fn popsicle_fill(attrs: List(Attribute(a))) -> Element(a)

popsicle_light

</> 
pub fn popsicle_light(attrs: List(Attribute(a))) -> Element(a)

popsicle_regular

</> 
pub fn popsicle_regular(attrs: List(Attribute(a))) -> Element(a)

popsicle_thin

</> 
pub fn popsicle_thin(attrs: List(Attribute(a))) -> Element(a)

potted_plant_bold

</> 
pub fn potted_plant_bold(attrs: List(Attribute(a))) -> Element(a)

potted_plant_duotone

</> 
pub fn potted_plant_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

potted_plant_fill

</> 
pub fn potted_plant_fill(attrs: List(Attribute(a))) -> Element(a)

potted_plant_light

</> 
pub fn potted_plant_light(
  attrs: List(Attribute(a)),
) -> Element(a)

potted_plant_regular

</> 
pub fn potted_plant_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

potted_plant_thin

</> 
pub fn potted_plant_thin(attrs: List(Attribute(a))) -> Element(a)

power_bold

</> 
pub fn power_bold(attrs: List(Attribute(a))) -> Element(a)

power_duotone

</> 
pub fn power_duotone(attrs: List(Attribute(a))) -> Element(a)

power_fill

</> 
pub fn power_fill(attrs: List(Attribute(a))) -> Element(a)

power_light

</> 
pub fn power_light(attrs: List(Attribute(a))) -> Element(a)

power_regular

</> 
pub fn power_regular(attrs: List(Attribute(a))) -> Element(a)

power_thin

</> 
pub fn power_thin(attrs: List(Attribute(a))) -> Element(a)

prescription_bold

</> 
pub fn prescription_bold(attrs: List(Attribute(a))) -> Element(a)

prescription_duotone

</> 
pub fn prescription_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

prescription_fill

</> 
pub fn prescription_fill(attrs: List(Attribute(a))) -> Element(a)

prescription_light

</> 
pub fn prescription_light(
  attrs: List(Attribute(a)),
) -> Element(a)

prescription_regular

</> 
pub fn prescription_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

prescription_thin

</> 
pub fn prescription_thin(attrs: List(Attribute(a))) -> Element(a)

presentation_bold

</> 
pub fn presentation_bold(attrs: List(Attribute(a))) -> Element(a)

presentation_chart_bold

</> 
pub fn presentation_chart_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

presentation_chart_duotone

</> 
pub fn presentation_chart_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

presentation_chart_fill

</> 
pub fn presentation_chart_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

presentation_chart_light

</> 
pub fn presentation_chart_light(
  attrs: List(Attribute(a)),
) -> Element(a)

presentation_chart_regular

</> 
pub fn presentation_chart_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

presentation_chart_thin

</> 
pub fn presentation_chart_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

presentation_duotone

</> 
pub fn presentation_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

presentation_fill

</> 
pub fn presentation_fill(attrs: List(Attribute(a))) -> Element(a)

presentation_light

</> 
pub fn presentation_light(
  attrs: List(Attribute(a)),
) -> Element(a)

presentation_regular

</> 
pub fn presentation_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

presentation_thin

</> 
pub fn presentation_thin(attrs: List(Attribute(a))) -> Element(a)

printer_bold

</> 
pub fn printer_bold(attrs: List(Attribute(a))) -> Element(a)

printer_duotone

</> 
pub fn printer_duotone(attrs: List(Attribute(a))) -> Element(a)

printer_fill

</> 
pub fn printer_fill(attrs: List(Attribute(a))) -> Element(a)

printer_light

</> 
pub fn printer_light(attrs: List(Attribute(a))) -> Element(a)

printer_regular

</> 
pub fn printer_regular(attrs: List(Attribute(a))) -> Element(a)

printer_thin

</> 
pub fn printer_thin(attrs: List(Attribute(a))) -> Element(a)

prohibit_bold

</> 
pub fn prohibit_bold(attrs: List(Attribute(a))) -> Element(a)

prohibit_duotone

</> 
pub fn prohibit_duotone(attrs: List(Attribute(a))) -> Element(a)

prohibit_fill

</> 
pub fn prohibit_fill(attrs: List(Attribute(a))) -> Element(a)

prohibit_inset_bold

</> 
pub fn prohibit_inset_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

prohibit_inset_duotone

</> 
pub fn prohibit_inset_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

prohibit_inset_fill

</> 
pub fn prohibit_inset_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

prohibit_inset_light

</> 
pub fn prohibit_inset_light(
  attrs: List(Attribute(a)),
) -> Element(a)

prohibit_inset_regular

</> 
pub fn prohibit_inset_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

prohibit_inset_thin

</> 
pub fn prohibit_inset_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

prohibit_light

</> 
pub fn prohibit_light(attrs: List(Attribute(a))) -> Element(a)

prohibit_regular

</> 
pub fn prohibit_regular(attrs: List(Attribute(a))) -> Element(a)

prohibit_thin

</> 
pub fn prohibit_thin(attrs: List(Attribute(a))) -> Element(a)

projector_screen_bold

</> 
pub fn projector_screen_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_chart_bold

</> 
pub fn projector_screen_chart_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_chart_duotone

</> 
pub fn projector_screen_chart_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_chart_fill

</> 
pub fn projector_screen_chart_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_chart_light

</> 
pub fn projector_screen_chart_light(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_chart_regular

</> 
pub fn projector_screen_chart_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_chart_thin

</> 
pub fn projector_screen_chart_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_duotone

</> 
pub fn projector_screen_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_fill

</> 
pub fn projector_screen_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_light

</> 
pub fn projector_screen_light(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_regular

</> 
pub fn projector_screen_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

projector_screen_thin

</> 
pub fn projector_screen_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

pulse_bold

</> 
pub fn pulse_bold(attrs: List(Attribute(a))) -> Element(a)

pulse_duotone

</> 
pub fn pulse_duotone(attrs: List(Attribute(a))) -> Element(a)

pulse_fill

</> 
pub fn pulse_fill(attrs: List(Attribute(a))) -> Element(a)

pulse_light

</> 
pub fn pulse_light(attrs: List(Attribute(a))) -> Element(a)

pulse_regular

</> 
pub fn pulse_regular(attrs: List(Attribute(a))) -> Element(a)

pulse_thin

</> 
pub fn pulse_thin(attrs: List(Attribute(a))) -> Element(a)

push_pin_bold

</> 
pub fn push_pin_bold(attrs: List(Attribute(a))) -> Element(a)

push_pin_duotone

</> 
pub fn push_pin_duotone(attrs: List(Attribute(a))) -> Element(a)

push_pin_fill

</> 
pub fn push_pin_fill(attrs: List(Attribute(a))) -> Element(a)

push_pin_light

</> 
pub fn push_pin_light(attrs: List(Attribute(a))) -> Element(a)

push_pin_regular

</> 
pub fn push_pin_regular(attrs: List(Attribute(a))) -> Element(a)

push_pin_simple_bold

</> 
pub fn push_pin_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_duotone

</> 
pub fn push_pin_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_fill

</> 
pub fn push_pin_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_light

</> 
pub fn push_pin_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_regular

</> 
pub fn push_pin_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_slash_bold

</> 
pub fn push_pin_simple_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_slash_duotone

</> 
pub fn push_pin_simple_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_slash_fill

</> 
pub fn push_pin_simple_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_slash_light

</> 
pub fn push_pin_simple_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_slash_regular

</> 
pub fn push_pin_simple_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_slash_thin

</> 
pub fn push_pin_simple_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_simple_thin

</> 
pub fn push_pin_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_slash_bold

</> 
pub fn push_pin_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_slash_duotone

</> 
pub fn push_pin_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_slash_fill

</> 
pub fn push_pin_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_slash_light

</> 
pub fn push_pin_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_slash_regular

</> 
pub fn push_pin_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_slash_thin

</> 
pub fn push_pin_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

push_pin_thin

</> 
pub fn push_pin_thin(attrs: List(Attribute(a))) -> Element(a)

puzzle_piece_bold

</> 
pub fn puzzle_piece_bold(attrs: List(Attribute(a))) -> Element(a)

puzzle_piece_duotone

</> 
pub fn puzzle_piece_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

puzzle_piece_fill

</> 
pub fn puzzle_piece_fill(attrs: List(Attribute(a))) -> Element(a)

puzzle_piece_light

</> 
pub fn puzzle_piece_light(
  attrs: List(Attribute(a)),
) -> Element(a)

puzzle_piece_regular

</> 
pub fn puzzle_piece_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

puzzle_piece_thin

</> 
pub fn puzzle_piece_thin(attrs: List(Attribute(a))) -> Element(a)

qr_code_bold

</> 
pub fn qr_code_bold(attrs: List(Attribute(a))) -> Element(a)

qr_code_duotone

</> 
pub fn qr_code_duotone(attrs: List(Attribute(a))) -> Element(a)

qr_code_fill

</> 
pub fn qr_code_fill(attrs: List(Attribute(a))) -> Element(a)

qr_code_light

</> 
pub fn qr_code_light(attrs: List(Attribute(a))) -> Element(a)

qr_code_regular

</> 
pub fn qr_code_regular(attrs: List(Attribute(a))) -> Element(a)

qr_code_thin

</> 
pub fn qr_code_thin(attrs: List(Attribute(a))) -> Element(a)

question_bold

</> 
pub fn question_bold(attrs: List(Attribute(a))) -> Element(a)

question_duotone

</> 
pub fn question_duotone(attrs: List(Attribute(a))) -> Element(a)

question_fill

</> 
pub fn question_fill(attrs: List(Attribute(a))) -> Element(a)

question_light

</> 
pub fn question_light(attrs: List(Attribute(a))) -> Element(a)

question_mark_bold

</> 
pub fn question_mark_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

question_mark_duotone

</> 
pub fn question_mark_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

question_mark_fill

</> 
pub fn question_mark_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

question_mark_light

</> 
pub fn question_mark_light(
  attrs: List(Attribute(a)),
) -> Element(a)

question_mark_regular

</> 
pub fn question_mark_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

question_mark_thin

</> 
pub fn question_mark_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

question_regular

</> 
pub fn question_regular(attrs: List(Attribute(a))) -> Element(a)

question_thin

</> 
pub fn question_thin(attrs: List(Attribute(a))) -> Element(a)

queue_bold

</> 
pub fn queue_bold(attrs: List(Attribute(a))) -> Element(a)

queue_duotone

</> 
pub fn queue_duotone(attrs: List(Attribute(a))) -> Element(a)

queue_fill

</> 
pub fn queue_fill(attrs: List(Attribute(a))) -> Element(a)

queue_light

</> 
pub fn queue_light(attrs: List(Attribute(a))) -> Element(a)

queue_regular

</> 
pub fn queue_regular(attrs: List(Attribute(a))) -> Element(a)

queue_thin

</> 
pub fn queue_thin(attrs: List(Attribute(a))) -> Element(a)

quotes_bold

</> 
pub fn quotes_bold(attrs: List(Attribute(a))) -> Element(a)

quotes_duotone

</> 
pub fn quotes_duotone(attrs: List(Attribute(a))) -> Element(a)

quotes_fill

</> 
pub fn quotes_fill(attrs: List(Attribute(a))) -> Element(a)

quotes_light

</> 
pub fn quotes_light(attrs: List(Attribute(a))) -> Element(a)

quotes_regular

</> 
pub fn quotes_regular(attrs: List(Attribute(a))) -> Element(a)

quotes_thin

</> 
pub fn quotes_thin(attrs: List(Attribute(a))) -> Element(a)

rabbit_bold

</> 
pub fn rabbit_bold(attrs: List(Attribute(a))) -> Element(a)

rabbit_duotone

</> 
pub fn rabbit_duotone(attrs: List(Attribute(a))) -> Element(a)

rabbit_fill

</> 
pub fn rabbit_fill(attrs: List(Attribute(a))) -> Element(a)

rabbit_light

</> 
pub fn rabbit_light(attrs: List(Attribute(a))) -> Element(a)

rabbit_regular

</> 
pub fn rabbit_regular(attrs: List(Attribute(a))) -> Element(a)

rabbit_thin

</> 
pub fn rabbit_thin(attrs: List(Attribute(a))) -> Element(a)

racquet_bold

</> 
pub fn racquet_bold(attrs: List(Attribute(a))) -> Element(a)

racquet_duotone

</> 
pub fn racquet_duotone(attrs: List(Attribute(a))) -> Element(a)

racquet_fill

</> 
pub fn racquet_fill(attrs: List(Attribute(a))) -> Element(a)

racquet_light

</> 
pub fn racquet_light(attrs: List(Attribute(a))) -> Element(a)

racquet_regular

</> 
pub fn racquet_regular(attrs: List(Attribute(a))) -> Element(a)

racquet_thin

</> 
pub fn racquet_thin(attrs: List(Attribute(a))) -> Element(a)

radical_bold

</> 
pub fn radical_bold(attrs: List(Attribute(a))) -> Element(a)

radical_duotone

</> 
pub fn radical_duotone(attrs: List(Attribute(a))) -> Element(a)

radical_fill

</> 
pub fn radical_fill(attrs: List(Attribute(a))) -> Element(a)

radical_light

</> 
pub fn radical_light(attrs: List(Attribute(a))) -> Element(a)

radical_regular

</> 
pub fn radical_regular(attrs: List(Attribute(a))) -> Element(a)

radical_thin

</> 
pub fn radical_thin(attrs: List(Attribute(a))) -> Element(a)

radio_bold

</> 
pub fn radio_bold(attrs: List(Attribute(a))) -> Element(a)

radio_button_bold

</> 
pub fn radio_button_bold(attrs: List(Attribute(a))) -> Element(a)

radio_button_duotone

</> 
pub fn radio_button_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

radio_button_fill

</> 
pub fn radio_button_fill(attrs: List(Attribute(a))) -> Element(a)

radio_button_light

</> 
pub fn radio_button_light(
  attrs: List(Attribute(a)),
) -> Element(a)

radio_button_regular

</> 
pub fn radio_button_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

radio_button_thin

</> 
pub fn radio_button_thin(attrs: List(Attribute(a))) -> Element(a)

radio_duotone

</> 
pub fn radio_duotone(attrs: List(Attribute(a))) -> Element(a)

radio_fill

</> 
pub fn radio_fill(attrs: List(Attribute(a))) -> Element(a)

radio_light

</> 
pub fn radio_light(attrs: List(Attribute(a))) -> Element(a)

radio_regular

</> 
pub fn radio_regular(attrs: List(Attribute(a))) -> Element(a)

radio_thin

</> 
pub fn radio_thin(attrs: List(Attribute(a))) -> Element(a)

radioactive_bold

</> 
pub fn radioactive_bold(attrs: List(Attribute(a))) -> Element(a)

radioactive_duotone

</> 
pub fn radioactive_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

radioactive_fill

</> 
pub fn radioactive_fill(attrs: List(Attribute(a))) -> Element(a)

radioactive_light

</> 
pub fn radioactive_light(attrs: List(Attribute(a))) -> Element(a)

radioactive_regular

</> 
pub fn radioactive_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

radioactive_thin

</> 
pub fn radioactive_thin(attrs: List(Attribute(a))) -> Element(a)

rainbow_bold

</> 
pub fn rainbow_bold(attrs: List(Attribute(a))) -> Element(a)

rainbow_cloud_bold

</> 
pub fn rainbow_cloud_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

rainbow_cloud_duotone

</> 
pub fn rainbow_cloud_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

rainbow_cloud_fill

</> 
pub fn rainbow_cloud_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

rainbow_cloud_light

</> 
pub fn rainbow_cloud_light(
  attrs: List(Attribute(a)),
) -> Element(a)

rainbow_cloud_regular

</> 
pub fn rainbow_cloud_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

rainbow_cloud_thin

</> 
pub fn rainbow_cloud_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

rainbow_duotone

</> 
pub fn rainbow_duotone(attrs: List(Attribute(a))) -> Element(a)

rainbow_fill

</> 
pub fn rainbow_fill(attrs: List(Attribute(a))) -> Element(a)

rainbow_light

</> 
pub fn rainbow_light(attrs: List(Attribute(a))) -> Element(a)

rainbow_regular

</> 
pub fn rainbow_regular(attrs: List(Attribute(a))) -> Element(a)

rainbow_thin

</> 
pub fn rainbow_thin(attrs: List(Attribute(a))) -> Element(a)

ranking_bold

</> 
pub fn ranking_bold(attrs: List(Attribute(a))) -> Element(a)

ranking_duotone

</> 
pub fn ranking_duotone(attrs: List(Attribute(a))) -> Element(a)

ranking_fill

</> 
pub fn ranking_fill(attrs: List(Attribute(a))) -> Element(a)

ranking_light

</> 
pub fn ranking_light(attrs: List(Attribute(a))) -> Element(a)

ranking_regular

</> 
pub fn ranking_regular(attrs: List(Attribute(a))) -> Element(a)

ranking_thin

</> 
pub fn ranking_thin(attrs: List(Attribute(a))) -> Element(a)

read_cv_logo_bold

</> 
pub fn read_cv_logo_bold(attrs: List(Attribute(a))) -> Element(a)

read_cv_logo_duotone

</> 
pub fn read_cv_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

read_cv_logo_fill

</> 
pub fn read_cv_logo_fill(attrs: List(Attribute(a))) -> Element(a)

read_cv_logo_light

</> 
pub fn read_cv_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

read_cv_logo_regular

</> 
pub fn read_cv_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

read_cv_logo_thin

</> 
pub fn read_cv_logo_thin(attrs: List(Attribute(a))) -> Element(a)

receipt_bold

</> 
pub fn receipt_bold(attrs: List(Attribute(a))) -> Element(a)

receipt_duotone

</> 
pub fn receipt_duotone(attrs: List(Attribute(a))) -> Element(a)

receipt_fill

</> 
pub fn receipt_fill(attrs: List(Attribute(a))) -> Element(a)

receipt_light

</> 
pub fn receipt_light(attrs: List(Attribute(a))) -> Element(a)

receipt_regular

</> 
pub fn receipt_regular(attrs: List(Attribute(a))) -> Element(a)

receipt_thin

</> 
pub fn receipt_thin(attrs: List(Attribute(a))) -> Element(a)

receipt_x_bold

</> 
pub fn receipt_x_bold(attrs: List(Attribute(a))) -> Element(a)

receipt_x_duotone

</> 
pub fn receipt_x_duotone(attrs: List(Attribute(a))) -> Element(a)

receipt_x_fill

</> 
pub fn receipt_x_fill(attrs: List(Attribute(a))) -> Element(a)

receipt_x_light

</> 
pub fn receipt_x_light(attrs: List(Attribute(a))) -> Element(a)

receipt_x_regular

</> 
pub fn receipt_x_regular(attrs: List(Attribute(a))) -> Element(a)

receipt_x_thin

</> 
pub fn receipt_x_thin(attrs: List(Attribute(a))) -> Element(a)

record_bold

</> 
pub fn record_bold(attrs: List(Attribute(a))) -> Element(a)

record_duotone

</> 
pub fn record_duotone(attrs: List(Attribute(a))) -> Element(a)

record_fill

</> 
pub fn record_fill(attrs: List(Attribute(a))) -> Element(a)

record_light

</> 
pub fn record_light(attrs: List(Attribute(a))) -> Element(a)

record_regular

</> 
pub fn record_regular(attrs: List(Attribute(a))) -> Element(a)

record_thin

</> 
pub fn record_thin(attrs: List(Attribute(a))) -> Element(a)

rectangle_bold

</> 
pub fn rectangle_bold(attrs: List(Attribute(a))) -> Element(a)

rectangle_dashed_bold

</> 
pub fn rectangle_dashed_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

rectangle_dashed_duotone

</> 
pub fn rectangle_dashed_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

rectangle_dashed_fill

</> 
pub fn rectangle_dashed_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

rectangle_dashed_light

</> 
pub fn rectangle_dashed_light(
  attrs: List(Attribute(a)),
) -> Element(a)

rectangle_dashed_regular

</> 
pub fn rectangle_dashed_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

rectangle_dashed_thin

</> 
pub fn rectangle_dashed_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

rectangle_duotone

</> 
pub fn rectangle_duotone(attrs: List(Attribute(a))) -> Element(a)

rectangle_fill

</> 
pub fn rectangle_fill(attrs: List(Attribute(a))) -> Element(a)

rectangle_light

</> 
pub fn rectangle_light(attrs: List(Attribute(a))) -> Element(a)

rectangle_regular

</> 
pub fn rectangle_regular(attrs: List(Attribute(a))) -> Element(a)

rectangle_thin

</> 
pub fn rectangle_thin(attrs: List(Attribute(a))) -> Element(a)

recycle_bold

</> 
pub fn recycle_bold(attrs: List(Attribute(a))) -> Element(a)

recycle_duotone

</> 
pub fn recycle_duotone(attrs: List(Attribute(a))) -> Element(a)

recycle_fill

</> 
pub fn recycle_fill(attrs: List(Attribute(a))) -> Element(a)

recycle_light

</> 
pub fn recycle_light(attrs: List(Attribute(a))) -> Element(a)

recycle_regular

</> 
pub fn recycle_regular(attrs: List(Attribute(a))) -> Element(a)

recycle_thin

</> 
pub fn recycle_thin(attrs: List(Attribute(a))) -> Element(a)

reddit_logo_bold

</> 
pub fn reddit_logo_bold(attrs: List(Attribute(a))) -> Element(a)

reddit_logo_duotone

</> 
pub fn reddit_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

reddit_logo_fill

</> 
pub fn reddit_logo_fill(attrs: List(Attribute(a))) -> Element(a)

reddit_logo_light

</> 
pub fn reddit_logo_light(attrs: List(Attribute(a))) -> Element(a)

reddit_logo_regular

</> 
pub fn reddit_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

reddit_logo_thin

</> 
pub fn reddit_logo_thin(attrs: List(Attribute(a))) -> Element(a)

repeat_bold

</> 
pub fn repeat_bold(attrs: List(Attribute(a))) -> Element(a)

repeat_duotone

</> 
pub fn repeat_duotone(attrs: List(Attribute(a))) -> Element(a)

repeat_fill

</> 
pub fn repeat_fill(attrs: List(Attribute(a))) -> Element(a)

repeat_light

</> 
pub fn repeat_light(attrs: List(Attribute(a))) -> Element(a)

repeat_once_bold

</> 
pub fn repeat_once_bold(attrs: List(Attribute(a))) -> Element(a)

repeat_once_duotone

</> 
pub fn repeat_once_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

repeat_once_fill

</> 
pub fn repeat_once_fill(attrs: List(Attribute(a))) -> Element(a)

repeat_once_light

</> 
pub fn repeat_once_light(attrs: List(Attribute(a))) -> Element(a)

repeat_once_regular

</> 
pub fn repeat_once_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

repeat_once_thin

</> 
pub fn repeat_once_thin(attrs: List(Attribute(a))) -> Element(a)

repeat_regular

</> 
pub fn repeat_regular(attrs: List(Attribute(a))) -> Element(a)

repeat_thin

</> 
pub fn repeat_thin(attrs: List(Attribute(a))) -> Element(a)

replit_logo_bold

</> 
pub fn replit_logo_bold(attrs: List(Attribute(a))) -> Element(a)

replit_logo_duotone

</> 
pub fn replit_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

replit_logo_fill

</> 
pub fn replit_logo_fill(attrs: List(Attribute(a))) -> Element(a)

replit_logo_light

</> 
pub fn replit_logo_light(attrs: List(Attribute(a))) -> Element(a)

replit_logo_regular

</> 
pub fn replit_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

replit_logo_thin

</> 
pub fn replit_logo_thin(attrs: List(Attribute(a))) -> Element(a)

resize_bold

</> 
pub fn resize_bold(attrs: List(Attribute(a))) -> Element(a)

resize_duotone

</> 
pub fn resize_duotone(attrs: List(Attribute(a))) -> Element(a)

resize_fill

</> 
pub fn resize_fill(attrs: List(Attribute(a))) -> Element(a)

resize_light

</> 
pub fn resize_light(attrs: List(Attribute(a))) -> Element(a)

resize_regular

</> 
pub fn resize_regular(attrs: List(Attribute(a))) -> Element(a)

resize_thin

</> 
pub fn resize_thin(attrs: List(Attribute(a))) -> Element(a)

rewind_bold

</> 
pub fn rewind_bold(attrs: List(Attribute(a))) -> Element(a)

rewind_circle_bold

</> 
pub fn rewind_circle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

rewind_circle_duotone

</> 
pub fn rewind_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

rewind_circle_fill

</> 
pub fn rewind_circle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

rewind_circle_light

</> 
pub fn rewind_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

rewind_circle_regular

</> 
pub fn rewind_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

rewind_circle_thin

</> 
pub fn rewind_circle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

rewind_duotone

</> 
pub fn rewind_duotone(attrs: List(Attribute(a))) -> Element(a)

rewind_fill

</> 
pub fn rewind_fill(attrs: List(Attribute(a))) -> Element(a)

rewind_light

</> 
pub fn rewind_light(attrs: List(Attribute(a))) -> Element(a)

rewind_regular

</> 
pub fn rewind_regular(attrs: List(Attribute(a))) -> Element(a)

rewind_thin

</> 
pub fn rewind_thin(attrs: List(Attribute(a))) -> Element(a)

road_horizon_bold

</> 
pub fn road_horizon_bold(attrs: List(Attribute(a))) -> Element(a)

road_horizon_duotone

</> 
pub fn road_horizon_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

road_horizon_fill

</> 
pub fn road_horizon_fill(attrs: List(Attribute(a))) -> Element(a)

road_horizon_light

</> 
pub fn road_horizon_light(
  attrs: List(Attribute(a)),
) -> Element(a)

road_horizon_regular

</> 
pub fn road_horizon_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

road_horizon_thin

</> 
pub fn road_horizon_thin(attrs: List(Attribute(a))) -> Element(a)

robot_bold

</> 
pub fn robot_bold(attrs: List(Attribute(a))) -> Element(a)

robot_duotone

</> 
pub fn robot_duotone(attrs: List(Attribute(a))) -> Element(a)

robot_fill

</> 
pub fn robot_fill(attrs: List(Attribute(a))) -> Element(a)

robot_light

</> 
pub fn robot_light(attrs: List(Attribute(a))) -> Element(a)

robot_regular

</> 
pub fn robot_regular(attrs: List(Attribute(a))) -> Element(a)

robot_thin

</> 
pub fn robot_thin(attrs: List(Attribute(a))) -> Element(a)

rocket_bold

</> 
pub fn rocket_bold(attrs: List(Attribute(a))) -> Element(a)

rocket_duotone

</> 
pub fn rocket_duotone(attrs: List(Attribute(a))) -> Element(a)

rocket_fill

</> 
pub fn rocket_fill(attrs: List(Attribute(a))) -> Element(a)

rocket_launch_bold

</> 
pub fn rocket_launch_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

rocket_launch_duotone

</> 
pub fn rocket_launch_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

rocket_launch_fill

</> 
pub fn rocket_launch_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

rocket_launch_light

</> 
pub fn rocket_launch_light(
  attrs: List(Attribute(a)),
) -> Element(a)

rocket_launch_regular

</> 
pub fn rocket_launch_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

rocket_launch_thin

</> 
pub fn rocket_launch_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

rocket_light

</> 
pub fn rocket_light(attrs: List(Attribute(a))) -> Element(a)

rocket_regular

</> 
pub fn rocket_regular(attrs: List(Attribute(a))) -> Element(a)

rocket_thin

</> 
pub fn rocket_thin(attrs: List(Attribute(a))) -> Element(a)

rows_bold

</> 
pub fn rows_bold(attrs: List(Attribute(a))) -> Element(a)

rows_duotone

</> 
pub fn rows_duotone(attrs: List(Attribute(a))) -> Element(a)

rows_fill

</> 
pub fn rows_fill(attrs: List(Attribute(a))) -> Element(a)

rows_light

</> 
pub fn rows_light(attrs: List(Attribute(a))) -> Element(a)

rows_plus_bottom_bold

</> 
pub fn rows_plus_bottom_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_bottom_duotone

</> 
pub fn rows_plus_bottom_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_bottom_fill

</> 
pub fn rows_plus_bottom_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_bottom_light

</> 
pub fn rows_plus_bottom_light(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_bottom_regular

</> 
pub fn rows_plus_bottom_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_bottom_thin

</> 
pub fn rows_plus_bottom_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_top_bold

</> 
pub fn rows_plus_top_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_top_duotone

</> 
pub fn rows_plus_top_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_top_fill

</> 
pub fn rows_plus_top_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_top_light

</> 
pub fn rows_plus_top_light(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_top_regular

</> 
pub fn rows_plus_top_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_plus_top_thin

</> 
pub fn rows_plus_top_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

rows_regular

</> 
pub fn rows_regular(attrs: List(Attribute(a))) -> Element(a)

rows_thin

</> 
pub fn rows_thin(attrs: List(Attribute(a))) -> Element(a)

rss_bold

</> 
pub fn rss_bold(attrs: List(Attribute(a))) -> Element(a)

rss_duotone

</> 
pub fn rss_duotone(attrs: List(Attribute(a))) -> Element(a)

rss_fill

</> 
pub fn rss_fill(attrs: List(Attribute(a))) -> Element(a)

rss_light

</> 
pub fn rss_light(attrs: List(Attribute(a))) -> Element(a)

rss_regular

</> 
pub fn rss_regular(attrs: List(Attribute(a))) -> Element(a)

rss_simple_bold

</> 
pub fn rss_simple_bold(attrs: List(Attribute(a))) -> Element(a)

rss_simple_duotone

</> 
pub fn rss_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

rss_simple_fill

</> 
pub fn rss_simple_fill(attrs: List(Attribute(a))) -> Element(a)

rss_simple_light

</> 
pub fn rss_simple_light(attrs: List(Attribute(a))) -> Element(a)

rss_simple_regular

</> 
pub fn rss_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

rss_simple_thin

</> 
pub fn rss_simple_thin(attrs: List(Attribute(a))) -> Element(a)

rss_thin

</> 
pub fn rss_thin(attrs: List(Attribute(a))) -> Element(a)

rug_bold

</> 
pub fn rug_bold(attrs: List(Attribute(a))) -> Element(a)

rug_duotone

</> 
pub fn rug_duotone(attrs: List(Attribute(a))) -> Element(a)

rug_fill

</> 
pub fn rug_fill(attrs: List(Attribute(a))) -> Element(a)

rug_light

</> 
pub fn rug_light(attrs: List(Attribute(a))) -> Element(a)

rug_regular

</> 
pub fn rug_regular(attrs: List(Attribute(a))) -> Element(a)

rug_thin

</> 
pub fn rug_thin(attrs: List(Attribute(a))) -> Element(a)

ruler_bold

</> 
pub fn ruler_bold(attrs: List(Attribute(a))) -> Element(a)

ruler_duotone

</> 
pub fn ruler_duotone(attrs: List(Attribute(a))) -> Element(a)

ruler_fill

</> 
pub fn ruler_fill(attrs: List(Attribute(a))) -> Element(a)

ruler_light

</> 
pub fn ruler_light(attrs: List(Attribute(a))) -> Element(a)

ruler_regular

</> 
pub fn ruler_regular(attrs: List(Attribute(a))) -> Element(a)

ruler_thin

</> 
pub fn ruler_thin(attrs: List(Attribute(a))) -> Element(a)

sailboat_bold

</> 
pub fn sailboat_bold(attrs: List(Attribute(a))) -> Element(a)

sailboat_duotone

</> 
pub fn sailboat_duotone(attrs: List(Attribute(a))) -> Element(a)

sailboat_fill

</> 
pub fn sailboat_fill(attrs: List(Attribute(a))) -> Element(a)

sailboat_light

</> 
pub fn sailboat_light(attrs: List(Attribute(a))) -> Element(a)

sailboat_regular

</> 
pub fn sailboat_regular(attrs: List(Attribute(a))) -> Element(a)

sailboat_thin

</> 
pub fn sailboat_thin(attrs: List(Attribute(a))) -> Element(a)

scales_bold

</> 
pub fn scales_bold(attrs: List(Attribute(a))) -> Element(a)

scales_duotone

</> 
pub fn scales_duotone(attrs: List(Attribute(a))) -> Element(a)

scales_fill

</> 
pub fn scales_fill(attrs: List(Attribute(a))) -> Element(a)

scales_light

</> 
pub fn scales_light(attrs: List(Attribute(a))) -> Element(a)

scales_regular

</> 
pub fn scales_regular(attrs: List(Attribute(a))) -> Element(a)

scales_thin

</> 
pub fn scales_thin(attrs: List(Attribute(a))) -> Element(a)

scan_bold

</> 
pub fn scan_bold(attrs: List(Attribute(a))) -> Element(a)

scan_duotone

</> 
pub fn scan_duotone(attrs: List(Attribute(a))) -> Element(a)

scan_fill

</> 
pub fn scan_fill(attrs: List(Attribute(a))) -> Element(a)

scan_light

</> 
pub fn scan_light(attrs: List(Attribute(a))) -> Element(a)

scan_regular

</> 
pub fn scan_regular(attrs: List(Attribute(a))) -> Element(a)

scan_smiley_bold

</> 
pub fn scan_smiley_bold(attrs: List(Attribute(a))) -> Element(a)

scan_smiley_duotone

</> 
pub fn scan_smiley_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

scan_smiley_fill

</> 
pub fn scan_smiley_fill(attrs: List(Attribute(a))) -> Element(a)

scan_smiley_light

</> 
pub fn scan_smiley_light(attrs: List(Attribute(a))) -> Element(a)

scan_smiley_regular

</> 
pub fn scan_smiley_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

scan_smiley_thin

</> 
pub fn scan_smiley_thin(attrs: List(Attribute(a))) -> Element(a)

scan_thin

</> 
pub fn scan_thin(attrs: List(Attribute(a))) -> Element(a)

scissors_bold

</> 
pub fn scissors_bold(attrs: List(Attribute(a))) -> Element(a)

scissors_duotone

</> 
pub fn scissors_duotone(attrs: List(Attribute(a))) -> Element(a)

scissors_fill

</> 
pub fn scissors_fill(attrs: List(Attribute(a))) -> Element(a)

scissors_light

</> 
pub fn scissors_light(attrs: List(Attribute(a))) -> Element(a)

scissors_regular

</> 
pub fn scissors_regular(attrs: List(Attribute(a))) -> Element(a)

scissors_thin

</> 
pub fn scissors_thin(attrs: List(Attribute(a))) -> Element(a)

scooter_bold

</> 
pub fn scooter_bold(attrs: List(Attribute(a))) -> Element(a)

scooter_duotone

</> 
pub fn scooter_duotone(attrs: List(Attribute(a))) -> Element(a)

scooter_fill

</> 
pub fn scooter_fill(attrs: List(Attribute(a))) -> Element(a)

scooter_light

</> 
pub fn scooter_light(attrs: List(Attribute(a))) -> Element(a)

scooter_regular

</> 
pub fn scooter_regular(attrs: List(Attribute(a))) -> Element(a)

scooter_thin

</> 
pub fn scooter_thin(attrs: List(Attribute(a))) -> Element(a)

screencast_bold

</> 
pub fn screencast_bold(attrs: List(Attribute(a))) -> Element(a)

screencast_duotone

</> 
pub fn screencast_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

screencast_fill

</> 
pub fn screencast_fill(attrs: List(Attribute(a))) -> Element(a)

screencast_light

</> 
pub fn screencast_light(attrs: List(Attribute(a))) -> Element(a)

screencast_regular

</> 
pub fn screencast_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

screencast_thin

</> 
pub fn screencast_thin(attrs: List(Attribute(a))) -> Element(a)

screwdriver_bold

</> 
pub fn screwdriver_bold(attrs: List(Attribute(a))) -> Element(a)

screwdriver_duotone

</> 
pub fn screwdriver_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

screwdriver_fill

</> 
pub fn screwdriver_fill(attrs: List(Attribute(a))) -> Element(a)

screwdriver_light

</> 
pub fn screwdriver_light(attrs: List(Attribute(a))) -> Element(a)

screwdriver_regular

</> 
pub fn screwdriver_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

screwdriver_thin

</> 
pub fn screwdriver_thin(attrs: List(Attribute(a))) -> Element(a)

scribble_bold

</> 
pub fn scribble_bold(attrs: List(Attribute(a))) -> Element(a)

scribble_duotone

</> 
pub fn scribble_duotone(attrs: List(Attribute(a))) -> Element(a)

scribble_fill

</> 
pub fn scribble_fill(attrs: List(Attribute(a))) -> Element(a)

scribble_light

</> 
pub fn scribble_light(attrs: List(Attribute(a))) -> Element(a)

scribble_loop_bold

</> 
pub fn scribble_loop_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

scribble_loop_duotone

</> 
pub fn scribble_loop_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

scribble_loop_fill

</> 
pub fn scribble_loop_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

scribble_loop_light

</> 
pub fn scribble_loop_light(
  attrs: List(Attribute(a)),
) -> Element(a)

scribble_loop_regular

</> 
pub fn scribble_loop_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

scribble_loop_thin

</> 
pub fn scribble_loop_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

scribble_regular

</> 
pub fn scribble_regular(attrs: List(Attribute(a))) -> Element(a)

scribble_thin

</> 
pub fn scribble_thin(attrs: List(Attribute(a))) -> Element(a)

scroll_bold

</> 
pub fn scroll_bold(attrs: List(Attribute(a))) -> Element(a)

scroll_duotone

</> 
pub fn scroll_duotone(attrs: List(Attribute(a))) -> Element(a)

scroll_fill

</> 
pub fn scroll_fill(attrs: List(Attribute(a))) -> Element(a)

scroll_light

</> 
pub fn scroll_light(attrs: List(Attribute(a))) -> Element(a)

scroll_regular

</> 
pub fn scroll_regular(attrs: List(Attribute(a))) -> Element(a)

scroll_thin

</> 
pub fn scroll_thin(attrs: List(Attribute(a))) -> Element(a)

seal_bold

</> 
pub fn seal_bold(attrs: List(Attribute(a))) -> Element(a)

seal_check_bold

</> 
pub fn seal_check_bold(attrs: List(Attribute(a))) -> Element(a)

seal_check_duotone

</> 
pub fn seal_check_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_check_fill

</> 
pub fn seal_check_fill(attrs: List(Attribute(a))) -> Element(a)

seal_check_light

</> 
pub fn seal_check_light(attrs: List(Attribute(a))) -> Element(a)

seal_check_regular

</> 
pub fn seal_check_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_check_thin

</> 
pub fn seal_check_thin(attrs: List(Attribute(a))) -> Element(a)

seal_duotone

</> 
pub fn seal_duotone(attrs: List(Attribute(a))) -> Element(a)

seal_fill

</> 
pub fn seal_fill(attrs: List(Attribute(a))) -> Element(a)

seal_light

</> 
pub fn seal_light(attrs: List(Attribute(a))) -> Element(a)

seal_percent_bold

</> 
pub fn seal_percent_bold(attrs: List(Attribute(a))) -> Element(a)

seal_percent_duotone

</> 
pub fn seal_percent_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_percent_fill

</> 
pub fn seal_percent_fill(attrs: List(Attribute(a))) -> Element(a)

seal_percent_light

</> 
pub fn seal_percent_light(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_percent_regular

</> 
pub fn seal_percent_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_percent_thin

</> 
pub fn seal_percent_thin(attrs: List(Attribute(a))) -> Element(a)

seal_question_bold

</> 
pub fn seal_question_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_question_duotone

</> 
pub fn seal_question_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_question_fill

</> 
pub fn seal_question_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_question_light

</> 
pub fn seal_question_light(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_question_regular

</> 
pub fn seal_question_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_question_thin

</> 
pub fn seal_question_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_regular

</> 
pub fn seal_regular(attrs: List(Attribute(a))) -> Element(a)

seal_thin

</> 
pub fn seal_thin(attrs: List(Attribute(a))) -> Element(a)

seal_warning_bold

</> 
pub fn seal_warning_bold(attrs: List(Attribute(a))) -> Element(a)

seal_warning_duotone

</> 
pub fn seal_warning_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_warning_fill

</> 
pub fn seal_warning_fill(attrs: List(Attribute(a))) -> Element(a)

seal_warning_light

</> 
pub fn seal_warning_light(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_warning_regular

</> 
pub fn seal_warning_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

seal_warning_thin

</> 
pub fn seal_warning_thin(attrs: List(Attribute(a))) -> Element(a)

seat_bold

</> 
pub fn seat_bold(attrs: List(Attribute(a))) -> Element(a)

seat_duotone

</> 
pub fn seat_duotone(attrs: List(Attribute(a))) -> Element(a)

seat_fill

</> 
pub fn seat_fill(attrs: List(Attribute(a))) -> Element(a)

seat_light

</> 
pub fn seat_light(attrs: List(Attribute(a))) -> Element(a)

seat_regular

</> 
pub fn seat_regular(attrs: List(Attribute(a))) -> Element(a)

seat_thin

</> 
pub fn seat_thin(attrs: List(Attribute(a))) -> Element(a)

seatbelt_bold

</> 
pub fn seatbelt_bold(attrs: List(Attribute(a))) -> Element(a)

seatbelt_duotone

</> 
pub fn seatbelt_duotone(attrs: List(Attribute(a))) -> Element(a)

seatbelt_fill

</> 
pub fn seatbelt_fill(attrs: List(Attribute(a))) -> Element(a)

seatbelt_light

</> 
pub fn seatbelt_light(attrs: List(Attribute(a))) -> Element(a)

seatbelt_regular

</> 
pub fn seatbelt_regular(attrs: List(Attribute(a))) -> Element(a)

seatbelt_thin

</> 
pub fn seatbelt_thin(attrs: List(Attribute(a))) -> Element(a)

security_camera_bold

</> 
pub fn security_camera_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

security_camera_duotone

</> 
pub fn security_camera_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

security_camera_fill

</> 
pub fn security_camera_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

security_camera_light

</> 
pub fn security_camera_light(
  attrs: List(Attribute(a)),
) -> Element(a)

security_camera_regular

</> 
pub fn security_camera_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

security_camera_thin

</> 
pub fn security_camera_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_all_bold

</> 
pub fn selection_all_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_all_duotone

</> 
pub fn selection_all_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_all_fill

</> 
pub fn selection_all_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_all_light

</> 
pub fn selection_all_light(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_all_regular

</> 
pub fn selection_all_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_all_thin

</> 
pub fn selection_all_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_background_bold

</> 
pub fn selection_background_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_background_duotone

</> 
pub fn selection_background_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_background_fill

</> 
pub fn selection_background_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_background_light

</> 
pub fn selection_background_light(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_background_regular

</> 
pub fn selection_background_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_background_thin

</> 
pub fn selection_background_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_bold

</> 
pub fn selection_bold(attrs: List(Attribute(a))) -> Element(a)

selection_duotone

</> 
pub fn selection_duotone(attrs: List(Attribute(a))) -> Element(a)

selection_fill

</> 
pub fn selection_fill(attrs: List(Attribute(a))) -> Element(a)

selection_foreground_bold

</> 
pub fn selection_foreground_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_foreground_duotone

</> 
pub fn selection_foreground_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_foreground_fill

</> 
pub fn selection_foreground_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_foreground_light

</> 
pub fn selection_foreground_light(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_foreground_regular

</> 
pub fn selection_foreground_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_foreground_thin

</> 
pub fn selection_foreground_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_inverse_bold

</> 
pub fn selection_inverse_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_inverse_duotone

</> 
pub fn selection_inverse_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_inverse_fill

</> 
pub fn selection_inverse_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_inverse_light

</> 
pub fn selection_inverse_light(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_inverse_regular

</> 
pub fn selection_inverse_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_inverse_thin

</> 
pub fn selection_inverse_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_light

</> 
pub fn selection_light(attrs: List(Attribute(a))) -> Element(a)

selection_plus_bold

</> 
pub fn selection_plus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_plus_duotone

</> 
pub fn selection_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_plus_fill

</> 
pub fn selection_plus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_plus_light

</> 
pub fn selection_plus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_plus_regular

</> 
pub fn selection_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_plus_thin

</> 
pub fn selection_plus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_regular

</> 
pub fn selection_regular(attrs: List(Attribute(a))) -> Element(a)

selection_slash_bold

</> 
pub fn selection_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_slash_duotone

</> 
pub fn selection_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_slash_fill

</> 
pub fn selection_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_slash_light

</> 
pub fn selection_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_slash_regular

</> 
pub fn selection_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_slash_thin

</> 
pub fn selection_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

selection_thin

</> 
pub fn selection_thin(attrs: List(Attribute(a))) -> Element(a)

shapes_bold

</> 
pub fn shapes_bold(attrs: List(Attribute(a))) -> Element(a)

shapes_duotone

</> 
pub fn shapes_duotone(attrs: List(Attribute(a))) -> Element(a)

shapes_fill

</> 
pub fn shapes_fill(attrs: List(Attribute(a))) -> Element(a)

shapes_light

</> 
pub fn shapes_light(attrs: List(Attribute(a))) -> Element(a)

shapes_regular

</> 
pub fn shapes_regular(attrs: List(Attribute(a))) -> Element(a)

shapes_thin

</> 
pub fn shapes_thin(attrs: List(Attribute(a))) -> Element(a)

share_bold

</> 
pub fn share_bold(attrs: List(Attribute(a))) -> Element(a)

share_duotone

</> 
pub fn share_duotone(attrs: List(Attribute(a))) -> Element(a)

share_fat_bold

</> 
pub fn share_fat_bold(attrs: List(Attribute(a))) -> Element(a)

share_fat_duotone

</> 
pub fn share_fat_duotone(attrs: List(Attribute(a))) -> Element(a)

share_fat_fill

</> 
pub fn share_fat_fill(attrs: List(Attribute(a))) -> Element(a)

share_fat_light

</> 
pub fn share_fat_light(attrs: List(Attribute(a))) -> Element(a)

share_fat_regular

</> 
pub fn share_fat_regular(attrs: List(Attribute(a))) -> Element(a)

share_fat_thin

</> 
pub fn share_fat_thin(attrs: List(Attribute(a))) -> Element(a)

share_fill

</> 
pub fn share_fill(attrs: List(Attribute(a))) -> Element(a)

share_light

</> 
pub fn share_light(attrs: List(Attribute(a))) -> Element(a)

share_network_bold

</> 
pub fn share_network_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

share_network_duotone

</> 
pub fn share_network_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

share_network_fill

</> 
pub fn share_network_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

share_network_light

</> 
pub fn share_network_light(
  attrs: List(Attribute(a)),
) -> Element(a)

share_network_regular

</> 
pub fn share_network_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

share_network_thin

</> 
pub fn share_network_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

share_regular

</> 
pub fn share_regular(attrs: List(Attribute(a))) -> Element(a)

share_thin

</> 
pub fn share_thin(attrs: List(Attribute(a))) -> Element(a)

shield_bold

</> 
pub fn shield_bold(attrs: List(Attribute(a))) -> Element(a)

shield_check_bold

</> 
pub fn shield_check_bold(attrs: List(Attribute(a))) -> Element(a)

shield_check_duotone

</> 
pub fn shield_check_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_check_fill

</> 
pub fn shield_check_fill(attrs: List(Attribute(a))) -> Element(a)

shield_check_light

</> 
pub fn shield_check_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_check_regular

</> 
pub fn shield_check_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_check_thin

</> 
pub fn shield_check_thin(attrs: List(Attribute(a))) -> Element(a)

shield_checkered_bold

</> 
pub fn shield_checkered_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_checkered_duotone

</> 
pub fn shield_checkered_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_checkered_fill

</> 
pub fn shield_checkered_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_checkered_light

</> 
pub fn shield_checkered_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_checkered_regular

</> 
pub fn shield_checkered_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_checkered_thin

</> 
pub fn shield_checkered_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_chevron_bold

</> 
pub fn shield_chevron_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_chevron_duotone

</> 
pub fn shield_chevron_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_chevron_fill

</> 
pub fn shield_chevron_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_chevron_light

</> 
pub fn shield_chevron_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_chevron_regular

</> 
pub fn shield_chevron_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_chevron_thin

</> 
pub fn shield_chevron_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_duotone

</> 
pub fn shield_duotone(attrs: List(Attribute(a))) -> Element(a)

shield_fill

</> 
pub fn shield_fill(attrs: List(Attribute(a))) -> Element(a)

shield_light

</> 
pub fn shield_light(attrs: List(Attribute(a))) -> Element(a)

shield_plus_bold

</> 
pub fn shield_plus_bold(attrs: List(Attribute(a))) -> Element(a)

shield_plus_duotone

</> 
pub fn shield_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_plus_fill

</> 
pub fn shield_plus_fill(attrs: List(Attribute(a))) -> Element(a)

shield_plus_light

</> 
pub fn shield_plus_light(attrs: List(Attribute(a))) -> Element(a)

shield_plus_regular

</> 
pub fn shield_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_plus_thin

</> 
pub fn shield_plus_thin(attrs: List(Attribute(a))) -> Element(a)

shield_regular

</> 
pub fn shield_regular(attrs: List(Attribute(a))) -> Element(a)

shield_slash_bold

</> 
pub fn shield_slash_bold(attrs: List(Attribute(a))) -> Element(a)

shield_slash_duotone

</> 
pub fn shield_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_slash_fill

</> 
pub fn shield_slash_fill(attrs: List(Attribute(a))) -> Element(a)

shield_slash_light

</> 
pub fn shield_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_slash_regular

</> 
pub fn shield_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_slash_thin

</> 
pub fn shield_slash_thin(attrs: List(Attribute(a))) -> Element(a)

shield_star_bold

</> 
pub fn shield_star_bold(attrs: List(Attribute(a))) -> Element(a)

shield_star_duotone

</> 
pub fn shield_star_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_star_fill

</> 
pub fn shield_star_fill(attrs: List(Attribute(a))) -> Element(a)

shield_star_light

</> 
pub fn shield_star_light(attrs: List(Attribute(a))) -> Element(a)

shield_star_regular

</> 
pub fn shield_star_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_star_thin

</> 
pub fn shield_star_thin(attrs: List(Attribute(a))) -> Element(a)

shield_thin

</> 
pub fn shield_thin(attrs: List(Attribute(a))) -> Element(a)

shield_warning_bold

</> 
pub fn shield_warning_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_warning_duotone

</> 
pub fn shield_warning_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_warning_fill

</> 
pub fn shield_warning_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_warning_light

</> 
pub fn shield_warning_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_warning_regular

</> 
pub fn shield_warning_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shield_warning_thin

</> 
pub fn shield_warning_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

shipping_container_bold

</> 
pub fn shipping_container_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

shipping_container_duotone

</> 
pub fn shipping_container_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shipping_container_fill

</> 
pub fn shipping_container_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

shipping_container_light

</> 
pub fn shipping_container_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shipping_container_regular

</> 
pub fn shipping_container_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shipping_container_thin

</> 
pub fn shipping_container_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

shirt_folded_bold

</> 
pub fn shirt_folded_bold(attrs: List(Attribute(a))) -> Element(a)

shirt_folded_duotone

</> 
pub fn shirt_folded_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shirt_folded_fill

</> 
pub fn shirt_folded_fill(attrs: List(Attribute(a))) -> Element(a)

shirt_folded_light

</> 
pub fn shirt_folded_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shirt_folded_regular

</> 
pub fn shirt_folded_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shirt_folded_thin

</> 
pub fn shirt_folded_thin(attrs: List(Attribute(a))) -> Element(a)

shooting_star_bold

</> 
pub fn shooting_star_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

shooting_star_duotone

</> 
pub fn shooting_star_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shooting_star_fill

</> 
pub fn shooting_star_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

shooting_star_light

</> 
pub fn shooting_star_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shooting_star_regular

</> 
pub fn shooting_star_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shooting_star_thin

</> 
pub fn shooting_star_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_bag_bold

</> 
pub fn shopping_bag_bold(attrs: List(Attribute(a))) -> Element(a)

shopping_bag_duotone

</> 
pub fn shopping_bag_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_bag_fill

</> 
pub fn shopping_bag_fill(attrs: List(Attribute(a))) -> Element(a)

shopping_bag_light

</> 
pub fn shopping_bag_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_bag_open_bold

</> 
pub fn shopping_bag_open_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_bag_open_duotone

</> 
pub fn shopping_bag_open_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_bag_open_fill

</> 
pub fn shopping_bag_open_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_bag_open_light

</> 
pub fn shopping_bag_open_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_bag_open_regular

</> 
pub fn shopping_bag_open_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_bag_open_thin

</> 
pub fn shopping_bag_open_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_bag_regular

</> 
pub fn shopping_bag_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_bag_thin

</> 
pub fn shopping_bag_thin(attrs: List(Attribute(a))) -> Element(a)

shopping_cart_bold

</> 
pub fn shopping_cart_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_duotone

</> 
pub fn shopping_cart_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_fill

</> 
pub fn shopping_cart_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_light

</> 
pub fn shopping_cart_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_regular

</> 
pub fn shopping_cart_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_simple_bold

</> 
pub fn shopping_cart_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_simple_duotone

</> 
pub fn shopping_cart_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_simple_fill

</> 
pub fn shopping_cart_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_simple_light

</> 
pub fn shopping_cart_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_simple_regular

</> 
pub fn shopping_cart_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_simple_thin

</> 
pub fn shopping_cart_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

shopping_cart_thin

</> 
pub fn shopping_cart_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

shovel_bold

</> 
pub fn shovel_bold(attrs: List(Attribute(a))) -> Element(a)

shovel_duotone

</> 
pub fn shovel_duotone(attrs: List(Attribute(a))) -> Element(a)

shovel_fill

</> 
pub fn shovel_fill(attrs: List(Attribute(a))) -> Element(a)

shovel_light

</> 
pub fn shovel_light(attrs: List(Attribute(a))) -> Element(a)

shovel_regular

</> 
pub fn shovel_regular(attrs: List(Attribute(a))) -> Element(a)

shovel_thin

</> 
pub fn shovel_thin(attrs: List(Attribute(a))) -> Element(a)

shower_bold

</> 
pub fn shower_bold(attrs: List(Attribute(a))) -> Element(a)

shower_duotone

</> 
pub fn shower_duotone(attrs: List(Attribute(a))) -> Element(a)

shower_fill

</> 
pub fn shower_fill(attrs: List(Attribute(a))) -> Element(a)

shower_light

</> 
pub fn shower_light(attrs: List(Attribute(a))) -> Element(a)

shower_regular

</> 
pub fn shower_regular(attrs: List(Attribute(a))) -> Element(a)

shower_thin

</> 
pub fn shower_thin(attrs: List(Attribute(a))) -> Element(a)

shrimp_bold

</> 
pub fn shrimp_bold(attrs: List(Attribute(a))) -> Element(a)

shrimp_duotone

</> 
pub fn shrimp_duotone(attrs: List(Attribute(a))) -> Element(a)

shrimp_fill

</> 
pub fn shrimp_fill(attrs: List(Attribute(a))) -> Element(a)

shrimp_light

</> 
pub fn shrimp_light(attrs: List(Attribute(a))) -> Element(a)

shrimp_regular

</> 
pub fn shrimp_regular(attrs: List(Attribute(a))) -> Element(a)

shrimp_thin

</> 
pub fn shrimp_thin(attrs: List(Attribute(a))) -> Element(a)

shuffle_angular_bold

</> 
pub fn shuffle_angular_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_angular_duotone

</> 
pub fn shuffle_angular_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_angular_fill

</> 
pub fn shuffle_angular_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_angular_light

</> 
pub fn shuffle_angular_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_angular_regular

</> 
pub fn shuffle_angular_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_angular_thin

</> 
pub fn shuffle_angular_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_bold

</> 
pub fn shuffle_bold(attrs: List(Attribute(a))) -> Element(a)

shuffle_duotone

</> 
pub fn shuffle_duotone(attrs: List(Attribute(a))) -> Element(a)

shuffle_fill

</> 
pub fn shuffle_fill(attrs: List(Attribute(a))) -> Element(a)

shuffle_light

</> 
pub fn shuffle_light(attrs: List(Attribute(a))) -> Element(a)

shuffle_regular

</> 
pub fn shuffle_regular(attrs: List(Attribute(a))) -> Element(a)

shuffle_simple_bold

</> 
pub fn shuffle_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_simple_duotone

</> 
pub fn shuffle_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_simple_fill

</> 
pub fn shuffle_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_simple_light

</> 
pub fn shuffle_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_simple_regular

</> 
pub fn shuffle_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_simple_thin

</> 
pub fn shuffle_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

shuffle_thin

</> 
pub fn shuffle_thin(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn sidebar_bold(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn sidebar_duotone(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn sidebar_fill(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn sidebar_light(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn sidebar_regular(attrs: List(Attribute(a))) -> Element(a)
</> 
pub fn sidebar_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn sidebar_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn sidebar_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn sidebar_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn sidebar_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn sidebar_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)
</> 
pub fn sidebar_thin(attrs: List(Attribute(a))) -> Element(a)

sigma_bold

</> 
pub fn sigma_bold(attrs: List(Attribute(a))) -> Element(a)

sigma_duotone

</> 
pub fn sigma_duotone(attrs: List(Attribute(a))) -> Element(a)

sigma_fill

</> 
pub fn sigma_fill(attrs: List(Attribute(a))) -> Element(a)

sigma_light

</> 
pub fn sigma_light(attrs: List(Attribute(a))) -> Element(a)

sigma_regular

</> 
pub fn sigma_regular(attrs: List(Attribute(a))) -> Element(a)

sigma_thin

</> 
pub fn sigma_thin(attrs: List(Attribute(a))) -> Element(a)

sign_in_bold

</> 
pub fn sign_in_bold(attrs: List(Attribute(a))) -> Element(a)

sign_in_duotone

</> 
pub fn sign_in_duotone(attrs: List(Attribute(a))) -> Element(a)

sign_in_fill

</> 
pub fn sign_in_fill(attrs: List(Attribute(a))) -> Element(a)

sign_in_light

</> 
pub fn sign_in_light(attrs: List(Attribute(a))) -> Element(a)

sign_in_regular

</> 
pub fn sign_in_regular(attrs: List(Attribute(a))) -> Element(a)

sign_in_thin

</> 
pub fn sign_in_thin(attrs: List(Attribute(a))) -> Element(a)

sign_out_bold

</> 
pub fn sign_out_bold(attrs: List(Attribute(a))) -> Element(a)

sign_out_duotone

</> 
pub fn sign_out_duotone(attrs: List(Attribute(a))) -> Element(a)

sign_out_fill

</> 
pub fn sign_out_fill(attrs: List(Attribute(a))) -> Element(a)

sign_out_light

</> 
pub fn sign_out_light(attrs: List(Attribute(a))) -> Element(a)

sign_out_regular

</> 
pub fn sign_out_regular(attrs: List(Attribute(a))) -> Element(a)

sign_out_thin

</> 
pub fn sign_out_thin(attrs: List(Attribute(a))) -> Element(a)

signature_bold

</> 
pub fn signature_bold(attrs: List(Attribute(a))) -> Element(a)

signature_duotone

</> 
pub fn signature_duotone(attrs: List(Attribute(a))) -> Element(a)

signature_fill

</> 
pub fn signature_fill(attrs: List(Attribute(a))) -> Element(a)

signature_light

</> 
pub fn signature_light(attrs: List(Attribute(a))) -> Element(a)

signature_regular

</> 
pub fn signature_regular(attrs: List(Attribute(a))) -> Element(a)

signature_thin

</> 
pub fn signature_thin(attrs: List(Attribute(a))) -> Element(a)

signpost_bold

</> 
pub fn signpost_bold(attrs: List(Attribute(a))) -> Element(a)

signpost_duotone

</> 
pub fn signpost_duotone(attrs: List(Attribute(a))) -> Element(a)

signpost_fill

</> 
pub fn signpost_fill(attrs: List(Attribute(a))) -> Element(a)

signpost_light

</> 
pub fn signpost_light(attrs: List(Attribute(a))) -> Element(a)

signpost_regular

</> 
pub fn signpost_regular(attrs: List(Attribute(a))) -> Element(a)

signpost_thin

</> 
pub fn signpost_thin(attrs: List(Attribute(a))) -> Element(a)

sim_card_bold

</> 
pub fn sim_card_bold(attrs: List(Attribute(a))) -> Element(a)

sim_card_duotone

</> 
pub fn sim_card_duotone(attrs: List(Attribute(a))) -> Element(a)

sim_card_fill

</> 
pub fn sim_card_fill(attrs: List(Attribute(a))) -> Element(a)

sim_card_light

</> 
pub fn sim_card_light(attrs: List(Attribute(a))) -> Element(a)

sim_card_regular

</> 
pub fn sim_card_regular(attrs: List(Attribute(a))) -> Element(a)

sim_card_thin

</> 
pub fn sim_card_thin(attrs: List(Attribute(a))) -> Element(a)

siren_bold

</> 
pub fn siren_bold(attrs: List(Attribute(a))) -> Element(a)

siren_duotone

</> 
pub fn siren_duotone(attrs: List(Attribute(a))) -> Element(a)

siren_fill

</> 
pub fn siren_fill(attrs: List(Attribute(a))) -> Element(a)

siren_light

</> 
pub fn siren_light(attrs: List(Attribute(a))) -> Element(a)

siren_regular

</> 
pub fn siren_regular(attrs: List(Attribute(a))) -> Element(a)

siren_thin

</> 
pub fn siren_thin(attrs: List(Attribute(a))) -> Element(a)

sketch_logo_bold

</> 
pub fn sketch_logo_bold(attrs: List(Attribute(a))) -> Element(a)

sketch_logo_duotone

</> 
pub fn sketch_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

sketch_logo_fill

</> 
pub fn sketch_logo_fill(attrs: List(Attribute(a))) -> Element(a)

sketch_logo_light

</> 
pub fn sketch_logo_light(attrs: List(Attribute(a))) -> Element(a)

sketch_logo_regular

</> 
pub fn sketch_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

sketch_logo_thin

</> 
pub fn sketch_logo_thin(attrs: List(Attribute(a))) -> Element(a)

skip_back_bold

</> 
pub fn skip_back_bold(attrs: List(Attribute(a))) -> Element(a)

skip_back_circle_bold

</> 
pub fn skip_back_circle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_back_circle_duotone

</> 
pub fn skip_back_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_back_circle_fill

</> 
pub fn skip_back_circle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_back_circle_light

</> 
pub fn skip_back_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_back_circle_regular

</> 
pub fn skip_back_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_back_circle_thin

</> 
pub fn skip_back_circle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_back_duotone

</> 
pub fn skip_back_duotone(attrs: List(Attribute(a))) -> Element(a)

skip_back_fill

</> 
pub fn skip_back_fill(attrs: List(Attribute(a))) -> Element(a)

skip_back_light

</> 
pub fn skip_back_light(attrs: List(Attribute(a))) -> Element(a)

skip_back_regular

</> 
pub fn skip_back_regular(attrs: List(Attribute(a))) -> Element(a)

skip_back_thin

</> 
pub fn skip_back_thin(attrs: List(Attribute(a))) -> Element(a)

skip_forward_bold

</> 
pub fn skip_forward_bold(attrs: List(Attribute(a))) -> Element(a)

skip_forward_circle_bold

</> 
pub fn skip_forward_circle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_forward_circle_duotone

</> 
pub fn skip_forward_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_forward_circle_fill

</> 
pub fn skip_forward_circle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_forward_circle_light

</> 
pub fn skip_forward_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_forward_circle_regular

</> 
pub fn skip_forward_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_forward_circle_thin

</> 
pub fn skip_forward_circle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_forward_duotone

</> 
pub fn skip_forward_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_forward_fill

</> 
pub fn skip_forward_fill(attrs: List(Attribute(a))) -> Element(a)

skip_forward_light

</> 
pub fn skip_forward_light(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_forward_regular

</> 
pub fn skip_forward_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

skip_forward_thin

</> 
pub fn skip_forward_thin(attrs: List(Attribute(a))) -> Element(a)

skull_bold

</> 
pub fn skull_bold(attrs: List(Attribute(a))) -> Element(a)

skull_duotone

</> 
pub fn skull_duotone(attrs: List(Attribute(a))) -> Element(a)

skull_fill

</> 
pub fn skull_fill(attrs: List(Attribute(a))) -> Element(a)

skull_light

</> 
pub fn skull_light(attrs: List(Attribute(a))) -> Element(a)

skull_regular

</> 
pub fn skull_regular(attrs: List(Attribute(a))) -> Element(a)

skull_thin

</> 
pub fn skull_thin(attrs: List(Attribute(a))) -> Element(a)

skype_logo_bold

</> 
pub fn skype_logo_bold(attrs: List(Attribute(a))) -> Element(a)

skype_logo_duotone

</> 
pub fn skype_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

skype_logo_fill

</> 
pub fn skype_logo_fill(attrs: List(Attribute(a))) -> Element(a)

skype_logo_light

</> 
pub fn skype_logo_light(attrs: List(Attribute(a))) -> Element(a)

skype_logo_regular

</> 
pub fn skype_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

skype_logo_thin

</> 
pub fn skype_logo_thin(attrs: List(Attribute(a))) -> Element(a)

slack_logo_bold

</> 
pub fn slack_logo_bold(attrs: List(Attribute(a))) -> Element(a)

slack_logo_duotone

</> 
pub fn slack_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

slack_logo_fill

</> 
pub fn slack_logo_fill(attrs: List(Attribute(a))) -> Element(a)

slack_logo_light

</> 
pub fn slack_logo_light(attrs: List(Attribute(a))) -> Element(a)

slack_logo_regular

</> 
pub fn slack_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

slack_logo_thin

</> 
pub fn slack_logo_thin(attrs: List(Attribute(a))) -> Element(a)

sliders_bold

</> 
pub fn sliders_bold(attrs: List(Attribute(a))) -> Element(a)

sliders_duotone

</> 
pub fn sliders_duotone(attrs: List(Attribute(a))) -> Element(a)

sliders_fill

</> 
pub fn sliders_fill(attrs: List(Attribute(a))) -> Element(a)

sliders_horizontal_bold

</> 
pub fn sliders_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

sliders_horizontal_duotone

</> 
pub fn sliders_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

sliders_horizontal_fill

</> 
pub fn sliders_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

sliders_horizontal_light

</> 
pub fn sliders_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

sliders_horizontal_regular

</> 
pub fn sliders_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

sliders_horizontal_thin

</> 
pub fn sliders_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

sliders_light

</> 
pub fn sliders_light(attrs: List(Attribute(a))) -> Element(a)

sliders_regular

</> 
pub fn sliders_regular(attrs: List(Attribute(a))) -> Element(a)

sliders_thin

</> 
pub fn sliders_thin(attrs: List(Attribute(a))) -> Element(a)

slideshow_bold

</> 
pub fn slideshow_bold(attrs: List(Attribute(a))) -> Element(a)

slideshow_duotone

</> 
pub fn slideshow_duotone(attrs: List(Attribute(a))) -> Element(a)

slideshow_fill

</> 
pub fn slideshow_fill(attrs: List(Attribute(a))) -> Element(a)

slideshow_light

</> 
pub fn slideshow_light(attrs: List(Attribute(a))) -> Element(a)

slideshow_regular

</> 
pub fn slideshow_regular(attrs: List(Attribute(a))) -> Element(a)

slideshow_thin

</> 
pub fn slideshow_thin(attrs: List(Attribute(a))) -> Element(a)

smiley_angry_bold

</> 
pub fn smiley_angry_bold(attrs: List(Attribute(a))) -> Element(a)

smiley_angry_duotone

</> 
pub fn smiley_angry_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_angry_fill

</> 
pub fn smiley_angry_fill(attrs: List(Attribute(a))) -> Element(a)

smiley_angry_light

</> 
pub fn smiley_angry_light(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_angry_regular

</> 
pub fn smiley_angry_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_angry_thin

</> 
pub fn smiley_angry_thin(attrs: List(Attribute(a))) -> Element(a)

smiley_blank_bold

</> 
pub fn smiley_blank_bold(attrs: List(Attribute(a))) -> Element(a)

smiley_blank_duotone

</> 
pub fn smiley_blank_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_blank_fill

</> 
pub fn smiley_blank_fill(attrs: List(Attribute(a))) -> Element(a)

smiley_blank_light

</> 
pub fn smiley_blank_light(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_blank_regular

</> 
pub fn smiley_blank_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_blank_thin

</> 
pub fn smiley_blank_thin(attrs: List(Attribute(a))) -> Element(a)

smiley_bold

</> 
pub fn smiley_bold(attrs: List(Attribute(a))) -> Element(a)

smiley_duotone

</> 
pub fn smiley_duotone(attrs: List(Attribute(a))) -> Element(a)

smiley_fill

</> 
pub fn smiley_fill(attrs: List(Attribute(a))) -> Element(a)

smiley_light

</> 
pub fn smiley_light(attrs: List(Attribute(a))) -> Element(a)

smiley_meh_bold

</> 
pub fn smiley_meh_bold(attrs: List(Attribute(a))) -> Element(a)

smiley_meh_duotone

</> 
pub fn smiley_meh_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_meh_fill

</> 
pub fn smiley_meh_fill(attrs: List(Attribute(a))) -> Element(a)

smiley_meh_light

</> 
pub fn smiley_meh_light(attrs: List(Attribute(a))) -> Element(a)

smiley_meh_regular

</> 
pub fn smiley_meh_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_meh_thin

</> 
pub fn smiley_meh_thin(attrs: List(Attribute(a))) -> Element(a)

smiley_melting_bold

</> 
pub fn smiley_melting_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_melting_duotone

</> 
pub fn smiley_melting_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_melting_fill

</> 
pub fn smiley_melting_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_melting_light

</> 
pub fn smiley_melting_light(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_melting_regular

</> 
pub fn smiley_melting_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_melting_thin

</> 
pub fn smiley_melting_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_nervous_bold

</> 
pub fn smiley_nervous_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_nervous_duotone

</> 
pub fn smiley_nervous_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_nervous_fill

</> 
pub fn smiley_nervous_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_nervous_light

</> 
pub fn smiley_nervous_light(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_nervous_regular

</> 
pub fn smiley_nervous_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_nervous_thin

</> 
pub fn smiley_nervous_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_regular

</> 
pub fn smiley_regular(attrs: List(Attribute(a))) -> Element(a)

smiley_sad_bold

</> 
pub fn smiley_sad_bold(attrs: List(Attribute(a))) -> Element(a)

smiley_sad_duotone

</> 
pub fn smiley_sad_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_sad_fill

</> 
pub fn smiley_sad_fill(attrs: List(Attribute(a))) -> Element(a)

smiley_sad_light

</> 
pub fn smiley_sad_light(attrs: List(Attribute(a))) -> Element(a)

smiley_sad_regular

</> 
pub fn smiley_sad_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_sad_thin

</> 
pub fn smiley_sad_thin(attrs: List(Attribute(a))) -> Element(a)

smiley_sticker_bold

</> 
pub fn smiley_sticker_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_sticker_duotone

</> 
pub fn smiley_sticker_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_sticker_fill

</> 
pub fn smiley_sticker_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_sticker_light

</> 
pub fn smiley_sticker_light(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_sticker_regular

</> 
pub fn smiley_sticker_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_sticker_thin

</> 
pub fn smiley_sticker_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_thin

</> 
pub fn smiley_thin(attrs: List(Attribute(a))) -> Element(a)

smiley_wink_bold

</> 
pub fn smiley_wink_bold(attrs: List(Attribute(a))) -> Element(a)

smiley_wink_duotone

</> 
pub fn smiley_wink_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_wink_fill

</> 
pub fn smiley_wink_fill(attrs: List(Attribute(a))) -> Element(a)

smiley_wink_light

</> 
pub fn smiley_wink_light(attrs: List(Attribute(a))) -> Element(a)

smiley_wink_regular

</> 
pub fn smiley_wink_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_wink_thin

</> 
pub fn smiley_wink_thin(attrs: List(Attribute(a))) -> Element(a)

smiley_x_eyes_bold

</> 
pub fn smiley_x_eyes_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_x_eyes_duotone

</> 
pub fn smiley_x_eyes_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_x_eyes_fill

</> 
pub fn smiley_x_eyes_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_x_eyes_light

</> 
pub fn smiley_x_eyes_light(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_x_eyes_regular

</> 
pub fn smiley_x_eyes_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

smiley_x_eyes_thin

</> 
pub fn smiley_x_eyes_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

snapchat_logo_bold

</> 
pub fn snapchat_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

snapchat_logo_duotone

</> 
pub fn snapchat_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

snapchat_logo_fill

</> 
pub fn snapchat_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

snapchat_logo_light

</> 
pub fn snapchat_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

snapchat_logo_regular

</> 
pub fn snapchat_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

snapchat_logo_thin

</> 
pub fn snapchat_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

sneaker_bold

</> 
pub fn sneaker_bold(attrs: List(Attribute(a))) -> Element(a)

sneaker_duotone

</> 
pub fn sneaker_duotone(attrs: List(Attribute(a))) -> Element(a)

sneaker_fill

</> 
pub fn sneaker_fill(attrs: List(Attribute(a))) -> Element(a)

sneaker_light

</> 
pub fn sneaker_light(attrs: List(Attribute(a))) -> Element(a)

sneaker_move_bold

</> 
pub fn sneaker_move_bold(attrs: List(Attribute(a))) -> Element(a)

sneaker_move_duotone

</> 
pub fn sneaker_move_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

sneaker_move_fill

</> 
pub fn sneaker_move_fill(attrs: List(Attribute(a))) -> Element(a)

sneaker_move_light

</> 
pub fn sneaker_move_light(
  attrs: List(Attribute(a)),
) -> Element(a)

sneaker_move_regular

</> 
pub fn sneaker_move_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

sneaker_move_thin

</> 
pub fn sneaker_move_thin(attrs: List(Attribute(a))) -> Element(a)

sneaker_regular

</> 
pub fn sneaker_regular(attrs: List(Attribute(a))) -> Element(a)

sneaker_thin

</> 
pub fn sneaker_thin(attrs: List(Attribute(a))) -> Element(a)

snowflake_bold

</> 
pub fn snowflake_bold(attrs: List(Attribute(a))) -> Element(a)

snowflake_duotone

</> 
pub fn snowflake_duotone(attrs: List(Attribute(a))) -> Element(a)

snowflake_fill

</> 
pub fn snowflake_fill(attrs: List(Attribute(a))) -> Element(a)

snowflake_light

</> 
pub fn snowflake_light(attrs: List(Attribute(a))) -> Element(a)

snowflake_regular

</> 
pub fn snowflake_regular(attrs: List(Attribute(a))) -> Element(a)

snowflake_thin

</> 
pub fn snowflake_thin(attrs: List(Attribute(a))) -> Element(a)

soccer_ball_bold

</> 
pub fn soccer_ball_bold(attrs: List(Attribute(a))) -> Element(a)

soccer_ball_duotone

</> 
pub fn soccer_ball_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

soccer_ball_fill

</> 
pub fn soccer_ball_fill(attrs: List(Attribute(a))) -> Element(a)

soccer_ball_light

</> 
pub fn soccer_ball_light(attrs: List(Attribute(a))) -> Element(a)

soccer_ball_regular

</> 
pub fn soccer_ball_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

soccer_ball_thin

</> 
pub fn soccer_ball_thin(attrs: List(Attribute(a))) -> Element(a)

sock_bold

</> 
pub fn sock_bold(attrs: List(Attribute(a))) -> Element(a)

sock_duotone

</> 
pub fn sock_duotone(attrs: List(Attribute(a))) -> Element(a)

sock_fill

</> 
pub fn sock_fill(attrs: List(Attribute(a))) -> Element(a)

sock_light

</> 
pub fn sock_light(attrs: List(Attribute(a))) -> Element(a)

sock_regular

</> 
pub fn sock_regular(attrs: List(Attribute(a))) -> Element(a)

sock_thin

</> 
pub fn sock_thin(attrs: List(Attribute(a))) -> Element(a)

solar_panel_bold

</> 
pub fn solar_panel_bold(attrs: List(Attribute(a))) -> Element(a)

solar_panel_duotone

</> 
pub fn solar_panel_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

solar_panel_fill

</> 
pub fn solar_panel_fill(attrs: List(Attribute(a))) -> Element(a)

solar_panel_light

</> 
pub fn solar_panel_light(attrs: List(Attribute(a))) -> Element(a)

solar_panel_regular

</> 
pub fn solar_panel_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

solar_panel_thin

</> 
pub fn solar_panel_thin(attrs: List(Attribute(a))) -> Element(a)

solar_roof_bold

</> 
pub fn solar_roof_bold(attrs: List(Attribute(a))) -> Element(a)

solar_roof_duotone

</> 
pub fn solar_roof_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

solar_roof_fill

</> 
pub fn solar_roof_fill(attrs: List(Attribute(a))) -> Element(a)

solar_roof_light

</> 
pub fn solar_roof_light(attrs: List(Attribute(a))) -> Element(a)

solar_roof_regular

</> 
pub fn solar_roof_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

solar_roof_thin

</> 
pub fn solar_roof_thin(attrs: List(Attribute(a))) -> Element(a)

sort_ascending_bold

</> 
pub fn sort_ascending_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_ascending_duotone

</> 
pub fn sort_ascending_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_ascending_fill

</> 
pub fn sort_ascending_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_ascending_light

</> 
pub fn sort_ascending_light(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_ascending_regular

</> 
pub fn sort_ascending_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_ascending_thin

</> 
pub fn sort_ascending_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_descending_bold

</> 
pub fn sort_descending_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_descending_duotone

</> 
pub fn sort_descending_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_descending_fill

</> 
pub fn sort_descending_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_descending_light

</> 
pub fn sort_descending_light(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_descending_regular

</> 
pub fn sort_descending_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

sort_descending_thin

</> 
pub fn sort_descending_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

soundcloud_logo_bold

</> 
pub fn soundcloud_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

soundcloud_logo_duotone

</> 
pub fn soundcloud_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

soundcloud_logo_fill

</> 
pub fn soundcloud_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

soundcloud_logo_light

</> 
pub fn soundcloud_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

soundcloud_logo_regular

</> 
pub fn soundcloud_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

soundcloud_logo_thin

</> 
pub fn soundcloud_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

spade_bold

</> 
pub fn spade_bold(attrs: List(Attribute(a))) -> Element(a)

spade_duotone

</> 
pub fn spade_duotone(attrs: List(Attribute(a))) -> Element(a)

spade_fill

</> 
pub fn spade_fill(attrs: List(Attribute(a))) -> Element(a)

spade_light

</> 
pub fn spade_light(attrs: List(Attribute(a))) -> Element(a)

spade_regular

</> 
pub fn spade_regular(attrs: List(Attribute(a))) -> Element(a)

spade_thin

</> 
pub fn spade_thin(attrs: List(Attribute(a))) -> Element(a)

sparkle_bold

</> 
pub fn sparkle_bold(attrs: List(Attribute(a))) -> Element(a)

sparkle_duotone

</> 
pub fn sparkle_duotone(attrs: List(Attribute(a))) -> Element(a)

sparkle_fill

</> 
pub fn sparkle_fill(attrs: List(Attribute(a))) -> Element(a)

sparkle_light

</> 
pub fn sparkle_light(attrs: List(Attribute(a))) -> Element(a)

sparkle_regular

</> 
pub fn sparkle_regular(attrs: List(Attribute(a))) -> Element(a)

sparkle_thin

</> 
pub fn sparkle_thin(attrs: List(Attribute(a))) -> Element(a)

speaker_hifi_bold

</> 
pub fn speaker_hifi_bold(attrs: List(Attribute(a))) -> Element(a)

speaker_hifi_duotone

</> 
pub fn speaker_hifi_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_hifi_fill

</> 
pub fn speaker_hifi_fill(attrs: List(Attribute(a))) -> Element(a)

speaker_hifi_light

</> 
pub fn speaker_hifi_light(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_hifi_regular

</> 
pub fn speaker_hifi_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_hifi_thin

</> 
pub fn speaker_hifi_thin(attrs: List(Attribute(a))) -> Element(a)

speaker_high_bold

</> 
pub fn speaker_high_bold(attrs: List(Attribute(a))) -> Element(a)

speaker_high_duotone

</> 
pub fn speaker_high_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_high_fill

</> 
pub fn speaker_high_fill(attrs: List(Attribute(a))) -> Element(a)

speaker_high_light

</> 
pub fn speaker_high_light(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_high_regular

</> 
pub fn speaker_high_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_high_thin

</> 
pub fn speaker_high_thin(attrs: List(Attribute(a))) -> Element(a)

speaker_low_bold

</> 
pub fn speaker_low_bold(attrs: List(Attribute(a))) -> Element(a)

speaker_low_duotone

</> 
pub fn speaker_low_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_low_fill

</> 
pub fn speaker_low_fill(attrs: List(Attribute(a))) -> Element(a)

speaker_low_light

</> 
pub fn speaker_low_light(attrs: List(Attribute(a))) -> Element(a)

speaker_low_regular

</> 
pub fn speaker_low_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_low_thin

</> 
pub fn speaker_low_thin(attrs: List(Attribute(a))) -> Element(a)

speaker_none_bold

</> 
pub fn speaker_none_bold(attrs: List(Attribute(a))) -> Element(a)

speaker_none_duotone

</> 
pub fn speaker_none_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_none_fill

</> 
pub fn speaker_none_fill(attrs: List(Attribute(a))) -> Element(a)

speaker_none_light

</> 
pub fn speaker_none_light(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_none_regular

</> 
pub fn speaker_none_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_none_thin

</> 
pub fn speaker_none_thin(attrs: List(Attribute(a))) -> Element(a)

speaker_simple_high_bold

</> 
pub fn speaker_simple_high_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_high_duotone

</> 
pub fn speaker_simple_high_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_high_fill

</> 
pub fn speaker_simple_high_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_high_light

</> 
pub fn speaker_simple_high_light(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_high_regular

</> 
pub fn speaker_simple_high_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_high_thin

</> 
pub fn speaker_simple_high_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_low_bold

</> 
pub fn speaker_simple_low_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_low_duotone

</> 
pub fn speaker_simple_low_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_low_fill

</> 
pub fn speaker_simple_low_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_low_light

</> 
pub fn speaker_simple_low_light(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_low_regular

</> 
pub fn speaker_simple_low_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_low_thin

</> 
pub fn speaker_simple_low_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_none_bold

</> 
pub fn speaker_simple_none_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_none_duotone

</> 
pub fn speaker_simple_none_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_none_fill

</> 
pub fn speaker_simple_none_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_none_light

</> 
pub fn speaker_simple_none_light(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_none_regular

</> 
pub fn speaker_simple_none_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_none_thin

</> 
pub fn speaker_simple_none_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_slash_bold

</> 
pub fn speaker_simple_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_slash_duotone

</> 
pub fn speaker_simple_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_slash_fill

</> 
pub fn speaker_simple_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_slash_light

</> 
pub fn speaker_simple_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_slash_regular

</> 
pub fn speaker_simple_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_slash_thin

</> 
pub fn speaker_simple_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_x_bold

</> 
pub fn speaker_simple_x_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_x_duotone

</> 
pub fn speaker_simple_x_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_x_fill

</> 
pub fn speaker_simple_x_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_x_light

</> 
pub fn speaker_simple_x_light(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_x_regular

</> 
pub fn speaker_simple_x_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_simple_x_thin

</> 
pub fn speaker_simple_x_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_slash_bold

</> 
pub fn speaker_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_slash_duotone

</> 
pub fn speaker_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_slash_fill

</> 
pub fn speaker_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_slash_light

</> 
pub fn speaker_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_slash_regular

</> 
pub fn speaker_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_slash_thin

</> 
pub fn speaker_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

speaker_x_bold

</> 
pub fn speaker_x_bold(attrs: List(Attribute(a))) -> Element(a)

speaker_x_duotone

</> 
pub fn speaker_x_duotone(attrs: List(Attribute(a))) -> Element(a)

speaker_x_fill

</> 
pub fn speaker_x_fill(attrs: List(Attribute(a))) -> Element(a)

speaker_x_light

</> 
pub fn speaker_x_light(attrs: List(Attribute(a))) -> Element(a)

speaker_x_regular

</> 
pub fn speaker_x_regular(attrs: List(Attribute(a))) -> Element(a)

speaker_x_thin

</> 
pub fn speaker_x_thin(attrs: List(Attribute(a))) -> Element(a)

speedometer_bold

</> 
pub fn speedometer_bold(attrs: List(Attribute(a))) -> Element(a)

speedometer_duotone

</> 
pub fn speedometer_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

speedometer_fill

</> 
pub fn speedometer_fill(attrs: List(Attribute(a))) -> Element(a)

speedometer_light

</> 
pub fn speedometer_light(attrs: List(Attribute(a))) -> Element(a)

speedometer_regular

</> 
pub fn speedometer_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

speedometer_thin

</> 
pub fn speedometer_thin(attrs: List(Attribute(a))) -> Element(a)

sphere_bold

</> 
pub fn sphere_bold(attrs: List(Attribute(a))) -> Element(a)

sphere_duotone

</> 
pub fn sphere_duotone(attrs: List(Attribute(a))) -> Element(a)

sphere_fill

</> 
pub fn sphere_fill(attrs: List(Attribute(a))) -> Element(a)

sphere_light

</> 
pub fn sphere_light(attrs: List(Attribute(a))) -> Element(a)

sphere_regular

</> 
pub fn sphere_regular(attrs: List(Attribute(a))) -> Element(a)

sphere_thin

</> 
pub fn sphere_thin(attrs: List(Attribute(a))) -> Element(a)

spinner_ball_bold

</> 
pub fn spinner_ball_bold(attrs: List(Attribute(a))) -> Element(a)

spinner_ball_duotone

</> 
pub fn spinner_ball_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

spinner_ball_fill

</> 
pub fn spinner_ball_fill(attrs: List(Attribute(a))) -> Element(a)

spinner_ball_light

</> 
pub fn spinner_ball_light(
  attrs: List(Attribute(a)),
) -> Element(a)

spinner_ball_regular

</> 
pub fn spinner_ball_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

spinner_ball_thin

</> 
pub fn spinner_ball_thin(attrs: List(Attribute(a))) -> Element(a)

spinner_bold

</> 
pub fn spinner_bold(attrs: List(Attribute(a))) -> Element(a)

spinner_duotone

</> 
pub fn spinner_duotone(attrs: List(Attribute(a))) -> Element(a)

spinner_fill

</> 
pub fn spinner_fill(attrs: List(Attribute(a))) -> Element(a)

spinner_gap_bold

</> 
pub fn spinner_gap_bold(attrs: List(Attribute(a))) -> Element(a)

spinner_gap_duotone

</> 
pub fn spinner_gap_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

spinner_gap_fill

</> 
pub fn spinner_gap_fill(attrs: List(Attribute(a))) -> Element(a)

spinner_gap_light

</> 
pub fn spinner_gap_light(attrs: List(Attribute(a))) -> Element(a)

spinner_gap_regular

</> 
pub fn spinner_gap_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

spinner_gap_thin

</> 
pub fn spinner_gap_thin(attrs: List(Attribute(a))) -> Element(a)

spinner_light

</> 
pub fn spinner_light(attrs: List(Attribute(a))) -> Element(a)

spinner_regular

</> 
pub fn spinner_regular(attrs: List(Attribute(a))) -> Element(a)

spinner_thin

</> 
pub fn spinner_thin(attrs: List(Attribute(a))) -> Element(a)

spiral_bold

</> 
pub fn spiral_bold(attrs: List(Attribute(a))) -> Element(a)

spiral_duotone

</> 
pub fn spiral_duotone(attrs: List(Attribute(a))) -> Element(a)

spiral_fill

</> 
pub fn spiral_fill(attrs: List(Attribute(a))) -> Element(a)

spiral_light

</> 
pub fn spiral_light(attrs: List(Attribute(a))) -> Element(a)

spiral_regular

</> 
pub fn spiral_regular(attrs: List(Attribute(a))) -> Element(a)

spiral_thin

</> 
pub fn spiral_thin(attrs: List(Attribute(a))) -> Element(a)

split_horizontal_bold

</> 
pub fn split_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

split_horizontal_duotone

</> 
pub fn split_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

split_horizontal_fill

</> 
pub fn split_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

split_horizontal_light

</> 
pub fn split_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

split_horizontal_regular

</> 
pub fn split_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

split_horizontal_thin

</> 
pub fn split_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

split_vertical_bold

</> 
pub fn split_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

split_vertical_duotone

</> 
pub fn split_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

split_vertical_fill

</> 
pub fn split_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

split_vertical_light

</> 
pub fn split_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

split_vertical_regular

</> 
pub fn split_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

split_vertical_thin

</> 
pub fn split_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

spotify_logo_bold

</> 
pub fn spotify_logo_bold(attrs: List(Attribute(a))) -> Element(a)

spotify_logo_duotone

</> 
pub fn spotify_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

spotify_logo_fill

</> 
pub fn spotify_logo_fill(attrs: List(Attribute(a))) -> Element(a)

spotify_logo_light

</> 
pub fn spotify_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

spotify_logo_regular

</> 
pub fn spotify_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

spotify_logo_thin

</> 
pub fn spotify_logo_thin(attrs: List(Attribute(a))) -> Element(a)

spray_bottle_bold

</> 
pub fn spray_bottle_bold(attrs: List(Attribute(a))) -> Element(a)

spray_bottle_duotone

</> 
pub fn spray_bottle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

spray_bottle_fill

</> 
pub fn spray_bottle_fill(attrs: List(Attribute(a))) -> Element(a)

spray_bottle_light

</> 
pub fn spray_bottle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

spray_bottle_regular

</> 
pub fn spray_bottle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

spray_bottle_thin

</> 
pub fn spray_bottle_thin(attrs: List(Attribute(a))) -> Element(a)

square_bold

</> 
pub fn square_bold(attrs: List(Attribute(a))) -> Element(a)

square_duotone

</> 
pub fn square_duotone(attrs: List(Attribute(a))) -> Element(a)

square_fill

</> 
pub fn square_fill(attrs: List(Attribute(a))) -> Element(a)

square_half_bold

</> 
pub fn square_half_bold(attrs: List(Attribute(a))) -> Element(a)

square_half_bottom_bold

</> 
pub fn square_half_bottom_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

square_half_bottom_duotone

</> 
pub fn square_half_bottom_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

square_half_bottom_fill

</> 
pub fn square_half_bottom_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

square_half_bottom_light

</> 
pub fn square_half_bottom_light(
  attrs: List(Attribute(a)),
) -> Element(a)

square_half_bottom_regular

</> 
pub fn square_half_bottom_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

square_half_bottom_thin

</> 
pub fn square_half_bottom_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

square_half_duotone

</> 
pub fn square_half_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

square_half_fill

</> 
pub fn square_half_fill(attrs: List(Attribute(a))) -> Element(a)

square_half_light

</> 
pub fn square_half_light(attrs: List(Attribute(a))) -> Element(a)

square_half_regular

</> 
pub fn square_half_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

square_half_thin

</> 
pub fn square_half_thin(attrs: List(Attribute(a))) -> Element(a)

square_light

</> 
pub fn square_light(attrs: List(Attribute(a))) -> Element(a)

square_logo_bold

</> 
pub fn square_logo_bold(attrs: List(Attribute(a))) -> Element(a)

square_logo_duotone

</> 
pub fn square_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

square_logo_fill

</> 
pub fn square_logo_fill(attrs: List(Attribute(a))) -> Element(a)

square_logo_light

</> 
pub fn square_logo_light(attrs: List(Attribute(a))) -> Element(a)

square_logo_regular

</> 
pub fn square_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

square_logo_thin

</> 
pub fn square_logo_thin(attrs: List(Attribute(a))) -> Element(a)

square_regular

</> 
pub fn square_regular(attrs: List(Attribute(a))) -> Element(a)

square_split_horizontal_bold

</> 
pub fn square_split_horizontal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_horizontal_duotone

</> 
pub fn square_split_horizontal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_horizontal_fill

</> 
pub fn square_split_horizontal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_horizontal_light

</> 
pub fn square_split_horizontal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_horizontal_regular

</> 
pub fn square_split_horizontal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_horizontal_thin

</> 
pub fn square_split_horizontal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_vertical_bold

</> 
pub fn square_split_vertical_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_vertical_duotone

</> 
pub fn square_split_vertical_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_vertical_fill

</> 
pub fn square_split_vertical_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_vertical_light

</> 
pub fn square_split_vertical_light(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_vertical_regular

</> 
pub fn square_split_vertical_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

square_split_vertical_thin

</> 
pub fn square_split_vertical_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

square_thin

</> 
pub fn square_thin(attrs: List(Attribute(a))) -> Element(a)

squares_four_bold

</> 
pub fn squares_four_bold(attrs: List(Attribute(a))) -> Element(a)

squares_four_duotone

</> 
pub fn squares_four_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

squares_four_fill

</> 
pub fn squares_four_fill(attrs: List(Attribute(a))) -> Element(a)

squares_four_light

</> 
pub fn squares_four_light(
  attrs: List(Attribute(a)),
) -> Element(a)

squares_four_regular

</> 
pub fn squares_four_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

squares_four_thin

</> 
pub fn squares_four_thin(attrs: List(Attribute(a))) -> Element(a)

stack_bold

</> 
pub fn stack_bold(attrs: List(Attribute(a))) -> Element(a)

stack_duotone

</> 
pub fn stack_duotone(attrs: List(Attribute(a))) -> Element(a)

stack_fill

</> 
pub fn stack_fill(attrs: List(Attribute(a))) -> Element(a)

stack_light

</> 
pub fn stack_light(attrs: List(Attribute(a))) -> Element(a)

stack_minus_bold

</> 
pub fn stack_minus_bold(attrs: List(Attribute(a))) -> Element(a)

stack_minus_duotone

</> 
pub fn stack_minus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_minus_fill

</> 
pub fn stack_minus_fill(attrs: List(Attribute(a))) -> Element(a)

stack_minus_light

</> 
pub fn stack_minus_light(attrs: List(Attribute(a))) -> Element(a)

stack_minus_regular

</> 
pub fn stack_minus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_minus_thin

</> 
pub fn stack_minus_thin(attrs: List(Attribute(a))) -> Element(a)

stack_overflow_logo_bold

</> 
pub fn stack_overflow_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_overflow_logo_duotone

</> 
pub fn stack_overflow_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_overflow_logo_fill

</> 
pub fn stack_overflow_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_overflow_logo_light

</> 
pub fn stack_overflow_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_overflow_logo_regular

</> 
pub fn stack_overflow_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_overflow_logo_thin

</> 
pub fn stack_overflow_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_plus_bold

</> 
pub fn stack_plus_bold(attrs: List(Attribute(a))) -> Element(a)

stack_plus_duotone

</> 
pub fn stack_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_plus_fill

</> 
pub fn stack_plus_fill(attrs: List(Attribute(a))) -> Element(a)

stack_plus_light

</> 
pub fn stack_plus_light(attrs: List(Attribute(a))) -> Element(a)

stack_plus_regular

</> 
pub fn stack_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_plus_thin

</> 
pub fn stack_plus_thin(attrs: List(Attribute(a))) -> Element(a)

stack_regular

</> 
pub fn stack_regular(attrs: List(Attribute(a))) -> Element(a)

stack_simple_bold

</> 
pub fn stack_simple_bold(attrs: List(Attribute(a))) -> Element(a)

stack_simple_duotone

</> 
pub fn stack_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_simple_fill

</> 
pub fn stack_simple_fill(attrs: List(Attribute(a))) -> Element(a)

stack_simple_light

</> 
pub fn stack_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_simple_regular

</> 
pub fn stack_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

stack_simple_thin

</> 
pub fn stack_simple_thin(attrs: List(Attribute(a))) -> Element(a)

stack_thin

</> 
pub fn stack_thin(attrs: List(Attribute(a))) -> Element(a)

stairs_bold

</> 
pub fn stairs_bold(attrs: List(Attribute(a))) -> Element(a)

stairs_duotone

</> 
pub fn stairs_duotone(attrs: List(Attribute(a))) -> Element(a)

stairs_fill

</> 
pub fn stairs_fill(attrs: List(Attribute(a))) -> Element(a)

stairs_light

</> 
pub fn stairs_light(attrs: List(Attribute(a))) -> Element(a)

stairs_regular

</> 
pub fn stairs_regular(attrs: List(Attribute(a))) -> Element(a)

stairs_thin

</> 
pub fn stairs_thin(attrs: List(Attribute(a))) -> Element(a)

stamp_bold

</> 
pub fn stamp_bold(attrs: List(Attribute(a))) -> Element(a)

stamp_duotone

</> 
pub fn stamp_duotone(attrs: List(Attribute(a))) -> Element(a)

stamp_fill

</> 
pub fn stamp_fill(attrs: List(Attribute(a))) -> Element(a)

stamp_light

</> 
pub fn stamp_light(attrs: List(Attribute(a))) -> Element(a)

stamp_regular

</> 
pub fn stamp_regular(attrs: List(Attribute(a))) -> Element(a)

stamp_thin

</> 
pub fn stamp_thin(attrs: List(Attribute(a))) -> Element(a)

standard_definition_bold

</> 
pub fn standard_definition_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

standard_definition_duotone

</> 
pub fn standard_definition_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

standard_definition_fill

</> 
pub fn standard_definition_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

standard_definition_light

</> 
pub fn standard_definition_light(
  attrs: List(Attribute(a)),
) -> Element(a)

standard_definition_regular

</> 
pub fn standard_definition_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

standard_definition_thin

</> 
pub fn standard_definition_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

star_and_crescent_bold

</> 
pub fn star_and_crescent_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

star_and_crescent_duotone

</> 
pub fn star_and_crescent_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

star_and_crescent_fill

</> 
pub fn star_and_crescent_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

star_and_crescent_light

</> 
pub fn star_and_crescent_light(
  attrs: List(Attribute(a)),
) -> Element(a)

star_and_crescent_regular

</> 
pub fn star_and_crescent_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

star_and_crescent_thin

</> 
pub fn star_and_crescent_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

star_bold

</> 
pub fn star_bold(attrs: List(Attribute(a))) -> Element(a)

star_duotone

</> 
pub fn star_duotone(attrs: List(Attribute(a))) -> Element(a)

star_fill

</> 
pub fn star_fill(attrs: List(Attribute(a))) -> Element(a)

star_four_bold

</> 
pub fn star_four_bold(attrs: List(Attribute(a))) -> Element(a)

star_four_duotone

</> 
pub fn star_four_duotone(attrs: List(Attribute(a))) -> Element(a)

star_four_fill

</> 
pub fn star_four_fill(attrs: List(Attribute(a))) -> Element(a)

star_four_light

</> 
pub fn star_four_light(attrs: List(Attribute(a))) -> Element(a)

star_four_regular

</> 
pub fn star_four_regular(attrs: List(Attribute(a))) -> Element(a)

star_four_thin

</> 
pub fn star_four_thin(attrs: List(Attribute(a))) -> Element(a)

star_half_bold

</> 
pub fn star_half_bold(attrs: List(Attribute(a))) -> Element(a)

star_half_duotone

</> 
pub fn star_half_duotone(attrs: List(Attribute(a))) -> Element(a)

star_half_fill

</> 
pub fn star_half_fill(attrs: List(Attribute(a))) -> Element(a)

star_half_light

</> 
pub fn star_half_light(attrs: List(Attribute(a))) -> Element(a)

star_half_regular

</> 
pub fn star_half_regular(attrs: List(Attribute(a))) -> Element(a)

star_half_thin

</> 
pub fn star_half_thin(attrs: List(Attribute(a))) -> Element(a)

star_light

</> 
pub fn star_light(attrs: List(Attribute(a))) -> Element(a)

star_of_david_bold

</> 
pub fn star_of_david_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

star_of_david_duotone

</> 
pub fn star_of_david_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

star_of_david_fill

</> 
pub fn star_of_david_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

star_of_david_light

</> 
pub fn star_of_david_light(
  attrs: List(Attribute(a)),
) -> Element(a)

star_of_david_regular

</> 
pub fn star_of_david_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

star_of_david_thin

</> 
pub fn star_of_david_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

star_regular

</> 
pub fn star_regular(attrs: List(Attribute(a))) -> Element(a)

star_thin

</> 
pub fn star_thin(attrs: List(Attribute(a))) -> Element(a)

steam_logo_bold

</> 
pub fn steam_logo_bold(attrs: List(Attribute(a))) -> Element(a)

steam_logo_duotone

</> 
pub fn steam_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

steam_logo_fill

</> 
pub fn steam_logo_fill(attrs: List(Attribute(a))) -> Element(a)

steam_logo_light

</> 
pub fn steam_logo_light(attrs: List(Attribute(a))) -> Element(a)

steam_logo_regular

</> 
pub fn steam_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

steam_logo_thin

</> 
pub fn steam_logo_thin(attrs: List(Attribute(a))) -> Element(a)

steering_wheel_bold

</> 
pub fn steering_wheel_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

steering_wheel_duotone

</> 
pub fn steering_wheel_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

steering_wheel_fill

</> 
pub fn steering_wheel_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

steering_wheel_light

</> 
pub fn steering_wheel_light(
  attrs: List(Attribute(a)),
) -> Element(a)

steering_wheel_regular

</> 
pub fn steering_wheel_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

steering_wheel_thin

</> 
pub fn steering_wheel_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

steps_bold

</> 
pub fn steps_bold(attrs: List(Attribute(a))) -> Element(a)

steps_duotone

</> 
pub fn steps_duotone(attrs: List(Attribute(a))) -> Element(a)

steps_fill

</> 
pub fn steps_fill(attrs: List(Attribute(a))) -> Element(a)

steps_light

</> 
pub fn steps_light(attrs: List(Attribute(a))) -> Element(a)

steps_regular

</> 
pub fn steps_regular(attrs: List(Attribute(a))) -> Element(a)

steps_thin

</> 
pub fn steps_thin(attrs: List(Attribute(a))) -> Element(a)

stethoscope_bold

</> 
pub fn stethoscope_bold(attrs: List(Attribute(a))) -> Element(a)

stethoscope_duotone

</> 
pub fn stethoscope_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

stethoscope_fill

</> 
pub fn stethoscope_fill(attrs: List(Attribute(a))) -> Element(a)

stethoscope_light

</> 
pub fn stethoscope_light(attrs: List(Attribute(a))) -> Element(a)

stethoscope_regular

</> 
pub fn stethoscope_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

stethoscope_thin

</> 
pub fn stethoscope_thin(attrs: List(Attribute(a))) -> Element(a)

sticker_bold

</> 
pub fn sticker_bold(attrs: List(Attribute(a))) -> Element(a)

sticker_duotone

</> 
pub fn sticker_duotone(attrs: List(Attribute(a))) -> Element(a)

sticker_fill

</> 
pub fn sticker_fill(attrs: List(Attribute(a))) -> Element(a)

sticker_light

</> 
pub fn sticker_light(attrs: List(Attribute(a))) -> Element(a)

sticker_regular

</> 
pub fn sticker_regular(attrs: List(Attribute(a))) -> Element(a)

sticker_thin

</> 
pub fn sticker_thin(attrs: List(Attribute(a))) -> Element(a)

stool_bold

</> 
pub fn stool_bold(attrs: List(Attribute(a))) -> Element(a)

stool_duotone

</> 
pub fn stool_duotone(attrs: List(Attribute(a))) -> Element(a)

stool_fill

</> 
pub fn stool_fill(attrs: List(Attribute(a))) -> Element(a)

stool_light

</> 
pub fn stool_light(attrs: List(Attribute(a))) -> Element(a)

stool_regular

</> 
pub fn stool_regular(attrs: List(Attribute(a))) -> Element(a)

stool_thin

</> 
pub fn stool_thin(attrs: List(Attribute(a))) -> Element(a)

stop_bold

</> 
pub fn stop_bold(attrs: List(Attribute(a))) -> Element(a)

stop_circle_bold

</> 
pub fn stop_circle_bold(attrs: List(Attribute(a))) -> Element(a)

stop_circle_duotone

</> 
pub fn stop_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

stop_circle_fill

</> 
pub fn stop_circle_fill(attrs: List(Attribute(a))) -> Element(a)

stop_circle_light

</> 
pub fn stop_circle_light(attrs: List(Attribute(a))) -> Element(a)

stop_circle_regular

</> 
pub fn stop_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

stop_circle_thin

</> 
pub fn stop_circle_thin(attrs: List(Attribute(a))) -> Element(a)

stop_duotone

</> 
pub fn stop_duotone(attrs: List(Attribute(a))) -> Element(a)

stop_fill

</> 
pub fn stop_fill(attrs: List(Attribute(a))) -> Element(a)

stop_light

</> 
pub fn stop_light(attrs: List(Attribute(a))) -> Element(a)

stop_regular

</> 
pub fn stop_regular(attrs: List(Attribute(a))) -> Element(a)

stop_thin

</> 
pub fn stop_thin(attrs: List(Attribute(a))) -> Element(a)

storefront_bold

</> 
pub fn storefront_bold(attrs: List(Attribute(a))) -> Element(a)

storefront_duotone

</> 
pub fn storefront_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

storefront_fill

</> 
pub fn storefront_fill(attrs: List(Attribute(a))) -> Element(a)

storefront_light

</> 
pub fn storefront_light(attrs: List(Attribute(a))) -> Element(a)

storefront_regular

</> 
pub fn storefront_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

storefront_thin

</> 
pub fn storefront_thin(attrs: List(Attribute(a))) -> Element(a)

strategy_bold

</> 
pub fn strategy_bold(attrs: List(Attribute(a))) -> Element(a)

strategy_duotone

</> 
pub fn strategy_duotone(attrs: List(Attribute(a))) -> Element(a)

strategy_fill

</> 
pub fn strategy_fill(attrs: List(Attribute(a))) -> Element(a)

strategy_light

</> 
pub fn strategy_light(attrs: List(Attribute(a))) -> Element(a)

strategy_regular

</> 
pub fn strategy_regular(attrs: List(Attribute(a))) -> Element(a)

strategy_thin

</> 
pub fn strategy_thin(attrs: List(Attribute(a))) -> Element(a)

stripe_logo_bold

</> 
pub fn stripe_logo_bold(attrs: List(Attribute(a))) -> Element(a)

stripe_logo_duotone

</> 
pub fn stripe_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

stripe_logo_fill

</> 
pub fn stripe_logo_fill(attrs: List(Attribute(a))) -> Element(a)

stripe_logo_light

</> 
pub fn stripe_logo_light(attrs: List(Attribute(a))) -> Element(a)

stripe_logo_regular

</> 
pub fn stripe_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

stripe_logo_thin

</> 
pub fn stripe_logo_thin(attrs: List(Attribute(a))) -> Element(a)

student_bold

</> 
pub fn student_bold(attrs: List(Attribute(a))) -> Element(a)

student_duotone

</> 
pub fn student_duotone(attrs: List(Attribute(a))) -> Element(a)

student_fill

</> 
pub fn student_fill(attrs: List(Attribute(a))) -> Element(a)

student_light

</> 
pub fn student_light(attrs: List(Attribute(a))) -> Element(a)

student_regular

</> 
pub fn student_regular(attrs: List(Attribute(a))) -> Element(a)

student_thin

</> 
pub fn student_thin(attrs: List(Attribute(a))) -> Element(a)

subset_of_bold

</> 
pub fn subset_of_bold(attrs: List(Attribute(a))) -> Element(a)

subset_of_duotone

</> 
pub fn subset_of_duotone(attrs: List(Attribute(a))) -> Element(a)

subset_of_fill

</> 
pub fn subset_of_fill(attrs: List(Attribute(a))) -> Element(a)

subset_of_light

</> 
pub fn subset_of_light(attrs: List(Attribute(a))) -> Element(a)

subset_of_regular

</> 
pub fn subset_of_regular(attrs: List(Attribute(a))) -> Element(a)

subset_of_thin

</> 
pub fn subset_of_thin(attrs: List(Attribute(a))) -> Element(a)

subset_proper_of_bold

</> 
pub fn subset_proper_of_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

subset_proper_of_duotone

</> 
pub fn subset_proper_of_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

subset_proper_of_fill

</> 
pub fn subset_proper_of_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

subset_proper_of_light

</> 
pub fn subset_proper_of_light(
  attrs: List(Attribute(a)),
) -> Element(a)

subset_proper_of_regular

</> 
pub fn subset_proper_of_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

subset_proper_of_thin

</> 
pub fn subset_proper_of_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

subtitles_bold

</> 
pub fn subtitles_bold(attrs: List(Attribute(a))) -> Element(a)

subtitles_duotone

</> 
pub fn subtitles_duotone(attrs: List(Attribute(a))) -> Element(a)

subtitles_fill

</> 
pub fn subtitles_fill(attrs: List(Attribute(a))) -> Element(a)

subtitles_light

</> 
pub fn subtitles_light(attrs: List(Attribute(a))) -> Element(a)

subtitles_regular

</> 
pub fn subtitles_regular(attrs: List(Attribute(a))) -> Element(a)

subtitles_slash_bold

</> 
pub fn subtitles_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

subtitles_slash_duotone

</> 
pub fn subtitles_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

subtitles_slash_fill

</> 
pub fn subtitles_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

subtitles_slash_light

</> 
pub fn subtitles_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

subtitles_slash_regular

</> 
pub fn subtitles_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

subtitles_slash_thin

</> 
pub fn subtitles_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

subtitles_thin

</> 
pub fn subtitles_thin(attrs: List(Attribute(a))) -> Element(a)

subtract_bold

</> 
pub fn subtract_bold(attrs: List(Attribute(a))) -> Element(a)

subtract_duotone

</> 
pub fn subtract_duotone(attrs: List(Attribute(a))) -> Element(a)

subtract_fill

</> 
pub fn subtract_fill(attrs: List(Attribute(a))) -> Element(a)

subtract_light

</> 
pub fn subtract_light(attrs: List(Attribute(a))) -> Element(a)

subtract_regular

</> 
pub fn subtract_regular(attrs: List(Attribute(a))) -> Element(a)

subtract_square_bold

</> 
pub fn subtract_square_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

subtract_square_duotone

</> 
pub fn subtract_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

subtract_square_fill

</> 
pub fn subtract_square_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

subtract_square_light

</> 
pub fn subtract_square_light(
  attrs: List(Attribute(a)),
) -> Element(a)

subtract_square_regular

</> 
pub fn subtract_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

subtract_square_thin

</> 
pub fn subtract_square_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

subtract_thin

</> 
pub fn subtract_thin(attrs: List(Attribute(a))) -> Element(a)

subway_bold

</> 
pub fn subway_bold(attrs: List(Attribute(a))) -> Element(a)

subway_duotone

</> 
pub fn subway_duotone(attrs: List(Attribute(a))) -> Element(a)

subway_fill

</> 
pub fn subway_fill(attrs: List(Attribute(a))) -> Element(a)

subway_light

</> 
pub fn subway_light(attrs: List(Attribute(a))) -> Element(a)

subway_regular

</> 
pub fn subway_regular(attrs: List(Attribute(a))) -> Element(a)

subway_thin

</> 
pub fn subway_thin(attrs: List(Attribute(a))) -> Element(a)

suitcase_bold

</> 
pub fn suitcase_bold(attrs: List(Attribute(a))) -> Element(a)

suitcase_duotone

</> 
pub fn suitcase_duotone(attrs: List(Attribute(a))) -> Element(a)

suitcase_fill

</> 
pub fn suitcase_fill(attrs: List(Attribute(a))) -> Element(a)

suitcase_light

</> 
pub fn suitcase_light(attrs: List(Attribute(a))) -> Element(a)

suitcase_regular

</> 
pub fn suitcase_regular(attrs: List(Attribute(a))) -> Element(a)

suitcase_rolling_bold

</> 
pub fn suitcase_rolling_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_rolling_duotone

</> 
pub fn suitcase_rolling_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_rolling_fill

</> 
pub fn suitcase_rolling_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_rolling_light

</> 
pub fn suitcase_rolling_light(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_rolling_regular

</> 
pub fn suitcase_rolling_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_rolling_thin

</> 
pub fn suitcase_rolling_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_simple_bold

</> 
pub fn suitcase_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_simple_duotone

</> 
pub fn suitcase_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_simple_fill

</> 
pub fn suitcase_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_simple_light

</> 
pub fn suitcase_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_simple_regular

</> 
pub fn suitcase_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_simple_thin

</> 
pub fn suitcase_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

suitcase_thin

</> 
pub fn suitcase_thin(attrs: List(Attribute(a))) -> Element(a)

sun_bold

</> 
pub fn sun_bold(attrs: List(Attribute(a))) -> Element(a)

sun_dim_bold

</> 
pub fn sun_dim_bold(attrs: List(Attribute(a))) -> Element(a)

sun_dim_duotone

</> 
pub fn sun_dim_duotone(attrs: List(Attribute(a))) -> Element(a)

sun_dim_fill

</> 
pub fn sun_dim_fill(attrs: List(Attribute(a))) -> Element(a)

sun_dim_light

</> 
pub fn sun_dim_light(attrs: List(Attribute(a))) -> Element(a)

sun_dim_regular

</> 
pub fn sun_dim_regular(attrs: List(Attribute(a))) -> Element(a)

sun_dim_thin

</> 
pub fn sun_dim_thin(attrs: List(Attribute(a))) -> Element(a)

sun_duotone

</> 
pub fn sun_duotone(attrs: List(Attribute(a))) -> Element(a)

sun_fill

</> 
pub fn sun_fill(attrs: List(Attribute(a))) -> Element(a)

sun_horizon_bold

</> 
pub fn sun_horizon_bold(attrs: List(Attribute(a))) -> Element(a)

sun_horizon_duotone

</> 
pub fn sun_horizon_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

sun_horizon_fill

</> 
pub fn sun_horizon_fill(attrs: List(Attribute(a))) -> Element(a)

sun_horizon_light

</> 
pub fn sun_horizon_light(attrs: List(Attribute(a))) -> Element(a)

sun_horizon_regular

</> 
pub fn sun_horizon_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

sun_horizon_thin

</> 
pub fn sun_horizon_thin(attrs: List(Attribute(a))) -> Element(a)

sun_light

</> 
pub fn sun_light(attrs: List(Attribute(a))) -> Element(a)

sun_regular

</> 
pub fn sun_regular(attrs: List(Attribute(a))) -> Element(a)

sun_thin

</> 
pub fn sun_thin(attrs: List(Attribute(a))) -> Element(a)

sunglasses_bold

</> 
pub fn sunglasses_bold(attrs: List(Attribute(a))) -> Element(a)

sunglasses_duotone

</> 
pub fn sunglasses_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

sunglasses_fill

</> 
pub fn sunglasses_fill(attrs: List(Attribute(a))) -> Element(a)

sunglasses_light

</> 
pub fn sunglasses_light(attrs: List(Attribute(a))) -> Element(a)

sunglasses_regular

</> 
pub fn sunglasses_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

sunglasses_thin

</> 
pub fn sunglasses_thin(attrs: List(Attribute(a))) -> Element(a)

superset_of_bold

</> 
pub fn superset_of_bold(attrs: List(Attribute(a))) -> Element(a)

superset_of_duotone

</> 
pub fn superset_of_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

superset_of_fill

</> 
pub fn superset_of_fill(attrs: List(Attribute(a))) -> Element(a)

superset_of_light

</> 
pub fn superset_of_light(attrs: List(Attribute(a))) -> Element(a)

superset_of_regular

</> 
pub fn superset_of_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

superset_of_thin

</> 
pub fn superset_of_thin(attrs: List(Attribute(a))) -> Element(a)

superset_proper_of_bold

</> 
pub fn superset_proper_of_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

superset_proper_of_duotone

</> 
pub fn superset_proper_of_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

superset_proper_of_fill

</> 
pub fn superset_proper_of_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

superset_proper_of_light

</> 
pub fn superset_proper_of_light(
  attrs: List(Attribute(a)),
) -> Element(a)

superset_proper_of_regular

</> 
pub fn superset_proper_of_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

superset_proper_of_thin

</> 
pub fn superset_proper_of_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

swap_bold

</> 
pub fn swap_bold(attrs: List(Attribute(a))) -> Element(a)

swap_duotone

</> 
pub fn swap_duotone(attrs: List(Attribute(a))) -> Element(a)

swap_fill

</> 
pub fn swap_fill(attrs: List(Attribute(a))) -> Element(a)

swap_light

</> 
pub fn swap_light(attrs: List(Attribute(a))) -> Element(a)

swap_regular

</> 
pub fn swap_regular(attrs: List(Attribute(a))) -> Element(a)

swap_thin

</> 
pub fn swap_thin(attrs: List(Attribute(a))) -> Element(a)

swatches_bold

</> 
pub fn swatches_bold(attrs: List(Attribute(a))) -> Element(a)

swatches_duotone

</> 
pub fn swatches_duotone(attrs: List(Attribute(a))) -> Element(a)

swatches_fill

</> 
pub fn swatches_fill(attrs: List(Attribute(a))) -> Element(a)

swatches_light

</> 
pub fn swatches_light(attrs: List(Attribute(a))) -> Element(a)

swatches_regular

</> 
pub fn swatches_regular(attrs: List(Attribute(a))) -> Element(a)

swatches_thin

</> 
pub fn swatches_thin(attrs: List(Attribute(a))) -> Element(a)

swimming_pool_bold

</> 
pub fn swimming_pool_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

swimming_pool_duotone

</> 
pub fn swimming_pool_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

swimming_pool_fill

</> 
pub fn swimming_pool_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

swimming_pool_light

</> 
pub fn swimming_pool_light(
  attrs: List(Attribute(a)),
) -> Element(a)

swimming_pool_regular

</> 
pub fn swimming_pool_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

swimming_pool_thin

</> 
pub fn swimming_pool_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

sword_bold

</> 
pub fn sword_bold(attrs: List(Attribute(a))) -> Element(a)

sword_duotone

</> 
pub fn sword_duotone(attrs: List(Attribute(a))) -> Element(a)

sword_fill

</> 
pub fn sword_fill(attrs: List(Attribute(a))) -> Element(a)

sword_light

</> 
pub fn sword_light(attrs: List(Attribute(a))) -> Element(a)

sword_regular

</> 
pub fn sword_regular(attrs: List(Attribute(a))) -> Element(a)

sword_thin

</> 
pub fn sword_thin(attrs: List(Attribute(a))) -> Element(a)

synagogue_bold

</> 
pub fn synagogue_bold(attrs: List(Attribute(a))) -> Element(a)

synagogue_duotone

</> 
pub fn synagogue_duotone(attrs: List(Attribute(a))) -> Element(a)

synagogue_fill

</> 
pub fn synagogue_fill(attrs: List(Attribute(a))) -> Element(a)

synagogue_light

</> 
pub fn synagogue_light(attrs: List(Attribute(a))) -> Element(a)

synagogue_regular

</> 
pub fn synagogue_regular(attrs: List(Attribute(a))) -> Element(a)

synagogue_thin

</> 
pub fn synagogue_thin(attrs: List(Attribute(a))) -> Element(a)

syringe_bold

</> 
pub fn syringe_bold(attrs: List(Attribute(a))) -> Element(a)

syringe_duotone

</> 
pub fn syringe_duotone(attrs: List(Attribute(a))) -> Element(a)

syringe_fill

</> 
pub fn syringe_fill(attrs: List(Attribute(a))) -> Element(a)

syringe_light

</> 
pub fn syringe_light(attrs: List(Attribute(a))) -> Element(a)

syringe_regular

</> 
pub fn syringe_regular(attrs: List(Attribute(a))) -> Element(a)

syringe_thin

</> 
pub fn syringe_thin(attrs: List(Attribute(a))) -> Element(a)

t_shirt_bold

</> 
pub fn t_shirt_bold(attrs: List(Attribute(a))) -> Element(a)

t_shirt_duotone

</> 
pub fn t_shirt_duotone(attrs: List(Attribute(a))) -> Element(a)

t_shirt_fill

</> 
pub fn t_shirt_fill(attrs: List(Attribute(a))) -> Element(a)

t_shirt_light

</> 
pub fn t_shirt_light(attrs: List(Attribute(a))) -> Element(a)

t_shirt_regular

</> 
pub fn t_shirt_regular(attrs: List(Attribute(a))) -> Element(a)

t_shirt_thin

</> 
pub fn t_shirt_thin(attrs: List(Attribute(a))) -> Element(a)

table_bold

</> 
pub fn table_bold(attrs: List(Attribute(a))) -> Element(a)

table_duotone

</> 
pub fn table_duotone(attrs: List(Attribute(a))) -> Element(a)

table_fill

</> 
pub fn table_fill(attrs: List(Attribute(a))) -> Element(a)

table_light

</> 
pub fn table_light(attrs: List(Attribute(a))) -> Element(a)

table_regular

</> 
pub fn table_regular(attrs: List(Attribute(a))) -> Element(a)

table_thin

</> 
pub fn table_thin(attrs: List(Attribute(a))) -> Element(a)

tabs_bold

</> 
pub fn tabs_bold(attrs: List(Attribute(a))) -> Element(a)

tabs_duotone

</> 
pub fn tabs_duotone(attrs: List(Attribute(a))) -> Element(a)

tabs_fill

</> 
pub fn tabs_fill(attrs: List(Attribute(a))) -> Element(a)

tabs_light

</> 
pub fn tabs_light(attrs: List(Attribute(a))) -> Element(a)

tabs_regular

</> 
pub fn tabs_regular(attrs: List(Attribute(a))) -> Element(a)

tabs_thin

</> 
pub fn tabs_thin(attrs: List(Attribute(a))) -> Element(a)

tag_bold

</> 
pub fn tag_bold(attrs: List(Attribute(a))) -> Element(a)

tag_chevron_bold

</> 
pub fn tag_chevron_bold(attrs: List(Attribute(a))) -> Element(a)

tag_chevron_duotone

</> 
pub fn tag_chevron_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tag_chevron_fill

</> 
pub fn tag_chevron_fill(attrs: List(Attribute(a))) -> Element(a)

tag_chevron_light

</> 
pub fn tag_chevron_light(attrs: List(Attribute(a))) -> Element(a)

tag_chevron_regular

</> 
pub fn tag_chevron_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tag_chevron_thin

</> 
pub fn tag_chevron_thin(attrs: List(Attribute(a))) -> Element(a)

tag_duotone

</> 
pub fn tag_duotone(attrs: List(Attribute(a))) -> Element(a)

tag_fill

</> 
pub fn tag_fill(attrs: List(Attribute(a))) -> Element(a)

tag_light

</> 
pub fn tag_light(attrs: List(Attribute(a))) -> Element(a)

tag_regular

</> 
pub fn tag_regular(attrs: List(Attribute(a))) -> Element(a)

tag_simple_bold

</> 
pub fn tag_simple_bold(attrs: List(Attribute(a))) -> Element(a)

tag_simple_duotone

</> 
pub fn tag_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tag_simple_fill

</> 
pub fn tag_simple_fill(attrs: List(Attribute(a))) -> Element(a)

tag_simple_light

</> 
pub fn tag_simple_light(attrs: List(Attribute(a))) -> Element(a)

tag_simple_regular

</> 
pub fn tag_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tag_simple_thin

</> 
pub fn tag_simple_thin(attrs: List(Attribute(a))) -> Element(a)

tag_thin

</> 
pub fn tag_thin(attrs: List(Attribute(a))) -> Element(a)

target_bold

</> 
pub fn target_bold(attrs: List(Attribute(a))) -> Element(a)

target_duotone

</> 
pub fn target_duotone(attrs: List(Attribute(a))) -> Element(a)

target_fill

</> 
pub fn target_fill(attrs: List(Attribute(a))) -> Element(a)

target_light

</> 
pub fn target_light(attrs: List(Attribute(a))) -> Element(a)

target_regular

</> 
pub fn target_regular(attrs: List(Attribute(a))) -> Element(a)

target_thin

</> 
pub fn target_thin(attrs: List(Attribute(a))) -> Element(a)

taxi_bold

</> 
pub fn taxi_bold(attrs: List(Attribute(a))) -> Element(a)

taxi_duotone

</> 
pub fn taxi_duotone(attrs: List(Attribute(a))) -> Element(a)

taxi_fill

</> 
pub fn taxi_fill(attrs: List(Attribute(a))) -> Element(a)

taxi_light

</> 
pub fn taxi_light(attrs: List(Attribute(a))) -> Element(a)

taxi_regular

</> 
pub fn taxi_regular(attrs: List(Attribute(a))) -> Element(a)

taxi_thin

</> 
pub fn taxi_thin(attrs: List(Attribute(a))) -> Element(a)

tea_bag_bold

</> 
pub fn tea_bag_bold(attrs: List(Attribute(a))) -> Element(a)

tea_bag_duotone

</> 
pub fn tea_bag_duotone(attrs: List(Attribute(a))) -> Element(a)

tea_bag_fill

</> 
pub fn tea_bag_fill(attrs: List(Attribute(a))) -> Element(a)

tea_bag_light

</> 
pub fn tea_bag_light(attrs: List(Attribute(a))) -> Element(a)

tea_bag_regular

</> 
pub fn tea_bag_regular(attrs: List(Attribute(a))) -> Element(a)

tea_bag_thin

</> 
pub fn tea_bag_thin(attrs: List(Attribute(a))) -> Element(a)

telegram_logo_bold

</> 
pub fn telegram_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

telegram_logo_duotone

</> 
pub fn telegram_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

telegram_logo_fill

</> 
pub fn telegram_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

telegram_logo_light

</> 
pub fn telegram_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

telegram_logo_regular

</> 
pub fn telegram_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

telegram_logo_thin

</> 
pub fn telegram_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

television_bold

</> 
pub fn television_bold(attrs: List(Attribute(a))) -> Element(a)

television_duotone

</> 
pub fn television_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

television_fill

</> 
pub fn television_fill(attrs: List(Attribute(a))) -> Element(a)

television_light

</> 
pub fn television_light(attrs: List(Attribute(a))) -> Element(a)

television_regular

</> 
pub fn television_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

television_simple_bold

</> 
pub fn television_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

television_simple_duotone

</> 
pub fn television_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

television_simple_fill

</> 
pub fn television_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

television_simple_light

</> 
pub fn television_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

television_simple_regular

</> 
pub fn television_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

television_simple_thin

</> 
pub fn television_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

television_thin

</> 
pub fn television_thin(attrs: List(Attribute(a))) -> Element(a)

tennis_ball_bold

</> 
pub fn tennis_ball_bold(attrs: List(Attribute(a))) -> Element(a)

tennis_ball_duotone

</> 
pub fn tennis_ball_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tennis_ball_fill

</> 
pub fn tennis_ball_fill(attrs: List(Attribute(a))) -> Element(a)

tennis_ball_light

</> 
pub fn tennis_ball_light(attrs: List(Attribute(a))) -> Element(a)

tennis_ball_regular

</> 
pub fn tennis_ball_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tennis_ball_thin

</> 
pub fn tennis_ball_thin(attrs: List(Attribute(a))) -> Element(a)

tent_bold

</> 
pub fn tent_bold(attrs: List(Attribute(a))) -> Element(a)

tent_duotone

</> 
pub fn tent_duotone(attrs: List(Attribute(a))) -> Element(a)

tent_fill

</> 
pub fn tent_fill(attrs: List(Attribute(a))) -> Element(a)

tent_light

</> 
pub fn tent_light(attrs: List(Attribute(a))) -> Element(a)

tent_regular

</> 
pub fn tent_regular(attrs: List(Attribute(a))) -> Element(a)

tent_thin

</> 
pub fn tent_thin(attrs: List(Attribute(a))) -> Element(a)

terminal_bold

</> 
pub fn terminal_bold(attrs: List(Attribute(a))) -> Element(a)

terminal_duotone

</> 
pub fn terminal_duotone(attrs: List(Attribute(a))) -> Element(a)

terminal_fill

</> 
pub fn terminal_fill(attrs: List(Attribute(a))) -> Element(a)

terminal_light

</> 
pub fn terminal_light(attrs: List(Attribute(a))) -> Element(a)

terminal_regular

</> 
pub fn terminal_regular(attrs: List(Attribute(a))) -> Element(a)

terminal_thin

</> 
pub fn terminal_thin(attrs: List(Attribute(a))) -> Element(a)

terminal_window_bold

</> 
pub fn terminal_window_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

terminal_window_duotone

</> 
pub fn terminal_window_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

terminal_window_fill

</> 
pub fn terminal_window_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

terminal_window_light

</> 
pub fn terminal_window_light(
  attrs: List(Attribute(a)),
) -> Element(a)

terminal_window_regular

</> 
pub fn terminal_window_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

terminal_window_thin

</> 
pub fn terminal_window_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

test_tube_bold

</> 
pub fn test_tube_bold(attrs: List(Attribute(a))) -> Element(a)

test_tube_duotone

</> 
pub fn test_tube_duotone(attrs: List(Attribute(a))) -> Element(a)

test_tube_fill

</> 
pub fn test_tube_fill(attrs: List(Attribute(a))) -> Element(a)

test_tube_light

</> 
pub fn test_tube_light(attrs: List(Attribute(a))) -> Element(a)

test_tube_regular

</> 
pub fn test_tube_regular(attrs: List(Attribute(a))) -> Element(a)

test_tube_thin

</> 
pub fn test_tube_thin(attrs: List(Attribute(a))) -> Element(a)

text_a_underline_bold

</> 
pub fn text_a_underline_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

text_a_underline_duotone

</> 
pub fn text_a_underline_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_a_underline_fill

</> 
pub fn text_a_underline_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

text_a_underline_light

</> 
pub fn text_a_underline_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_a_underline_regular

</> 
pub fn text_a_underline_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_a_underline_thin

</> 
pub fn text_a_underline_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

text_aa_bold

</> 
pub fn text_aa_bold(attrs: List(Attribute(a))) -> Element(a)

text_aa_duotone

</> 
pub fn text_aa_duotone(attrs: List(Attribute(a))) -> Element(a)

text_aa_fill

</> 
pub fn text_aa_fill(attrs: List(Attribute(a))) -> Element(a)

text_aa_light

</> 
pub fn text_aa_light(attrs: List(Attribute(a))) -> Element(a)

text_aa_regular

</> 
pub fn text_aa_regular(attrs: List(Attribute(a))) -> Element(a)

text_aa_thin

</> 
pub fn text_aa_thin(attrs: List(Attribute(a))) -> Element(a)

text_align_center_bold

</> 
pub fn text_align_center_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_center_duotone

</> 
pub fn text_align_center_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_center_fill

</> 
pub fn text_align_center_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_center_light

</> 
pub fn text_align_center_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_center_regular

</> 
pub fn text_align_center_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_center_thin

</> 
pub fn text_align_center_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_justify_bold

</> 
pub fn text_align_justify_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_justify_duotone

</> 
pub fn text_align_justify_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_justify_fill

</> 
pub fn text_align_justify_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_justify_light

</> 
pub fn text_align_justify_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_justify_regular

</> 
pub fn text_align_justify_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_justify_thin

</> 
pub fn text_align_justify_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_left_bold

</> 
pub fn text_align_left_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_left_duotone

</> 
pub fn text_align_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_left_fill

</> 
pub fn text_align_left_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_left_light

</> 
pub fn text_align_left_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_left_regular

</> 
pub fn text_align_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_left_thin

</> 
pub fn text_align_left_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_right_bold

</> 
pub fn text_align_right_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_right_duotone

</> 
pub fn text_align_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_right_fill

</> 
pub fn text_align_right_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_right_light

</> 
pub fn text_align_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_right_regular

</> 
pub fn text_align_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_align_right_thin

</> 
pub fn text_align_right_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

text_b_bold

</> 
pub fn text_b_bold(attrs: List(Attribute(a))) -> Element(a)

text_b_duotone

</> 
pub fn text_b_duotone(attrs: List(Attribute(a))) -> Element(a)

text_b_fill

</> 
pub fn text_b_fill(attrs: List(Attribute(a))) -> Element(a)

text_b_light

</> 
pub fn text_b_light(attrs: List(Attribute(a))) -> Element(a)

text_b_regular

</> 
pub fn text_b_regular(attrs: List(Attribute(a))) -> Element(a)

text_b_thin

</> 
pub fn text_b_thin(attrs: List(Attribute(a))) -> Element(a)

text_columns_bold

</> 
pub fn text_columns_bold(attrs: List(Attribute(a))) -> Element(a)

text_columns_duotone

</> 
pub fn text_columns_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_columns_fill

</> 
pub fn text_columns_fill(attrs: List(Attribute(a))) -> Element(a)

text_columns_light

</> 
pub fn text_columns_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_columns_regular

</> 
pub fn text_columns_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_columns_thin

</> 
pub fn text_columns_thin(attrs: List(Attribute(a))) -> Element(a)

text_h_bold

</> 
pub fn text_h_bold(attrs: List(Attribute(a))) -> Element(a)

text_h_duotone

</> 
pub fn text_h_duotone(attrs: List(Attribute(a))) -> Element(a)

text_h_fill

</> 
pub fn text_h_fill(attrs: List(Attribute(a))) -> Element(a)

text_h_five_bold

</> 
pub fn text_h_five_bold(attrs: List(Attribute(a))) -> Element(a)

text_h_five_duotone

</> 
pub fn text_h_five_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_five_fill

</> 
pub fn text_h_five_fill(attrs: List(Attribute(a))) -> Element(a)

text_h_five_light

</> 
pub fn text_h_five_light(attrs: List(Attribute(a))) -> Element(a)

text_h_five_regular

</> 
pub fn text_h_five_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_five_thin

</> 
pub fn text_h_five_thin(attrs: List(Attribute(a))) -> Element(a)

text_h_four_bold

</> 
pub fn text_h_four_bold(attrs: List(Attribute(a))) -> Element(a)

text_h_four_duotone

</> 
pub fn text_h_four_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_four_fill

</> 
pub fn text_h_four_fill(attrs: List(Attribute(a))) -> Element(a)

text_h_four_light

</> 
pub fn text_h_four_light(attrs: List(Attribute(a))) -> Element(a)

text_h_four_regular

</> 
pub fn text_h_four_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_four_thin

</> 
pub fn text_h_four_thin(attrs: List(Attribute(a))) -> Element(a)

text_h_light

</> 
pub fn text_h_light(attrs: List(Attribute(a))) -> Element(a)

text_h_one_bold

</> 
pub fn text_h_one_bold(attrs: List(Attribute(a))) -> Element(a)

text_h_one_duotone

</> 
pub fn text_h_one_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_one_fill

</> 
pub fn text_h_one_fill(attrs: List(Attribute(a))) -> Element(a)

text_h_one_light

</> 
pub fn text_h_one_light(attrs: List(Attribute(a))) -> Element(a)

text_h_one_regular

</> 
pub fn text_h_one_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_one_thin

</> 
pub fn text_h_one_thin(attrs: List(Attribute(a))) -> Element(a)

text_h_regular

</> 
pub fn text_h_regular(attrs: List(Attribute(a))) -> Element(a)

text_h_six_bold

</> 
pub fn text_h_six_bold(attrs: List(Attribute(a))) -> Element(a)

text_h_six_duotone

</> 
pub fn text_h_six_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_six_fill

</> 
pub fn text_h_six_fill(attrs: List(Attribute(a))) -> Element(a)

text_h_six_light

</> 
pub fn text_h_six_light(attrs: List(Attribute(a))) -> Element(a)

text_h_six_regular

</> 
pub fn text_h_six_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_six_thin

</> 
pub fn text_h_six_thin(attrs: List(Attribute(a))) -> Element(a)

text_h_thin

</> 
pub fn text_h_thin(attrs: List(Attribute(a))) -> Element(a)

text_h_three_bold

</> 
pub fn text_h_three_bold(attrs: List(Attribute(a))) -> Element(a)

text_h_three_duotone

</> 
pub fn text_h_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_three_fill

</> 
pub fn text_h_three_fill(attrs: List(Attribute(a))) -> Element(a)

text_h_three_light

</> 
pub fn text_h_three_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_three_regular

</> 
pub fn text_h_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_three_thin

</> 
pub fn text_h_three_thin(attrs: List(Attribute(a))) -> Element(a)

text_h_two_bold

</> 
pub fn text_h_two_bold(attrs: List(Attribute(a))) -> Element(a)

text_h_two_duotone

</> 
pub fn text_h_two_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_two_fill

</> 
pub fn text_h_two_fill(attrs: List(Attribute(a))) -> Element(a)

text_h_two_light

</> 
pub fn text_h_two_light(attrs: List(Attribute(a))) -> Element(a)

text_h_two_regular

</> 
pub fn text_h_two_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_h_two_thin

</> 
pub fn text_h_two_thin(attrs: List(Attribute(a))) -> Element(a)

text_indent_bold

</> 
pub fn text_indent_bold(attrs: List(Attribute(a))) -> Element(a)

text_indent_duotone

</> 
pub fn text_indent_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_indent_fill

</> 
pub fn text_indent_fill(attrs: List(Attribute(a))) -> Element(a)

text_indent_light

</> 
pub fn text_indent_light(attrs: List(Attribute(a))) -> Element(a)

text_indent_regular

</> 
pub fn text_indent_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_indent_thin

</> 
pub fn text_indent_thin(attrs: List(Attribute(a))) -> Element(a)

text_italic_bold

</> 
pub fn text_italic_bold(attrs: List(Attribute(a))) -> Element(a)

text_italic_duotone

</> 
pub fn text_italic_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_italic_fill

</> 
pub fn text_italic_fill(attrs: List(Attribute(a))) -> Element(a)

text_italic_light

</> 
pub fn text_italic_light(attrs: List(Attribute(a))) -> Element(a)

text_italic_regular

</> 
pub fn text_italic_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_italic_thin

</> 
pub fn text_italic_thin(attrs: List(Attribute(a))) -> Element(a)

text_outdent_bold

</> 
pub fn text_outdent_bold(attrs: List(Attribute(a))) -> Element(a)

text_outdent_duotone

</> 
pub fn text_outdent_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_outdent_fill

</> 
pub fn text_outdent_fill(attrs: List(Attribute(a))) -> Element(a)

text_outdent_light

</> 
pub fn text_outdent_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_outdent_regular

</> 
pub fn text_outdent_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_outdent_thin

</> 
pub fn text_outdent_thin(attrs: List(Attribute(a))) -> Element(a)

text_strikethrough_bold

</> 
pub fn text_strikethrough_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

text_strikethrough_duotone

</> 
pub fn text_strikethrough_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_strikethrough_fill

</> 
pub fn text_strikethrough_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

text_strikethrough_light

</> 
pub fn text_strikethrough_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_strikethrough_regular

</> 
pub fn text_strikethrough_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_strikethrough_thin

</> 
pub fn text_strikethrough_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

text_subscript_bold

</> 
pub fn text_subscript_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

text_subscript_duotone

</> 
pub fn text_subscript_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_subscript_fill

</> 
pub fn text_subscript_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

text_subscript_light

</> 
pub fn text_subscript_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_subscript_regular

</> 
pub fn text_subscript_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_subscript_thin

</> 
pub fn text_subscript_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

text_superscript_bold

</> 
pub fn text_superscript_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

text_superscript_duotone

</> 
pub fn text_superscript_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_superscript_fill

</> 
pub fn text_superscript_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

text_superscript_light

</> 
pub fn text_superscript_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_superscript_regular

</> 
pub fn text_superscript_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_superscript_thin

</> 
pub fn text_superscript_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

text_t_bold

</> 
pub fn text_t_bold(attrs: List(Attribute(a))) -> Element(a)

text_t_duotone

</> 
pub fn text_t_duotone(attrs: List(Attribute(a))) -> Element(a)

text_t_fill

</> 
pub fn text_t_fill(attrs: List(Attribute(a))) -> Element(a)

text_t_light

</> 
pub fn text_t_light(attrs: List(Attribute(a))) -> Element(a)

text_t_regular

</> 
pub fn text_t_regular(attrs: List(Attribute(a))) -> Element(a)

text_t_slash_bold

</> 
pub fn text_t_slash_bold(attrs: List(Attribute(a))) -> Element(a)

text_t_slash_duotone

</> 
pub fn text_t_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_t_slash_fill

</> 
pub fn text_t_slash_fill(attrs: List(Attribute(a))) -> Element(a)

text_t_slash_light

</> 
pub fn text_t_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_t_slash_regular

</> 
pub fn text_t_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_t_slash_thin

</> 
pub fn text_t_slash_thin(attrs: List(Attribute(a))) -> Element(a)

text_t_thin

</> 
pub fn text_t_thin(attrs: List(Attribute(a))) -> Element(a)

text_underline_bold

</> 
pub fn text_underline_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

text_underline_duotone

</> 
pub fn text_underline_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

text_underline_fill

</> 
pub fn text_underline_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

text_underline_light

</> 
pub fn text_underline_light(
  attrs: List(Attribute(a)),
) -> Element(a)

text_underline_regular

</> 
pub fn text_underline_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

text_underline_thin

</> 
pub fn text_underline_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

textbox_bold

</> 
pub fn textbox_bold(attrs: List(Attribute(a))) -> Element(a)

textbox_duotone

</> 
pub fn textbox_duotone(attrs: List(Attribute(a))) -> Element(a)

textbox_fill

</> 
pub fn textbox_fill(attrs: List(Attribute(a))) -> Element(a)

textbox_light

</> 
pub fn textbox_light(attrs: List(Attribute(a))) -> Element(a)

textbox_regular

</> 
pub fn textbox_regular(attrs: List(Attribute(a))) -> Element(a)

textbox_thin

</> 
pub fn textbox_thin(attrs: List(Attribute(a))) -> Element(a)

thermometer_bold

</> 
pub fn thermometer_bold(attrs: List(Attribute(a))) -> Element(a)

thermometer_cold_bold

</> 
pub fn thermometer_cold_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_cold_duotone

</> 
pub fn thermometer_cold_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_cold_fill

</> 
pub fn thermometer_cold_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_cold_light

</> 
pub fn thermometer_cold_light(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_cold_regular

</> 
pub fn thermometer_cold_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_cold_thin

</> 
pub fn thermometer_cold_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_duotone

</> 
pub fn thermometer_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_fill

</> 
pub fn thermometer_fill(attrs: List(Attribute(a))) -> Element(a)

thermometer_hot_bold

</> 
pub fn thermometer_hot_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_hot_duotone

</> 
pub fn thermometer_hot_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_hot_fill

</> 
pub fn thermometer_hot_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_hot_light

</> 
pub fn thermometer_hot_light(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_hot_regular

</> 
pub fn thermometer_hot_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_hot_thin

</> 
pub fn thermometer_hot_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_light

</> 
pub fn thermometer_light(attrs: List(Attribute(a))) -> Element(a)

thermometer_regular

</> 
pub fn thermometer_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_simple_bold

</> 
pub fn thermometer_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_simple_duotone

</> 
pub fn thermometer_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_simple_fill

</> 
pub fn thermometer_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_simple_light

</> 
pub fn thermometer_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_simple_regular

</> 
pub fn thermometer_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_simple_thin

</> 
pub fn thermometer_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

thermometer_thin

</> 
pub fn thermometer_thin(attrs: List(Attribute(a))) -> Element(a)

threads_logo_bold

</> 
pub fn threads_logo_bold(attrs: List(Attribute(a))) -> Element(a)

threads_logo_duotone

</> 
pub fn threads_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

threads_logo_fill

</> 
pub fn threads_logo_fill(attrs: List(Attribute(a))) -> Element(a)

threads_logo_light

</> 
pub fn threads_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

threads_logo_regular

</> 
pub fn threads_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

threads_logo_thin

</> 
pub fn threads_logo_thin(attrs: List(Attribute(a))) -> Element(a)

three_d_bold

</> 
pub fn three_d_bold(attrs: List(Attribute(a))) -> Element(a)

three_d_duotone

</> 
pub fn three_d_duotone(attrs: List(Attribute(a))) -> Element(a)

three_d_fill

</> 
pub fn three_d_fill(attrs: List(Attribute(a))) -> Element(a)

three_d_light

</> 
pub fn three_d_light(attrs: List(Attribute(a))) -> Element(a)

three_d_regular

</> 
pub fn three_d_regular(attrs: List(Attribute(a))) -> Element(a)

three_d_thin

</> 
pub fn three_d_thin(attrs: List(Attribute(a))) -> Element(a)

thumbs_down_bold

</> 
pub fn thumbs_down_bold(attrs: List(Attribute(a))) -> Element(a)

thumbs_down_duotone

</> 
pub fn thumbs_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

thumbs_down_fill

</> 
pub fn thumbs_down_fill(attrs: List(Attribute(a))) -> Element(a)

thumbs_down_light

</> 
pub fn thumbs_down_light(attrs: List(Attribute(a))) -> Element(a)

thumbs_down_regular

</> 
pub fn thumbs_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

thumbs_down_thin

</> 
pub fn thumbs_down_thin(attrs: List(Attribute(a))) -> Element(a)

thumbs_up_bold

</> 
pub fn thumbs_up_bold(attrs: List(Attribute(a))) -> Element(a)

thumbs_up_duotone

</> 
pub fn thumbs_up_duotone(attrs: List(Attribute(a))) -> Element(a)

thumbs_up_fill

</> 
pub fn thumbs_up_fill(attrs: List(Attribute(a))) -> Element(a)

thumbs_up_light

</> 
pub fn thumbs_up_light(attrs: List(Attribute(a))) -> Element(a)

thumbs_up_regular

</> 
pub fn thumbs_up_regular(attrs: List(Attribute(a))) -> Element(a)

thumbs_up_thin

</> 
pub fn thumbs_up_thin(attrs: List(Attribute(a))) -> Element(a)

ticket_bold

</> 
pub fn ticket_bold(attrs: List(Attribute(a))) -> Element(a)

ticket_duotone

</> 
pub fn ticket_duotone(attrs: List(Attribute(a))) -> Element(a)

ticket_fill

</> 
pub fn ticket_fill(attrs: List(Attribute(a))) -> Element(a)

ticket_light

</> 
pub fn ticket_light(attrs: List(Attribute(a))) -> Element(a)

ticket_regular

</> 
pub fn ticket_regular(attrs: List(Attribute(a))) -> Element(a)

ticket_thin

</> 
pub fn ticket_thin(attrs: List(Attribute(a))) -> Element(a)

tidal_logo_bold

</> 
pub fn tidal_logo_bold(attrs: List(Attribute(a))) -> Element(a)

tidal_logo_duotone

</> 
pub fn tidal_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tidal_logo_fill

</> 
pub fn tidal_logo_fill(attrs: List(Attribute(a))) -> Element(a)

tidal_logo_light

</> 
pub fn tidal_logo_light(attrs: List(Attribute(a))) -> Element(a)

tidal_logo_regular

</> 
pub fn tidal_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tidal_logo_thin

</> 
pub fn tidal_logo_thin(attrs: List(Attribute(a))) -> Element(a)

tiktok_logo_bold

</> 
pub fn tiktok_logo_bold(attrs: List(Attribute(a))) -> Element(a)

tiktok_logo_duotone

</> 
pub fn tiktok_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tiktok_logo_fill

</> 
pub fn tiktok_logo_fill(attrs: List(Attribute(a))) -> Element(a)

tiktok_logo_light

</> 
pub fn tiktok_logo_light(attrs: List(Attribute(a))) -> Element(a)

tiktok_logo_regular

</> 
pub fn tiktok_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tiktok_logo_thin

</> 
pub fn tiktok_logo_thin(attrs: List(Attribute(a))) -> Element(a)

tilde_bold

</> 
pub fn tilde_bold(attrs: List(Attribute(a))) -> Element(a)

tilde_duotone

</> 
pub fn tilde_duotone(attrs: List(Attribute(a))) -> Element(a)

tilde_fill

</> 
pub fn tilde_fill(attrs: List(Attribute(a))) -> Element(a)

tilde_light

</> 
pub fn tilde_light(attrs: List(Attribute(a))) -> Element(a)

tilde_regular

</> 
pub fn tilde_regular(attrs: List(Attribute(a))) -> Element(a)

tilde_thin

</> 
pub fn tilde_thin(attrs: List(Attribute(a))) -> Element(a)

timer_bold

</> 
pub fn timer_bold(attrs: List(Attribute(a))) -> Element(a)

timer_duotone

</> 
pub fn timer_duotone(attrs: List(Attribute(a))) -> Element(a)

timer_fill

</> 
pub fn timer_fill(attrs: List(Attribute(a))) -> Element(a)

timer_light

</> 
pub fn timer_light(attrs: List(Attribute(a))) -> Element(a)

timer_regular

</> 
pub fn timer_regular(attrs: List(Attribute(a))) -> Element(a)

timer_thin

</> 
pub fn timer_thin(attrs: List(Attribute(a))) -> Element(a)

tip_jar_bold

</> 
pub fn tip_jar_bold(attrs: List(Attribute(a))) -> Element(a)

tip_jar_duotone

</> 
pub fn tip_jar_duotone(attrs: List(Attribute(a))) -> Element(a)

tip_jar_fill

</> 
pub fn tip_jar_fill(attrs: List(Attribute(a))) -> Element(a)

tip_jar_light

</> 
pub fn tip_jar_light(attrs: List(Attribute(a))) -> Element(a)

tip_jar_regular

</> 
pub fn tip_jar_regular(attrs: List(Attribute(a))) -> Element(a)

tip_jar_thin

</> 
pub fn tip_jar_thin(attrs: List(Attribute(a))) -> Element(a)

tipi_bold

</> 
pub fn tipi_bold(attrs: List(Attribute(a))) -> Element(a)

tipi_duotone

</> 
pub fn tipi_duotone(attrs: List(Attribute(a))) -> Element(a)

tipi_fill

</> 
pub fn tipi_fill(attrs: List(Attribute(a))) -> Element(a)

tipi_light

</> 
pub fn tipi_light(attrs: List(Attribute(a))) -> Element(a)

tipi_regular

</> 
pub fn tipi_regular(attrs: List(Attribute(a))) -> Element(a)

tipi_thin

</> 
pub fn tipi_thin(attrs: List(Attribute(a))) -> Element(a)

tire_bold

</> 
pub fn tire_bold(attrs: List(Attribute(a))) -> Element(a)

tire_duotone

</> 
pub fn tire_duotone(attrs: List(Attribute(a))) -> Element(a)

tire_fill

</> 
pub fn tire_fill(attrs: List(Attribute(a))) -> Element(a)

tire_light

</> 
pub fn tire_light(attrs: List(Attribute(a))) -> Element(a)

tire_regular

</> 
pub fn tire_regular(attrs: List(Attribute(a))) -> Element(a)

tire_thin

</> 
pub fn tire_thin(attrs: List(Attribute(a))) -> Element(a)

toggle_left_bold

</> 
pub fn toggle_left_bold(attrs: List(Attribute(a))) -> Element(a)

toggle_left_duotone

</> 
pub fn toggle_left_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

toggle_left_fill

</> 
pub fn toggle_left_fill(attrs: List(Attribute(a))) -> Element(a)

toggle_left_light

</> 
pub fn toggle_left_light(attrs: List(Attribute(a))) -> Element(a)

toggle_left_regular

</> 
pub fn toggle_left_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

toggle_left_thin

</> 
pub fn toggle_left_thin(attrs: List(Attribute(a))) -> Element(a)

toggle_right_bold

</> 
pub fn toggle_right_bold(attrs: List(Attribute(a))) -> Element(a)

toggle_right_duotone

</> 
pub fn toggle_right_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

toggle_right_fill

</> 
pub fn toggle_right_fill(attrs: List(Attribute(a))) -> Element(a)

toggle_right_light

</> 
pub fn toggle_right_light(
  attrs: List(Attribute(a)),
) -> Element(a)

toggle_right_regular

</> 
pub fn toggle_right_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

toggle_right_thin

</> 
pub fn toggle_right_thin(attrs: List(Attribute(a))) -> Element(a)

toilet_bold

</> 
pub fn toilet_bold(attrs: List(Attribute(a))) -> Element(a)

toilet_duotone

</> 
pub fn toilet_duotone(attrs: List(Attribute(a))) -> Element(a)

toilet_fill

</> 
pub fn toilet_fill(attrs: List(Attribute(a))) -> Element(a)

toilet_light

</> 
pub fn toilet_light(attrs: List(Attribute(a))) -> Element(a)

toilet_paper_bold

</> 
pub fn toilet_paper_bold(attrs: List(Attribute(a))) -> Element(a)

toilet_paper_duotone

</> 
pub fn toilet_paper_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

toilet_paper_fill

</> 
pub fn toilet_paper_fill(attrs: List(Attribute(a))) -> Element(a)

toilet_paper_light

</> 
pub fn toilet_paper_light(
  attrs: List(Attribute(a)),
) -> Element(a)

toilet_paper_regular

</> 
pub fn toilet_paper_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

toilet_paper_thin

</> 
pub fn toilet_paper_thin(attrs: List(Attribute(a))) -> Element(a)

toilet_regular

</> 
pub fn toilet_regular(attrs: List(Attribute(a))) -> Element(a)

toilet_thin

</> 
pub fn toilet_thin(attrs: List(Attribute(a))) -> Element(a)

toolbox_bold

</> 
pub fn toolbox_bold(attrs: List(Attribute(a))) -> Element(a)

toolbox_duotone

</> 
pub fn toolbox_duotone(attrs: List(Attribute(a))) -> Element(a)

toolbox_fill

</> 
pub fn toolbox_fill(attrs: List(Attribute(a))) -> Element(a)

toolbox_light

</> 
pub fn toolbox_light(attrs: List(Attribute(a))) -> Element(a)

toolbox_regular

</> 
pub fn toolbox_regular(attrs: List(Attribute(a))) -> Element(a)

toolbox_thin

</> 
pub fn toolbox_thin(attrs: List(Attribute(a))) -> Element(a)

tooth_bold

</> 
pub fn tooth_bold(attrs: List(Attribute(a))) -> Element(a)

tooth_duotone

</> 
pub fn tooth_duotone(attrs: List(Attribute(a))) -> Element(a)

tooth_fill

</> 
pub fn tooth_fill(attrs: List(Attribute(a))) -> Element(a)

tooth_light

</> 
pub fn tooth_light(attrs: List(Attribute(a))) -> Element(a)

tooth_regular

</> 
pub fn tooth_regular(attrs: List(Attribute(a))) -> Element(a)

tooth_thin

</> 
pub fn tooth_thin(attrs: List(Attribute(a))) -> Element(a)

tornado_bold

</> 
pub fn tornado_bold(attrs: List(Attribute(a))) -> Element(a)

tornado_duotone

</> 
pub fn tornado_duotone(attrs: List(Attribute(a))) -> Element(a)

tornado_fill

</> 
pub fn tornado_fill(attrs: List(Attribute(a))) -> Element(a)

tornado_light

</> 
pub fn tornado_light(attrs: List(Attribute(a))) -> Element(a)

tornado_regular

</> 
pub fn tornado_regular(attrs: List(Attribute(a))) -> Element(a)

tornado_thin

</> 
pub fn tornado_thin(attrs: List(Attribute(a))) -> Element(a)

tote_bold

</> 
pub fn tote_bold(attrs: List(Attribute(a))) -> Element(a)

tote_duotone

</> 
pub fn tote_duotone(attrs: List(Attribute(a))) -> Element(a)

tote_fill

</> 
pub fn tote_fill(attrs: List(Attribute(a))) -> Element(a)

tote_light

</> 
pub fn tote_light(attrs: List(Attribute(a))) -> Element(a)

tote_regular

</> 
pub fn tote_regular(attrs: List(Attribute(a))) -> Element(a)

tote_simple_bold

</> 
pub fn tote_simple_bold(attrs: List(Attribute(a))) -> Element(a)

tote_simple_duotone

</> 
pub fn tote_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tote_simple_fill

</> 
pub fn tote_simple_fill(attrs: List(Attribute(a))) -> Element(a)

tote_simple_light

</> 
pub fn tote_simple_light(attrs: List(Attribute(a))) -> Element(a)

tote_simple_regular

</> 
pub fn tote_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tote_simple_thin

</> 
pub fn tote_simple_thin(attrs: List(Attribute(a))) -> Element(a)

tote_thin

</> 
pub fn tote_thin(attrs: List(Attribute(a))) -> Element(a)

towel_bold

</> 
pub fn towel_bold(attrs: List(Attribute(a))) -> Element(a)

towel_duotone

</> 
pub fn towel_duotone(attrs: List(Attribute(a))) -> Element(a)

towel_fill

</> 
pub fn towel_fill(attrs: List(Attribute(a))) -> Element(a)

towel_light

</> 
pub fn towel_light(attrs: List(Attribute(a))) -> Element(a)

towel_regular

</> 
pub fn towel_regular(attrs: List(Attribute(a))) -> Element(a)

towel_thin

</> 
pub fn towel_thin(attrs: List(Attribute(a))) -> Element(a)

tractor_bold

</> 
pub fn tractor_bold(attrs: List(Attribute(a))) -> Element(a)

tractor_duotone

</> 
pub fn tractor_duotone(attrs: List(Attribute(a))) -> Element(a)

tractor_fill

</> 
pub fn tractor_fill(attrs: List(Attribute(a))) -> Element(a)

tractor_light

</> 
pub fn tractor_light(attrs: List(Attribute(a))) -> Element(a)

tractor_regular

</> 
pub fn tractor_regular(attrs: List(Attribute(a))) -> Element(a)

tractor_thin

</> 
pub fn tractor_thin(attrs: List(Attribute(a))) -> Element(a)

trademark_bold

</> 
pub fn trademark_bold(attrs: List(Attribute(a))) -> Element(a)

trademark_duotone

</> 
pub fn trademark_duotone(attrs: List(Attribute(a))) -> Element(a)

trademark_fill

</> 
pub fn trademark_fill(attrs: List(Attribute(a))) -> Element(a)

trademark_light

</> 
pub fn trademark_light(attrs: List(Attribute(a))) -> Element(a)

trademark_registered_bold

</> 
pub fn trademark_registered_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

trademark_registered_duotone

</> 
pub fn trademark_registered_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

trademark_registered_fill

</> 
pub fn trademark_registered_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

trademark_registered_light

</> 
pub fn trademark_registered_light(
  attrs: List(Attribute(a)),
) -> Element(a)

trademark_registered_regular

</> 
pub fn trademark_registered_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

trademark_registered_thin

</> 
pub fn trademark_registered_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

trademark_regular

</> 
pub fn trademark_regular(attrs: List(Attribute(a))) -> Element(a)

trademark_thin

</> 
pub fn trademark_thin(attrs: List(Attribute(a))) -> Element(a)

traffic_cone_bold

</> 
pub fn traffic_cone_bold(attrs: List(Attribute(a))) -> Element(a)

traffic_cone_duotone

</> 
pub fn traffic_cone_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_cone_fill

</> 
pub fn traffic_cone_fill(attrs: List(Attribute(a))) -> Element(a)

traffic_cone_light

</> 
pub fn traffic_cone_light(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_cone_regular

</> 
pub fn traffic_cone_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_cone_thin

</> 
pub fn traffic_cone_thin(attrs: List(Attribute(a))) -> Element(a)

traffic_sign_bold

</> 
pub fn traffic_sign_bold(attrs: List(Attribute(a))) -> Element(a)

traffic_sign_duotone

</> 
pub fn traffic_sign_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_sign_fill

</> 
pub fn traffic_sign_fill(attrs: List(Attribute(a))) -> Element(a)

traffic_sign_light

</> 
pub fn traffic_sign_light(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_sign_regular

</> 
pub fn traffic_sign_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_sign_thin

</> 
pub fn traffic_sign_thin(attrs: List(Attribute(a))) -> Element(a)

traffic_signal_bold

</> 
pub fn traffic_signal_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_signal_duotone

</> 
pub fn traffic_signal_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_signal_fill

</> 
pub fn traffic_signal_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_signal_light

</> 
pub fn traffic_signal_light(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_signal_regular

</> 
pub fn traffic_signal_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

traffic_signal_thin

</> 
pub fn traffic_signal_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

train_bold

</> 
pub fn train_bold(attrs: List(Attribute(a))) -> Element(a)

train_duotone

</> 
pub fn train_duotone(attrs: List(Attribute(a))) -> Element(a)

train_fill

</> 
pub fn train_fill(attrs: List(Attribute(a))) -> Element(a)

train_light

</> 
pub fn train_light(attrs: List(Attribute(a))) -> Element(a)

train_regional_bold

</> 
pub fn train_regional_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

train_regional_duotone

</> 
pub fn train_regional_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

train_regional_fill

</> 
pub fn train_regional_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

train_regional_light

</> 
pub fn train_regional_light(
  attrs: List(Attribute(a)),
) -> Element(a)

train_regional_regular

</> 
pub fn train_regional_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

train_regional_thin

</> 
pub fn train_regional_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

train_regular

</> 
pub fn train_regular(attrs: List(Attribute(a))) -> Element(a)

train_simple_bold

</> 
pub fn train_simple_bold(attrs: List(Attribute(a))) -> Element(a)

train_simple_duotone

</> 
pub fn train_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

train_simple_fill

</> 
pub fn train_simple_fill(attrs: List(Attribute(a))) -> Element(a)

train_simple_light

</> 
pub fn train_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

train_simple_regular

</> 
pub fn train_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

train_simple_thin

</> 
pub fn train_simple_thin(attrs: List(Attribute(a))) -> Element(a)

train_thin

</> 
pub fn train_thin(attrs: List(Attribute(a))) -> Element(a)

tram_bold

</> 
pub fn tram_bold(attrs: List(Attribute(a))) -> Element(a)

tram_duotone

</> 
pub fn tram_duotone(attrs: List(Attribute(a))) -> Element(a)

tram_fill

</> 
pub fn tram_fill(attrs: List(Attribute(a))) -> Element(a)

tram_light

</> 
pub fn tram_light(attrs: List(Attribute(a))) -> Element(a)

tram_regular

</> 
pub fn tram_regular(attrs: List(Attribute(a))) -> Element(a)

tram_thin

</> 
pub fn tram_thin(attrs: List(Attribute(a))) -> Element(a)

translate_bold

</> 
pub fn translate_bold(attrs: List(Attribute(a))) -> Element(a)

translate_duotone

</> 
pub fn translate_duotone(attrs: List(Attribute(a))) -> Element(a)

translate_fill

</> 
pub fn translate_fill(attrs: List(Attribute(a))) -> Element(a)

translate_light

</> 
pub fn translate_light(attrs: List(Attribute(a))) -> Element(a)

translate_regular

</> 
pub fn translate_regular(attrs: List(Attribute(a))) -> Element(a)

translate_thin

</> 
pub fn translate_thin(attrs: List(Attribute(a))) -> Element(a)

trash_bold

</> 
pub fn trash_bold(attrs: List(Attribute(a))) -> Element(a)

trash_duotone

</> 
pub fn trash_duotone(attrs: List(Attribute(a))) -> Element(a)

trash_fill

</> 
pub fn trash_fill(attrs: List(Attribute(a))) -> Element(a)

trash_light

</> 
pub fn trash_light(attrs: List(Attribute(a))) -> Element(a)

trash_regular

</> 
pub fn trash_regular(attrs: List(Attribute(a))) -> Element(a)

trash_simple_bold

</> 
pub fn trash_simple_bold(attrs: List(Attribute(a))) -> Element(a)

trash_simple_duotone

</> 
pub fn trash_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

trash_simple_fill

</> 
pub fn trash_simple_fill(attrs: List(Attribute(a))) -> Element(a)

trash_simple_light

</> 
pub fn trash_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

trash_simple_regular

</> 
pub fn trash_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

trash_simple_thin

</> 
pub fn trash_simple_thin(attrs: List(Attribute(a))) -> Element(a)

trash_thin

</> 
pub fn trash_thin(attrs: List(Attribute(a))) -> Element(a)

tray_arrow_down_bold

</> 
pub fn tray_arrow_down_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_down_duotone

</> 
pub fn tray_arrow_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_down_fill

</> 
pub fn tray_arrow_down_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_down_light

</> 
pub fn tray_arrow_down_light(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_down_regular

</> 
pub fn tray_arrow_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_down_thin

</> 
pub fn tray_arrow_down_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_up_bold

</> 
pub fn tray_arrow_up_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_up_duotone

</> 
pub fn tray_arrow_up_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_up_fill

</> 
pub fn tray_arrow_up_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_up_light

</> 
pub fn tray_arrow_up_light(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_up_regular

</> 
pub fn tray_arrow_up_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_arrow_up_thin

</> 
pub fn tray_arrow_up_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

tray_bold

</> 
pub fn tray_bold(attrs: List(Attribute(a))) -> Element(a)

tray_duotone

</> 
pub fn tray_duotone(attrs: List(Attribute(a))) -> Element(a)

tray_fill

</> 
pub fn tray_fill(attrs: List(Attribute(a))) -> Element(a)

tray_light

</> 
pub fn tray_light(attrs: List(Attribute(a))) -> Element(a)

tray_regular

</> 
pub fn tray_regular(attrs: List(Attribute(a))) -> Element(a)

tray_thin

</> 
pub fn tray_thin(attrs: List(Attribute(a))) -> Element(a)

treasure_chest_bold

</> 
pub fn treasure_chest_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

treasure_chest_duotone

</> 
pub fn treasure_chest_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

treasure_chest_fill

</> 
pub fn treasure_chest_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

treasure_chest_light

</> 
pub fn treasure_chest_light(
  attrs: List(Attribute(a)),
) -> Element(a)

treasure_chest_regular

</> 
pub fn treasure_chest_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

treasure_chest_thin

</> 
pub fn treasure_chest_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_bold

</> 
pub fn tree_bold(attrs: List(Attribute(a))) -> Element(a)

tree_duotone

</> 
pub fn tree_duotone(attrs: List(Attribute(a))) -> Element(a)

tree_evergreen_bold

</> 
pub fn tree_evergreen_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_evergreen_duotone

</> 
pub fn tree_evergreen_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_evergreen_fill

</> 
pub fn tree_evergreen_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_evergreen_light

</> 
pub fn tree_evergreen_light(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_evergreen_regular

</> 
pub fn tree_evergreen_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_evergreen_thin

</> 
pub fn tree_evergreen_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_fill

</> 
pub fn tree_fill(attrs: List(Attribute(a))) -> Element(a)

tree_light

</> 
pub fn tree_light(attrs: List(Attribute(a))) -> Element(a)

tree_palm_bold

</> 
pub fn tree_palm_bold(attrs: List(Attribute(a))) -> Element(a)

tree_palm_duotone

</> 
pub fn tree_palm_duotone(attrs: List(Attribute(a))) -> Element(a)

tree_palm_fill

</> 
pub fn tree_palm_fill(attrs: List(Attribute(a))) -> Element(a)

tree_palm_light

</> 
pub fn tree_palm_light(attrs: List(Attribute(a))) -> Element(a)

tree_palm_regular

</> 
pub fn tree_palm_regular(attrs: List(Attribute(a))) -> Element(a)

tree_palm_thin

</> 
pub fn tree_palm_thin(attrs: List(Attribute(a))) -> Element(a)

tree_regular

</> 
pub fn tree_regular(attrs: List(Attribute(a))) -> Element(a)

tree_structure_bold

</> 
pub fn tree_structure_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_structure_duotone

</> 
pub fn tree_structure_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_structure_fill

</> 
pub fn tree_structure_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_structure_light

</> 
pub fn tree_structure_light(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_structure_regular

</> 
pub fn tree_structure_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_structure_thin

</> 
pub fn tree_structure_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

tree_thin

</> 
pub fn tree_thin(attrs: List(Attribute(a))) -> Element(a)

tree_view_bold

</> 
pub fn tree_view_bold(attrs: List(Attribute(a))) -> Element(a)

tree_view_duotone

</> 
pub fn tree_view_duotone(attrs: List(Attribute(a))) -> Element(a)

tree_view_fill

</> 
pub fn tree_view_fill(attrs: List(Attribute(a))) -> Element(a)

tree_view_light

</> 
pub fn tree_view_light(attrs: List(Attribute(a))) -> Element(a)

tree_view_regular

</> 
pub fn tree_view_regular(attrs: List(Attribute(a))) -> Element(a)

tree_view_thin

</> 
pub fn tree_view_thin(attrs: List(Attribute(a))) -> Element(a)

trend_down_bold

</> 
pub fn trend_down_bold(attrs: List(Attribute(a))) -> Element(a)

trend_down_duotone

</> 
pub fn trend_down_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

trend_down_fill

</> 
pub fn trend_down_fill(attrs: List(Attribute(a))) -> Element(a)

trend_down_light

</> 
pub fn trend_down_light(attrs: List(Attribute(a))) -> Element(a)

trend_down_regular

</> 
pub fn trend_down_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

trend_down_thin

</> 
pub fn trend_down_thin(attrs: List(Attribute(a))) -> Element(a)

trend_up_bold

</> 
pub fn trend_up_bold(attrs: List(Attribute(a))) -> Element(a)

trend_up_duotone

</> 
pub fn trend_up_duotone(attrs: List(Attribute(a))) -> Element(a)

trend_up_fill

</> 
pub fn trend_up_fill(attrs: List(Attribute(a))) -> Element(a)

trend_up_light

</> 
pub fn trend_up_light(attrs: List(Attribute(a))) -> Element(a)

trend_up_regular

</> 
pub fn trend_up_regular(attrs: List(Attribute(a))) -> Element(a)

trend_up_thin

</> 
pub fn trend_up_thin(attrs: List(Attribute(a))) -> Element(a)

triangle_bold

</> 
pub fn triangle_bold(attrs: List(Attribute(a))) -> Element(a)

triangle_dashed_bold

</> 
pub fn triangle_dashed_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

triangle_dashed_duotone

</> 
pub fn triangle_dashed_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

triangle_dashed_fill

</> 
pub fn triangle_dashed_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

triangle_dashed_light

</> 
pub fn triangle_dashed_light(
  attrs: List(Attribute(a)),
) -> Element(a)

triangle_dashed_regular

</> 
pub fn triangle_dashed_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

triangle_dashed_thin

</> 
pub fn triangle_dashed_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

triangle_duotone

</> 
pub fn triangle_duotone(attrs: List(Attribute(a))) -> Element(a)

triangle_fill

</> 
pub fn triangle_fill(attrs: List(Attribute(a))) -> Element(a)

triangle_light

</> 
pub fn triangle_light(attrs: List(Attribute(a))) -> Element(a)

triangle_regular

</> 
pub fn triangle_regular(attrs: List(Attribute(a))) -> Element(a)

triangle_thin

</> 
pub fn triangle_thin(attrs: List(Attribute(a))) -> Element(a)

trolley_bold

</> 
pub fn trolley_bold(attrs: List(Attribute(a))) -> Element(a)

trolley_duotone

</> 
pub fn trolley_duotone(attrs: List(Attribute(a))) -> Element(a)

trolley_fill

</> 
pub fn trolley_fill(attrs: List(Attribute(a))) -> Element(a)

trolley_light

</> 
pub fn trolley_light(attrs: List(Attribute(a))) -> Element(a)

trolley_regular

</> 
pub fn trolley_regular(attrs: List(Attribute(a))) -> Element(a)

trolley_suitcase_bold

</> 
pub fn trolley_suitcase_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

trolley_suitcase_duotone

</> 
pub fn trolley_suitcase_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

trolley_suitcase_fill

</> 
pub fn trolley_suitcase_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

trolley_suitcase_light

</> 
pub fn trolley_suitcase_light(
  attrs: List(Attribute(a)),
) -> Element(a)

trolley_suitcase_regular

</> 
pub fn trolley_suitcase_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

trolley_suitcase_thin

</> 
pub fn trolley_suitcase_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

trolley_thin

</> 
pub fn trolley_thin(attrs: List(Attribute(a))) -> Element(a)

trophy_bold

</> 
pub fn trophy_bold(attrs: List(Attribute(a))) -> Element(a)

trophy_duotone

</> 
pub fn trophy_duotone(attrs: List(Attribute(a))) -> Element(a)

trophy_fill

</> 
pub fn trophy_fill(attrs: List(Attribute(a))) -> Element(a)

trophy_light

</> 
pub fn trophy_light(attrs: List(Attribute(a))) -> Element(a)

trophy_regular

</> 
pub fn trophy_regular(attrs: List(Attribute(a))) -> Element(a)

trophy_thin

</> 
pub fn trophy_thin(attrs: List(Attribute(a))) -> Element(a)

truck_bold

</> 
pub fn truck_bold(attrs: List(Attribute(a))) -> Element(a)

truck_duotone

</> 
pub fn truck_duotone(attrs: List(Attribute(a))) -> Element(a)

truck_fill

</> 
pub fn truck_fill(attrs: List(Attribute(a))) -> Element(a)

truck_light

</> 
pub fn truck_light(attrs: List(Attribute(a))) -> Element(a)

truck_regular

</> 
pub fn truck_regular(attrs: List(Attribute(a))) -> Element(a)

truck_thin

</> 
pub fn truck_thin(attrs: List(Attribute(a))) -> Element(a)

truck_trailer_bold

</> 
pub fn truck_trailer_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

truck_trailer_duotone

</> 
pub fn truck_trailer_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

truck_trailer_fill

</> 
pub fn truck_trailer_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

truck_trailer_light

</> 
pub fn truck_trailer_light(
  attrs: List(Attribute(a)),
) -> Element(a)

truck_trailer_regular

</> 
pub fn truck_trailer_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

truck_trailer_thin

</> 
pub fn truck_trailer_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

tumblr_logo_bold

</> 
pub fn tumblr_logo_bold(attrs: List(Attribute(a))) -> Element(a)

tumblr_logo_duotone

</> 
pub fn tumblr_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

tumblr_logo_fill

</> 
pub fn tumblr_logo_fill(attrs: List(Attribute(a))) -> Element(a)

tumblr_logo_light

</> 
pub fn tumblr_logo_light(attrs: List(Attribute(a))) -> Element(a)

tumblr_logo_regular

</> 
pub fn tumblr_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

tumblr_logo_thin

</> 
pub fn tumblr_logo_thin(attrs: List(Attribute(a))) -> Element(a)

twitch_logo_bold

</> 
pub fn twitch_logo_bold(attrs: List(Attribute(a))) -> Element(a)

twitch_logo_duotone

</> 
pub fn twitch_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

twitch_logo_fill

</> 
pub fn twitch_logo_fill(attrs: List(Attribute(a))) -> Element(a)

twitch_logo_light

</> 
pub fn twitch_logo_light(attrs: List(Attribute(a))) -> Element(a)

twitch_logo_regular

</> 
pub fn twitch_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

twitch_logo_thin

</> 
pub fn twitch_logo_thin(attrs: List(Attribute(a))) -> Element(a)

twitter_logo_bold

</> 
pub fn twitter_logo_bold(attrs: List(Attribute(a))) -> Element(a)

twitter_logo_duotone

</> 
pub fn twitter_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

twitter_logo_fill

</> 
pub fn twitter_logo_fill(attrs: List(Attribute(a))) -> Element(a)

twitter_logo_light

</> 
pub fn twitter_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

twitter_logo_regular

</> 
pub fn twitter_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

twitter_logo_thin

</> 
pub fn twitter_logo_thin(attrs: List(Attribute(a))) -> Element(a)

umbrella_bold

</> 
pub fn umbrella_bold(attrs: List(Attribute(a))) -> Element(a)

umbrella_duotone

</> 
pub fn umbrella_duotone(attrs: List(Attribute(a))) -> Element(a)

umbrella_fill

</> 
pub fn umbrella_fill(attrs: List(Attribute(a))) -> Element(a)

umbrella_light

</> 
pub fn umbrella_light(attrs: List(Attribute(a))) -> Element(a)

umbrella_regular

</> 
pub fn umbrella_regular(attrs: List(Attribute(a))) -> Element(a)

umbrella_simple_bold

</> 
pub fn umbrella_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

umbrella_simple_duotone

</> 
pub fn umbrella_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

umbrella_simple_fill

</> 
pub fn umbrella_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

umbrella_simple_light

</> 
pub fn umbrella_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

umbrella_simple_regular

</> 
pub fn umbrella_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

umbrella_simple_thin

</> 
pub fn umbrella_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

umbrella_thin

</> 
pub fn umbrella_thin(attrs: List(Attribute(a))) -> Element(a)

union_bold

</> 
pub fn union_bold(attrs: List(Attribute(a))) -> Element(a)

union_duotone

</> 
pub fn union_duotone(attrs: List(Attribute(a))) -> Element(a)

union_fill

</> 
pub fn union_fill(attrs: List(Attribute(a))) -> Element(a)

union_light

</> 
pub fn union_light(attrs: List(Attribute(a))) -> Element(a)

union_regular

</> 
pub fn union_regular(attrs: List(Attribute(a))) -> Element(a)

union_thin

</> 
pub fn union_thin(attrs: List(Attribute(a))) -> Element(a)

unite_bold

</> 
pub fn unite_bold(attrs: List(Attribute(a))) -> Element(a)

unite_duotone

</> 
pub fn unite_duotone(attrs: List(Attribute(a))) -> Element(a)

unite_fill

</> 
pub fn unite_fill(attrs: List(Attribute(a))) -> Element(a)

unite_light

</> 
pub fn unite_light(attrs: List(Attribute(a))) -> Element(a)

unite_regular

</> 
pub fn unite_regular(attrs: List(Attribute(a))) -> Element(a)

unite_square_bold

</> 
pub fn unite_square_bold(attrs: List(Attribute(a))) -> Element(a)

unite_square_duotone

</> 
pub fn unite_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

unite_square_fill

</> 
pub fn unite_square_fill(attrs: List(Attribute(a))) -> Element(a)

unite_square_light

</> 
pub fn unite_square_light(
  attrs: List(Attribute(a)),
) -> Element(a)

unite_square_regular

</> 
pub fn unite_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

unite_square_thin

</> 
pub fn unite_square_thin(attrs: List(Attribute(a))) -> Element(a)

unite_thin

</> 
pub fn unite_thin(attrs: List(Attribute(a))) -> Element(a)

upload_bold

</> 
pub fn upload_bold(attrs: List(Attribute(a))) -> Element(a)

upload_duotone

</> 
pub fn upload_duotone(attrs: List(Attribute(a))) -> Element(a)

upload_fill

</> 
pub fn upload_fill(attrs: List(Attribute(a))) -> Element(a)

upload_light

</> 
pub fn upload_light(attrs: List(Attribute(a))) -> Element(a)

upload_regular

</> 
pub fn upload_regular(attrs: List(Attribute(a))) -> Element(a)

upload_simple_bold

</> 
pub fn upload_simple_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

upload_simple_duotone

</> 
pub fn upload_simple_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

upload_simple_fill

</> 
pub fn upload_simple_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

upload_simple_light

</> 
pub fn upload_simple_light(
  attrs: List(Attribute(a)),
) -> Element(a)

upload_simple_regular

</> 
pub fn upload_simple_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

upload_simple_thin

</> 
pub fn upload_simple_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

upload_thin

</> 
pub fn upload_thin(attrs: List(Attribute(a))) -> Element(a)

usb_bold

</> 
pub fn usb_bold(attrs: List(Attribute(a))) -> Element(a)

usb_duotone

</> 
pub fn usb_duotone(attrs: List(Attribute(a))) -> Element(a)

usb_fill

</> 
pub fn usb_fill(attrs: List(Attribute(a))) -> Element(a)

usb_light

</> 
pub fn usb_light(attrs: List(Attribute(a))) -> Element(a)

usb_regular

</> 
pub fn usb_regular(attrs: List(Attribute(a))) -> Element(a)

usb_thin

</> 
pub fn usb_thin(attrs: List(Attribute(a))) -> Element(a)

user_bold

</> 
pub fn user_bold(attrs: List(Attribute(a))) -> Element(a)

user_check_bold

</> 
pub fn user_check_bold(attrs: List(Attribute(a))) -> Element(a)

user_check_duotone

</> 
pub fn user_check_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_check_fill

</> 
pub fn user_check_fill(attrs: List(Attribute(a))) -> Element(a)

user_check_light

</> 
pub fn user_check_light(attrs: List(Attribute(a))) -> Element(a)

user_check_regular

</> 
pub fn user_check_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_check_thin

</> 
pub fn user_check_thin(attrs: List(Attribute(a))) -> Element(a)

user_circle_bold

</> 
pub fn user_circle_bold(attrs: List(Attribute(a))) -> Element(a)

user_circle_check_bold

</> 
pub fn user_circle_check_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_check_duotone

</> 
pub fn user_circle_check_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_check_fill

</> 
pub fn user_circle_check_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_check_light

</> 
pub fn user_circle_check_light(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_check_regular

</> 
pub fn user_circle_check_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_check_thin

</> 
pub fn user_circle_check_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_dashed_bold

</> 
pub fn user_circle_dashed_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_dashed_duotone

</> 
pub fn user_circle_dashed_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_dashed_fill

</> 
pub fn user_circle_dashed_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_dashed_light

</> 
pub fn user_circle_dashed_light(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_dashed_regular

</> 
pub fn user_circle_dashed_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_dashed_thin

</> 
pub fn user_circle_dashed_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_duotone

</> 
pub fn user_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_fill

</> 
pub fn user_circle_fill(attrs: List(Attribute(a))) -> Element(a)

user_circle_gear_bold

</> 
pub fn user_circle_gear_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_gear_duotone

</> 
pub fn user_circle_gear_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_gear_fill

</> 
pub fn user_circle_gear_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_gear_light

</> 
pub fn user_circle_gear_light(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_gear_regular

</> 
pub fn user_circle_gear_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_gear_thin

</> 
pub fn user_circle_gear_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_light

</> 
pub fn user_circle_light(attrs: List(Attribute(a))) -> Element(a)

user_circle_minus_bold

</> 
pub fn user_circle_minus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_minus_duotone

</> 
pub fn user_circle_minus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_minus_fill

</> 
pub fn user_circle_minus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_minus_light

</> 
pub fn user_circle_minus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_minus_regular

</> 
pub fn user_circle_minus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_minus_thin

</> 
pub fn user_circle_minus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_plus_bold

</> 
pub fn user_circle_plus_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_plus_duotone

</> 
pub fn user_circle_plus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_plus_fill

</> 
pub fn user_circle_plus_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_plus_light

</> 
pub fn user_circle_plus_light(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_plus_regular

</> 
pub fn user_circle_plus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_plus_thin

</> 
pub fn user_circle_plus_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_regular

</> 
pub fn user_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_circle_thin

</> 
pub fn user_circle_thin(attrs: List(Attribute(a))) -> Element(a)

user_duotone

</> 
pub fn user_duotone(attrs: List(Attribute(a))) -> Element(a)

user_fill

</> 
pub fn user_fill(attrs: List(Attribute(a))) -> Element(a)

user_focus_bold

</> 
pub fn user_focus_bold(attrs: List(Attribute(a))) -> Element(a)

user_focus_duotone

</> 
pub fn user_focus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_focus_fill

</> 
pub fn user_focus_fill(attrs: List(Attribute(a))) -> Element(a)

user_focus_light

</> 
pub fn user_focus_light(attrs: List(Attribute(a))) -> Element(a)

user_focus_regular

</> 
pub fn user_focus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_focus_thin

</> 
pub fn user_focus_thin(attrs: List(Attribute(a))) -> Element(a)

user_gear_bold

</> 
pub fn user_gear_bold(attrs: List(Attribute(a))) -> Element(a)

user_gear_duotone

</> 
pub fn user_gear_duotone(attrs: List(Attribute(a))) -> Element(a)

user_gear_fill

</> 
pub fn user_gear_fill(attrs: List(Attribute(a))) -> Element(a)

user_gear_light

</> 
pub fn user_gear_light(attrs: List(Attribute(a))) -> Element(a)

user_gear_regular

</> 
pub fn user_gear_regular(attrs: List(Attribute(a))) -> Element(a)

user_gear_thin

</> 
pub fn user_gear_thin(attrs: List(Attribute(a))) -> Element(a)

user_light

</> 
pub fn user_light(attrs: List(Attribute(a))) -> Element(a)

user_list_bold

</> 
pub fn user_list_bold(attrs: List(Attribute(a))) -> Element(a)

user_list_duotone

</> 
pub fn user_list_duotone(attrs: List(Attribute(a))) -> Element(a)

user_list_fill

</> 
pub fn user_list_fill(attrs: List(Attribute(a))) -> Element(a)

user_list_light

</> 
pub fn user_list_light(attrs: List(Attribute(a))) -> Element(a)

user_list_regular

</> 
pub fn user_list_regular(attrs: List(Attribute(a))) -> Element(a)

user_list_thin

</> 
pub fn user_list_thin(attrs: List(Attribute(a))) -> Element(a)

user_minus_bold

</> 
pub fn user_minus_bold(attrs: List(Attribute(a))) -> Element(a)

user_minus_duotone

</> 
pub fn user_minus_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_minus_fill

</> 
pub fn user_minus_fill(attrs: List(Attribute(a))) -> Element(a)

user_minus_light

</> 
pub fn user_minus_light(attrs: List(Attribute(a))) -> Element(a)

user_minus_regular

</> 
pub fn user_minus_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_minus_thin

</> 
pub fn user_minus_thin(attrs: List(Attribute(a))) -> Element(a)

user_plus_bold

</> 
pub fn user_plus_bold(attrs: List(Attribute(a))) -> Element(a)

user_plus_duotone

</> 
pub fn user_plus_duotone(attrs: List(Attribute(a))) -> Element(a)

user_plus_fill

</> 
pub fn user_plus_fill(attrs: List(Attribute(a))) -> Element(a)

user_plus_light

</> 
pub fn user_plus_light(attrs: List(Attribute(a))) -> Element(a)

user_plus_regular

</> 
pub fn user_plus_regular(attrs: List(Attribute(a))) -> Element(a)

user_plus_thin

</> 
pub fn user_plus_thin(attrs: List(Attribute(a))) -> Element(a)

user_rectangle_bold

</> 
pub fn user_rectangle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

user_rectangle_duotone

</> 
pub fn user_rectangle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_rectangle_fill

</> 
pub fn user_rectangle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

user_rectangle_light

</> 
pub fn user_rectangle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

user_rectangle_regular

</> 
pub fn user_rectangle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_rectangle_thin

</> 
pub fn user_rectangle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

user_regular

</> 
pub fn user_regular(attrs: List(Attribute(a))) -> Element(a)

user_sound_bold

</> 
pub fn user_sound_bold(attrs: List(Attribute(a))) -> Element(a)

user_sound_duotone

</> 
pub fn user_sound_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_sound_fill

</> 
pub fn user_sound_fill(attrs: List(Attribute(a))) -> Element(a)

user_sound_light

</> 
pub fn user_sound_light(attrs: List(Attribute(a))) -> Element(a)

user_sound_regular

</> 
pub fn user_sound_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_sound_thin

</> 
pub fn user_sound_thin(attrs: List(Attribute(a))) -> Element(a)

user_square_bold

</> 
pub fn user_square_bold(attrs: List(Attribute(a))) -> Element(a)

user_square_duotone

</> 
pub fn user_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_square_fill

</> 
pub fn user_square_fill(attrs: List(Attribute(a))) -> Element(a)

user_square_light

</> 
pub fn user_square_light(attrs: List(Attribute(a))) -> Element(a)

user_square_regular

</> 
pub fn user_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_square_thin

</> 
pub fn user_square_thin(attrs: List(Attribute(a))) -> Element(a)

user_switch_bold

</> 
pub fn user_switch_bold(attrs: List(Attribute(a))) -> Element(a)

user_switch_duotone

</> 
pub fn user_switch_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

user_switch_fill

</> 
pub fn user_switch_fill(attrs: List(Attribute(a))) -> Element(a)

user_switch_light

</> 
pub fn user_switch_light(attrs: List(Attribute(a))) -> Element(a)

user_switch_regular

</> 
pub fn user_switch_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

user_switch_thin

</> 
pub fn user_switch_thin(attrs: List(Attribute(a))) -> Element(a)

user_thin

</> 
pub fn user_thin(attrs: List(Attribute(a))) -> Element(a)

users_bold

</> 
pub fn users_bold(attrs: List(Attribute(a))) -> Element(a)

users_duotone

</> 
pub fn users_duotone(attrs: List(Attribute(a))) -> Element(a)

users_fill

</> 
pub fn users_fill(attrs: List(Attribute(a))) -> Element(a)

users_four_bold

</> 
pub fn users_four_bold(attrs: List(Attribute(a))) -> Element(a)

users_four_duotone

</> 
pub fn users_four_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

users_four_fill

</> 
pub fn users_four_fill(attrs: List(Attribute(a))) -> Element(a)

users_four_light

</> 
pub fn users_four_light(attrs: List(Attribute(a))) -> Element(a)

users_four_regular

</> 
pub fn users_four_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

users_four_thin

</> 
pub fn users_four_thin(attrs: List(Attribute(a))) -> Element(a)

users_light

</> 
pub fn users_light(attrs: List(Attribute(a))) -> Element(a)

users_regular

</> 
pub fn users_regular(attrs: List(Attribute(a))) -> Element(a)

users_thin

</> 
pub fn users_thin(attrs: List(Attribute(a))) -> Element(a)

users_three_bold

</> 
pub fn users_three_bold(attrs: List(Attribute(a))) -> Element(a)

users_three_duotone

</> 
pub fn users_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

users_three_fill

</> 
pub fn users_three_fill(attrs: List(Attribute(a))) -> Element(a)

users_three_light

</> 
pub fn users_three_light(attrs: List(Attribute(a))) -> Element(a)

users_three_regular

</> 
pub fn users_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

users_three_thin

</> 
pub fn users_three_thin(attrs: List(Attribute(a))) -> Element(a)

van_bold

</> 
pub fn van_bold(attrs: List(Attribute(a))) -> Element(a)

van_duotone

</> 
pub fn van_duotone(attrs: List(Attribute(a))) -> Element(a)

van_fill

</> 
pub fn van_fill(attrs: List(Attribute(a))) -> Element(a)

van_light

</> 
pub fn van_light(attrs: List(Attribute(a))) -> Element(a)

van_regular

</> 
pub fn van_regular(attrs: List(Attribute(a))) -> Element(a)

van_thin

</> 
pub fn van_thin(attrs: List(Attribute(a))) -> Element(a)

vault_bold

</> 
pub fn vault_bold(attrs: List(Attribute(a))) -> Element(a)

vault_duotone

</> 
pub fn vault_duotone(attrs: List(Attribute(a))) -> Element(a)

vault_fill

</> 
pub fn vault_fill(attrs: List(Attribute(a))) -> Element(a)

vault_light

</> 
pub fn vault_light(attrs: List(Attribute(a))) -> Element(a)

vault_regular

</> 
pub fn vault_regular(attrs: List(Attribute(a))) -> Element(a)

vault_thin

</> 
pub fn vault_thin(attrs: List(Attribute(a))) -> Element(a)

vector_three_bold

</> 
pub fn vector_three_bold(attrs: List(Attribute(a))) -> Element(a)

vector_three_duotone

</> 
pub fn vector_three_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

vector_three_fill

</> 
pub fn vector_three_fill(attrs: List(Attribute(a))) -> Element(a)

vector_three_light

</> 
pub fn vector_three_light(
  attrs: List(Attribute(a)),
) -> Element(a)

vector_three_regular

</> 
pub fn vector_three_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

vector_three_thin

</> 
pub fn vector_three_thin(attrs: List(Attribute(a))) -> Element(a)

vector_two_bold

</> 
pub fn vector_two_bold(attrs: List(Attribute(a))) -> Element(a)

vector_two_duotone

</> 
pub fn vector_two_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

vector_two_fill

</> 
pub fn vector_two_fill(attrs: List(Attribute(a))) -> Element(a)

vector_two_light

</> 
pub fn vector_two_light(attrs: List(Attribute(a))) -> Element(a)

vector_two_regular

</> 
pub fn vector_two_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

vector_two_thin

</> 
pub fn vector_two_thin(attrs: List(Attribute(a))) -> Element(a)

vibrate_bold

</> 
pub fn vibrate_bold(attrs: List(Attribute(a))) -> Element(a)

vibrate_duotone

</> 
pub fn vibrate_duotone(attrs: List(Attribute(a))) -> Element(a)

vibrate_fill

</> 
pub fn vibrate_fill(attrs: List(Attribute(a))) -> Element(a)

vibrate_light

</> 
pub fn vibrate_light(attrs: List(Attribute(a))) -> Element(a)

vibrate_regular

</> 
pub fn vibrate_regular(attrs: List(Attribute(a))) -> Element(a)

vibrate_thin

</> 
pub fn vibrate_thin(attrs: List(Attribute(a))) -> Element(a)

video_bold

</> 
pub fn video_bold(attrs: List(Attribute(a))) -> Element(a)

video_camera_bold

</> 
pub fn video_camera_bold(attrs: List(Attribute(a))) -> Element(a)

video_camera_duotone

</> 
pub fn video_camera_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

video_camera_fill

</> 
pub fn video_camera_fill(attrs: List(Attribute(a))) -> Element(a)

video_camera_light

</> 
pub fn video_camera_light(
  attrs: List(Attribute(a)),
) -> Element(a)

video_camera_regular

</> 
pub fn video_camera_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

video_camera_slash_bold

</> 
pub fn video_camera_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

video_camera_slash_duotone

</> 
pub fn video_camera_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

video_camera_slash_fill

</> 
pub fn video_camera_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

video_camera_slash_light

</> 
pub fn video_camera_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

video_camera_slash_regular

</> 
pub fn video_camera_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

video_camera_slash_thin

</> 
pub fn video_camera_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

video_camera_thin

</> 
pub fn video_camera_thin(attrs: List(Attribute(a))) -> Element(a)

video_conference_bold

</> 
pub fn video_conference_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

video_conference_duotone

</> 
pub fn video_conference_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

video_conference_fill

</> 
pub fn video_conference_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

video_conference_light

</> 
pub fn video_conference_light(
  attrs: List(Attribute(a)),
) -> Element(a)

video_conference_regular

</> 
pub fn video_conference_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

video_conference_thin

</> 
pub fn video_conference_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

video_duotone

</> 
pub fn video_duotone(attrs: List(Attribute(a))) -> Element(a)

video_fill

</> 
pub fn video_fill(attrs: List(Attribute(a))) -> Element(a)

video_light

</> 
pub fn video_light(attrs: List(Attribute(a))) -> Element(a)

video_regular

</> 
pub fn video_regular(attrs: List(Attribute(a))) -> Element(a)

video_thin

</> 
pub fn video_thin(attrs: List(Attribute(a))) -> Element(a)

vignette_bold

</> 
pub fn vignette_bold(attrs: List(Attribute(a))) -> Element(a)

vignette_duotone

</> 
pub fn vignette_duotone(attrs: List(Attribute(a))) -> Element(a)

vignette_fill

</> 
pub fn vignette_fill(attrs: List(Attribute(a))) -> Element(a)

vignette_light

</> 
pub fn vignette_light(attrs: List(Attribute(a))) -> Element(a)

vignette_regular

</> 
pub fn vignette_regular(attrs: List(Attribute(a))) -> Element(a)

vignette_thin

</> 
pub fn vignette_thin(attrs: List(Attribute(a))) -> Element(a)

vinyl_record_bold

</> 
pub fn vinyl_record_bold(attrs: List(Attribute(a))) -> Element(a)

vinyl_record_duotone

</> 
pub fn vinyl_record_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

vinyl_record_fill

</> 
pub fn vinyl_record_fill(attrs: List(Attribute(a))) -> Element(a)

vinyl_record_light

</> 
pub fn vinyl_record_light(
  attrs: List(Attribute(a)),
) -> Element(a)

vinyl_record_regular

</> 
pub fn vinyl_record_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

vinyl_record_thin

</> 
pub fn vinyl_record_thin(attrs: List(Attribute(a))) -> Element(a)

virtual_reality_bold

</> 
pub fn virtual_reality_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

virtual_reality_duotone

</> 
pub fn virtual_reality_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

virtual_reality_fill

</> 
pub fn virtual_reality_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

virtual_reality_light

</> 
pub fn virtual_reality_light(
  attrs: List(Attribute(a)),
) -> Element(a)

virtual_reality_regular

</> 
pub fn virtual_reality_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

virtual_reality_thin

</> 
pub fn virtual_reality_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

virus_bold

</> 
pub fn virus_bold(attrs: List(Attribute(a))) -> Element(a)

virus_duotone

</> 
pub fn virus_duotone(attrs: List(Attribute(a))) -> Element(a)

virus_fill

</> 
pub fn virus_fill(attrs: List(Attribute(a))) -> Element(a)

virus_light

</> 
pub fn virus_light(attrs: List(Attribute(a))) -> Element(a)

virus_regular

</> 
pub fn virus_regular(attrs: List(Attribute(a))) -> Element(a)

virus_thin

</> 
pub fn virus_thin(attrs: List(Attribute(a))) -> Element(a)

visor_bold

</> 
pub fn visor_bold(attrs: List(Attribute(a))) -> Element(a)

visor_duotone

</> 
pub fn visor_duotone(attrs: List(Attribute(a))) -> Element(a)

visor_fill

</> 
pub fn visor_fill(attrs: List(Attribute(a))) -> Element(a)

visor_light

</> 
pub fn visor_light(attrs: List(Attribute(a))) -> Element(a)

visor_regular

</> 
pub fn visor_regular(attrs: List(Attribute(a))) -> Element(a)

visor_thin

</> 
pub fn visor_thin(attrs: List(Attribute(a))) -> Element(a)

voicemail_bold

</> 
pub fn voicemail_bold(attrs: List(Attribute(a))) -> Element(a)

voicemail_duotone

</> 
pub fn voicemail_duotone(attrs: List(Attribute(a))) -> Element(a)

voicemail_fill

</> 
pub fn voicemail_fill(attrs: List(Attribute(a))) -> Element(a)

voicemail_light

</> 
pub fn voicemail_light(attrs: List(Attribute(a))) -> Element(a)

voicemail_regular

</> 
pub fn voicemail_regular(attrs: List(Attribute(a))) -> Element(a)

voicemail_thin

</> 
pub fn voicemail_thin(attrs: List(Attribute(a))) -> Element(a)

volleyball_bold

</> 
pub fn volleyball_bold(attrs: List(Attribute(a))) -> Element(a)

volleyball_duotone

</> 
pub fn volleyball_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

volleyball_fill

</> 
pub fn volleyball_fill(attrs: List(Attribute(a))) -> Element(a)

volleyball_light

</> 
pub fn volleyball_light(attrs: List(Attribute(a))) -> Element(a)

volleyball_regular

</> 
pub fn volleyball_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

volleyball_thin

</> 
pub fn volleyball_thin(attrs: List(Attribute(a))) -> Element(a)

wall_bold

</> 
pub fn wall_bold(attrs: List(Attribute(a))) -> Element(a)

wall_duotone

</> 
pub fn wall_duotone(attrs: List(Attribute(a))) -> Element(a)

wall_fill

</> 
pub fn wall_fill(attrs: List(Attribute(a))) -> Element(a)

wall_light

</> 
pub fn wall_light(attrs: List(Attribute(a))) -> Element(a)

wall_regular

</> 
pub fn wall_regular(attrs: List(Attribute(a))) -> Element(a)

wall_thin

</> 
pub fn wall_thin(attrs: List(Attribute(a))) -> Element(a)

wallet_bold

</> 
pub fn wallet_bold(attrs: List(Attribute(a))) -> Element(a)

wallet_duotone

</> 
pub fn wallet_duotone(attrs: List(Attribute(a))) -> Element(a)

wallet_fill

</> 
pub fn wallet_fill(attrs: List(Attribute(a))) -> Element(a)

wallet_light

</> 
pub fn wallet_light(attrs: List(Attribute(a))) -> Element(a)

wallet_regular

</> 
pub fn wallet_regular(attrs: List(Attribute(a))) -> Element(a)

wallet_thin

</> 
pub fn wallet_thin(attrs: List(Attribute(a))) -> Element(a)

warehouse_bold

</> 
pub fn warehouse_bold(attrs: List(Attribute(a))) -> Element(a)

warehouse_duotone

</> 
pub fn warehouse_duotone(attrs: List(Attribute(a))) -> Element(a)

warehouse_fill

</> 
pub fn warehouse_fill(attrs: List(Attribute(a))) -> Element(a)

warehouse_light

</> 
pub fn warehouse_light(attrs: List(Attribute(a))) -> Element(a)

warehouse_regular

</> 
pub fn warehouse_regular(attrs: List(Attribute(a))) -> Element(a)

warehouse_thin

</> 
pub fn warehouse_thin(attrs: List(Attribute(a))) -> Element(a)

warning_bold

</> 
pub fn warning_bold(attrs: List(Attribute(a))) -> Element(a)

warning_circle_bold

</> 
pub fn warning_circle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_circle_duotone

</> 
pub fn warning_circle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_circle_fill

</> 
pub fn warning_circle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_circle_light

</> 
pub fn warning_circle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_circle_regular

</> 
pub fn warning_circle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_circle_thin

</> 
pub fn warning_circle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_diamond_bold

</> 
pub fn warning_diamond_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_diamond_duotone

</> 
pub fn warning_diamond_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_diamond_fill

</> 
pub fn warning_diamond_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_diamond_light

</> 
pub fn warning_diamond_light(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_diamond_regular

</> 
pub fn warning_diamond_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_diamond_thin

</> 
pub fn warning_diamond_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_duotone

</> 
pub fn warning_duotone(attrs: List(Attribute(a))) -> Element(a)

warning_fill

</> 
pub fn warning_fill(attrs: List(Attribute(a))) -> Element(a)

warning_light

</> 
pub fn warning_light(attrs: List(Attribute(a))) -> Element(a)

warning_octagon_bold

</> 
pub fn warning_octagon_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_octagon_duotone

</> 
pub fn warning_octagon_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_octagon_fill

</> 
pub fn warning_octagon_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_octagon_light

</> 
pub fn warning_octagon_light(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_octagon_regular

</> 
pub fn warning_octagon_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_octagon_thin

</> 
pub fn warning_octagon_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

warning_regular

</> 
pub fn warning_regular(attrs: List(Attribute(a))) -> Element(a)

warning_thin

</> 
pub fn warning_thin(attrs: List(Attribute(a))) -> Element(a)

washing_machine_bold

</> 
pub fn washing_machine_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

washing_machine_duotone

</> 
pub fn washing_machine_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

washing_machine_fill

</> 
pub fn washing_machine_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

washing_machine_light

</> 
pub fn washing_machine_light(
  attrs: List(Attribute(a)),
) -> Element(a)

washing_machine_regular

</> 
pub fn washing_machine_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

washing_machine_thin

</> 
pub fn washing_machine_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

watch_bold

</> 
pub fn watch_bold(attrs: List(Attribute(a))) -> Element(a)

watch_duotone

</> 
pub fn watch_duotone(attrs: List(Attribute(a))) -> Element(a)

watch_fill

</> 
pub fn watch_fill(attrs: List(Attribute(a))) -> Element(a)

watch_light

</> 
pub fn watch_light(attrs: List(Attribute(a))) -> Element(a)

watch_regular

</> 
pub fn watch_regular(attrs: List(Attribute(a))) -> Element(a)

watch_thin

</> 
pub fn watch_thin(attrs: List(Attribute(a))) -> Element(a)

wave_sawtooth_bold

</> 
pub fn wave_sawtooth_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_sawtooth_duotone

</> 
pub fn wave_sawtooth_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_sawtooth_fill

</> 
pub fn wave_sawtooth_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_sawtooth_light

</> 
pub fn wave_sawtooth_light(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_sawtooth_regular

</> 
pub fn wave_sawtooth_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_sawtooth_thin

</> 
pub fn wave_sawtooth_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_sine_bold

</> 
pub fn wave_sine_bold(attrs: List(Attribute(a))) -> Element(a)

wave_sine_duotone

</> 
pub fn wave_sine_duotone(attrs: List(Attribute(a))) -> Element(a)

wave_sine_fill

</> 
pub fn wave_sine_fill(attrs: List(Attribute(a))) -> Element(a)

wave_sine_light

</> 
pub fn wave_sine_light(attrs: List(Attribute(a))) -> Element(a)

wave_sine_regular

</> 
pub fn wave_sine_regular(attrs: List(Attribute(a))) -> Element(a)

wave_sine_thin

</> 
pub fn wave_sine_thin(attrs: List(Attribute(a))) -> Element(a)

wave_square_bold

</> 
pub fn wave_square_bold(attrs: List(Attribute(a))) -> Element(a)

wave_square_duotone

</> 
pub fn wave_square_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_square_fill

</> 
pub fn wave_square_fill(attrs: List(Attribute(a))) -> Element(a)

wave_square_light

</> 
pub fn wave_square_light(attrs: List(Attribute(a))) -> Element(a)

wave_square_regular

</> 
pub fn wave_square_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_square_thin

</> 
pub fn wave_square_thin(attrs: List(Attribute(a))) -> Element(a)

wave_triangle_bold

</> 
pub fn wave_triangle_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_triangle_duotone

</> 
pub fn wave_triangle_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_triangle_fill

</> 
pub fn wave_triangle_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_triangle_light

</> 
pub fn wave_triangle_light(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_triangle_regular

</> 
pub fn wave_triangle_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

wave_triangle_thin

</> 
pub fn wave_triangle_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

waveform_bold

</> 
pub fn waveform_bold(attrs: List(Attribute(a))) -> Element(a)

waveform_duotone

</> 
pub fn waveform_duotone(attrs: List(Attribute(a))) -> Element(a)

waveform_fill

</> 
pub fn waveform_fill(attrs: List(Attribute(a))) -> Element(a)

waveform_light

</> 
pub fn waveform_light(attrs: List(Attribute(a))) -> Element(a)

waveform_regular

</> 
pub fn waveform_regular(attrs: List(Attribute(a))) -> Element(a)

waveform_slash_bold

</> 
pub fn waveform_slash_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

waveform_slash_duotone

</> 
pub fn waveform_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

waveform_slash_fill

</> 
pub fn waveform_slash_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

waveform_slash_light

</> 
pub fn waveform_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

waveform_slash_regular

</> 
pub fn waveform_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

waveform_slash_thin

</> 
pub fn waveform_slash_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

waveform_thin

</> 
pub fn waveform_thin(attrs: List(Attribute(a))) -> Element(a)

waves_bold

</> 
pub fn waves_bold(attrs: List(Attribute(a))) -> Element(a)

waves_duotone

</> 
pub fn waves_duotone(attrs: List(Attribute(a))) -> Element(a)

waves_fill

</> 
pub fn waves_fill(attrs: List(Attribute(a))) -> Element(a)

waves_light

</> 
pub fn waves_light(attrs: List(Attribute(a))) -> Element(a)

waves_regular

</> 
pub fn waves_regular(attrs: List(Attribute(a))) -> Element(a)

waves_thin

</> 
pub fn waves_thin(attrs: List(Attribute(a))) -> Element(a)

webcam_bold

</> 
pub fn webcam_bold(attrs: List(Attribute(a))) -> Element(a)

webcam_duotone

</> 
pub fn webcam_duotone(attrs: List(Attribute(a))) -> Element(a)

webcam_fill

</> 
pub fn webcam_fill(attrs: List(Attribute(a))) -> Element(a)

webcam_light

</> 
pub fn webcam_light(attrs: List(Attribute(a))) -> Element(a)

webcam_regular

</> 
pub fn webcam_regular(attrs: List(Attribute(a))) -> Element(a)

webcam_slash_bold

</> 
pub fn webcam_slash_bold(attrs: List(Attribute(a))) -> Element(a)

webcam_slash_duotone

</> 
pub fn webcam_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

webcam_slash_fill

</> 
pub fn webcam_slash_fill(attrs: List(Attribute(a))) -> Element(a)

webcam_slash_light

</> 
pub fn webcam_slash_light(
  attrs: List(Attribute(a)),
) -> Element(a)

webcam_slash_regular

</> 
pub fn webcam_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

webcam_slash_thin

</> 
pub fn webcam_slash_thin(attrs: List(Attribute(a))) -> Element(a)

webcam_thin

</> 
pub fn webcam_thin(attrs: List(Attribute(a))) -> Element(a)

webhooks_logo_bold

</> 
pub fn webhooks_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

webhooks_logo_duotone

</> 
pub fn webhooks_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

webhooks_logo_fill

</> 
pub fn webhooks_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

webhooks_logo_light

</> 
pub fn webhooks_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

webhooks_logo_regular

</> 
pub fn webhooks_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

webhooks_logo_thin

</> 
pub fn webhooks_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

wechat_logo_bold

</> 
pub fn wechat_logo_bold(attrs: List(Attribute(a))) -> Element(a)

wechat_logo_duotone

</> 
pub fn wechat_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

wechat_logo_fill

</> 
pub fn wechat_logo_fill(attrs: List(Attribute(a))) -> Element(a)

wechat_logo_light

</> 
pub fn wechat_logo_light(attrs: List(Attribute(a))) -> Element(a)

wechat_logo_regular

</> 
pub fn wechat_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

wechat_logo_thin

</> 
pub fn wechat_logo_thin(attrs: List(Attribute(a))) -> Element(a)

whatsapp_logo_bold

</> 
pub fn whatsapp_logo_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

whatsapp_logo_duotone

</> 
pub fn whatsapp_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

whatsapp_logo_fill

</> 
pub fn whatsapp_logo_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

whatsapp_logo_light

</> 
pub fn whatsapp_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

whatsapp_logo_regular

</> 
pub fn whatsapp_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

whatsapp_logo_thin

</> 
pub fn whatsapp_logo_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

wheelchair_bold

</> 
pub fn wheelchair_bold(attrs: List(Attribute(a))) -> Element(a)

wheelchair_duotone

</> 
pub fn wheelchair_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

wheelchair_fill

</> 
pub fn wheelchair_fill(attrs: List(Attribute(a))) -> Element(a)

wheelchair_light

</> 
pub fn wheelchair_light(attrs: List(Attribute(a))) -> Element(a)

wheelchair_motion_bold

</> 
pub fn wheelchair_motion_bold(
  attrs: List(Attribute(a)),
) -> Element(a)

wheelchair_motion_duotone

</> 
pub fn wheelchair_motion_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

wheelchair_motion_fill

</> 
pub fn wheelchair_motion_fill(
  attrs: List(Attribute(a)),
) -> Element(a)

wheelchair_motion_light

</> 
pub fn wheelchair_motion_light(
  attrs: List(Attribute(a)),
) -> Element(a)

wheelchair_motion_regular

</> 
pub fn wheelchair_motion_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

wheelchair_motion_thin

</> 
pub fn wheelchair_motion_thin(
  attrs: List(Attribute(a)),
) -> Element(a)

wheelchair_regular

</> 
pub fn wheelchair_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

wheelchair_thin

</> 
pub fn wheelchair_thin(attrs: List(Attribute(a))) -> Element(a)

wifi_high_bold

</> 
pub fn wifi_high_bold(attrs: List(Attribute(a))) -> Element(a)

wifi_high_duotone

</> 
pub fn wifi_high_duotone(attrs: List(Attribute(a))) -> Element(a)

wifi_high_fill

</> 
pub fn wifi_high_fill(attrs: List(Attribute(a))) -> Element(a)

wifi_high_light

</> 
pub fn wifi_high_light(attrs: List(Attribute(a))) -> Element(a)

wifi_high_regular

</> 
pub fn wifi_high_regular(attrs: List(Attribute(a))) -> Element(a)

wifi_high_thin

</> 
pub fn wifi_high_thin(attrs: List(Attribute(a))) -> Element(a)

wifi_low_bold

</> 
pub fn wifi_low_bold(attrs: List(Attribute(a))) -> Element(a)

wifi_low_duotone

</> 
pub fn wifi_low_duotone(attrs: List(Attribute(a))) -> Element(a)

wifi_low_fill

</> 
pub fn wifi_low_fill(attrs: List(Attribute(a))) -> Element(a)

wifi_low_light

</> 
pub fn wifi_low_light(attrs: List(Attribute(a))) -> Element(a)

wifi_low_regular

</> 
pub fn wifi_low_regular(attrs: List(Attribute(a))) -> Element(a)

wifi_low_thin

</> 
pub fn wifi_low_thin(attrs: List(Attribute(a))) -> Element(a)

wifi_medium_bold

</> 
pub fn wifi_medium_bold(attrs: List(Attribute(a))) -> Element(a)

wifi_medium_duotone

</> 
pub fn wifi_medium_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

wifi_medium_fill

</> 
pub fn wifi_medium_fill(attrs: List(Attribute(a))) -> Element(a)

wifi_medium_light

</> 
pub fn wifi_medium_light(attrs: List(Attribute(a))) -> Element(a)

wifi_medium_regular

</> 
pub fn wifi_medium_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

wifi_medium_thin

</> 
pub fn wifi_medium_thin(attrs: List(Attribute(a))) -> Element(a)

wifi_none_bold

</> 
pub fn wifi_none_bold(attrs: List(Attribute(a))) -> Element(a)

wifi_none_duotone

</> 
pub fn wifi_none_duotone(attrs: List(Attribute(a))) -> Element(a)

wifi_none_fill

</> 
pub fn wifi_none_fill(attrs: List(Attribute(a))) -> Element(a)

wifi_none_light

</> 
pub fn wifi_none_light(attrs: List(Attribute(a))) -> Element(a)

wifi_none_regular

</> 
pub fn wifi_none_regular(attrs: List(Attribute(a))) -> Element(a)

wifi_none_thin

</> 
pub fn wifi_none_thin(attrs: List(Attribute(a))) -> Element(a)

wifi_slash_bold

</> 
pub fn wifi_slash_bold(attrs: List(Attribute(a))) -> Element(a)

wifi_slash_duotone

</> 
pub fn wifi_slash_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

wifi_slash_fill

</> 
pub fn wifi_slash_fill(attrs: List(Attribute(a))) -> Element(a)

wifi_slash_light

</> 
pub fn wifi_slash_light(attrs: List(Attribute(a))) -> Element(a)

wifi_slash_regular

</> 
pub fn wifi_slash_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

wifi_slash_thin

</> 
pub fn wifi_slash_thin(attrs: List(Attribute(a))) -> Element(a)

wifi_x_bold

</> 
pub fn wifi_x_bold(attrs: List(Attribute(a))) -> Element(a)

wifi_x_duotone

</> 
pub fn wifi_x_duotone(attrs: List(Attribute(a))) -> Element(a)

wifi_x_fill

</> 
pub fn wifi_x_fill(attrs: List(Attribute(a))) -> Element(a)

wifi_x_light

</> 
pub fn wifi_x_light(attrs: List(Attribute(a))) -> Element(a)

wifi_x_regular

</> 
pub fn wifi_x_regular(attrs: List(Attribute(a))) -> Element(a)

wifi_x_thin

</> 
pub fn wifi_x_thin(attrs: List(Attribute(a))) -> Element(a)

wind_bold

</> 
pub fn wind_bold(attrs: List(Attribute(a))) -> Element(a)

wind_duotone

</> 
pub fn wind_duotone(attrs: List(Attribute(a))) -> Element(a)

wind_fill

</> 
pub fn wind_fill(attrs: List(Attribute(a))) -> Element(a)

wind_light

</> 
pub fn wind_light(attrs: List(Attribute(a))) -> Element(a)

wind_regular

</> 
pub fn wind_regular(attrs: List(Attribute(a))) -> Element(a)

wind_thin

</> 
pub fn wind_thin(attrs: List(Attribute(a))) -> Element(a)

windmill_bold

</> 
pub fn windmill_bold(attrs: List(Attribute(a))) -> Element(a)

windmill_duotone

</> 
pub fn windmill_duotone(attrs: List(Attribute(a))) -> Element(a)

windmill_fill

</> 
pub fn windmill_fill(attrs: List(Attribute(a))) -> Element(a)

windmill_light

</> 
pub fn windmill_light(attrs: List(Attribute(a))) -> Element(a)

windmill_regular

</> 
pub fn windmill_regular(attrs: List(Attribute(a))) -> Element(a)

windmill_thin

</> 
pub fn windmill_thin(attrs: List(Attribute(a))) -> Element(a)

windows_logo_bold

</> 
pub fn windows_logo_bold(attrs: List(Attribute(a))) -> Element(a)

windows_logo_duotone

</> 
pub fn windows_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

windows_logo_fill

</> 
pub fn windows_logo_fill(attrs: List(Attribute(a))) -> Element(a)

windows_logo_light

</> 
pub fn windows_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

windows_logo_regular

</> 
pub fn windows_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

windows_logo_thin

</> 
pub fn windows_logo_thin(attrs: List(Attribute(a))) -> Element(a)

wine_bold

</> 
pub fn wine_bold(attrs: List(Attribute(a))) -> Element(a)

wine_duotone

</> 
pub fn wine_duotone(attrs: List(Attribute(a))) -> Element(a)

wine_fill

</> 
pub fn wine_fill(attrs: List(Attribute(a))) -> Element(a)

wine_light

</> 
pub fn wine_light(attrs: List(Attribute(a))) -> Element(a)

wine_regular

</> 
pub fn wine_regular(attrs: List(Attribute(a))) -> Element(a)

wine_thin

</> 
pub fn wine_thin(attrs: List(Attribute(a))) -> Element(a)

wrench_bold

</> 
pub fn wrench_bold(attrs: List(Attribute(a))) -> Element(a)

wrench_duotone

</> 
pub fn wrench_duotone(attrs: List(Attribute(a))) -> Element(a)

wrench_fill

</> 
pub fn wrench_fill(attrs: List(Attribute(a))) -> Element(a)

wrench_light

</> 
pub fn wrench_light(attrs: List(Attribute(a))) -> Element(a)

wrench_regular

</> 
pub fn wrench_regular(attrs: List(Attribute(a))) -> Element(a)

wrench_thin

</> 
pub fn wrench_thin(attrs: List(Attribute(a))) -> Element(a)

x_bold

</> 
pub fn x_bold(attrs: List(Attribute(a))) -> Element(a)

x_circle_bold

</> 
pub fn x_circle_bold(attrs: List(Attribute(a))) -> Element(a)

x_circle_duotone

</> 
pub fn x_circle_duotone(attrs: List(Attribute(a))) -> Element(a)

x_circle_fill

</> 
pub fn x_circle_fill(attrs: List(Attribute(a))) -> Element(a)

x_circle_light

</> 
pub fn x_circle_light(attrs: List(Attribute(a))) -> Element(a)

x_circle_regular

</> 
pub fn x_circle_regular(attrs: List(Attribute(a))) -> Element(a)

x_circle_thin

</> 
pub fn x_circle_thin(attrs: List(Attribute(a))) -> Element(a)

x_duotone

</> 
pub fn x_duotone(attrs: List(Attribute(a))) -> Element(a)

x_fill

</> 
pub fn x_fill(attrs: List(Attribute(a))) -> Element(a)

x_light

</> 
pub fn x_light(attrs: List(Attribute(a))) -> Element(a)

x_logo_bold

</> 
pub fn x_logo_bold(attrs: List(Attribute(a))) -> Element(a)

x_logo_duotone

</> 
pub fn x_logo_duotone(attrs: List(Attribute(a))) -> Element(a)

x_logo_fill

</> 
pub fn x_logo_fill(attrs: List(Attribute(a))) -> Element(a)

x_logo_light

</> 
pub fn x_logo_light(attrs: List(Attribute(a))) -> Element(a)

x_logo_regular

</> 
pub fn x_logo_regular(attrs: List(Attribute(a))) -> Element(a)

x_logo_thin

</> 
pub fn x_logo_thin(attrs: List(Attribute(a))) -> Element(a)

x_regular

</> 
pub fn x_regular(attrs: List(Attribute(a))) -> Element(a)

x_square_bold

</> 
pub fn x_square_bold(attrs: List(Attribute(a))) -> Element(a)

x_square_duotone

</> 
pub fn x_square_duotone(attrs: List(Attribute(a))) -> Element(a)

x_square_fill

</> 
pub fn x_square_fill(attrs: List(Attribute(a))) -> Element(a)

x_square_light

</> 
pub fn x_square_light(attrs: List(Attribute(a))) -> Element(a)

x_square_regular

</> 
pub fn x_square_regular(attrs: List(Attribute(a))) -> Element(a)

x_square_thin

</> 
pub fn x_square_thin(attrs: List(Attribute(a))) -> Element(a)

x_thin

</> 
pub fn x_thin(attrs: List(Attribute(a))) -> Element(a)

yarn_bold

</> 
pub fn yarn_bold(attrs: List(Attribute(a))) -> Element(a)

yarn_duotone

</> 
pub fn yarn_duotone(attrs: List(Attribute(a))) -> Element(a)

yarn_fill

</> 
pub fn yarn_fill(attrs: List(Attribute(a))) -> Element(a)

yarn_light

</> 
pub fn yarn_light(attrs: List(Attribute(a))) -> Element(a)

yarn_regular

</> 
pub fn yarn_regular(attrs: List(Attribute(a))) -> Element(a)

yarn_thin

</> 
pub fn yarn_thin(attrs: List(Attribute(a))) -> Element(a)

yin_yang_bold

</> 
pub fn yin_yang_bold(attrs: List(Attribute(a))) -> Element(a)

yin_yang_duotone

</> 
pub fn yin_yang_duotone(attrs: List(Attribute(a))) -> Element(a)

yin_yang_fill

</> 
pub fn yin_yang_fill(attrs: List(Attribute(a))) -> Element(a)

yin_yang_light

</> 
pub fn yin_yang_light(attrs: List(Attribute(a))) -> Element(a)

yin_yang_regular

</> 
pub fn yin_yang_regular(attrs: List(Attribute(a))) -> Element(a)

yin_yang_thin

</> 
pub fn yin_yang_thin(attrs: List(Attribute(a))) -> Element(a)

youtube_logo_bold

</> 
pub fn youtube_logo_bold(attrs: List(Attribute(a))) -> Element(a)

youtube_logo_duotone

</> 
pub fn youtube_logo_duotone(
  attrs: List(Attribute(a)),
) -> Element(a)

youtube_logo_fill

</> 
pub fn youtube_logo_fill(attrs: List(Attribute(a))) -> Element(a)

youtube_logo_light

</> 
pub fn youtube_logo_light(
  attrs: List(Attribute(a)),
) -> Element(a)

youtube_logo_regular

</> 
pub fn youtube_logo_regular(
  attrs: List(Attribute(a)),
) -> Element(a)

youtube_logo_thin

</> 
pub fn youtube_logo_thin(attrs: List(Attribute(a))) -> Element(a)
✨ Search Document