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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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