pub fn a_arrow_down(attributes: List(Attribute(a))) -> Element(a)

pub fn a_arrow_up(attributes: List(Attribute(a))) -> Element(a)

pub fn a_large_small(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn accessibility(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn activity(attributes: List(Attribute(a))) -> Element(a)

pub fn air_vent(attributes: List(Attribute(a))) -> Element(a)

pub fn airplay(attributes: List(Attribute(a))) -> Element(a)

pub fn alarm_clock(attributes: List(Attribute(a))) -> Element(a)

pub fn alarm_clock_check(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn alarm_clock_minus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn alarm_clock_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn alarm_clock_plus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn alarm_smoke(attributes: List(Attribute(a))) -> Element(a)

pub fn album(attributes: List(Attribute(a))) -> Element(a)

pub fn align_center(attributes: List(Attribute(a))) -> Element(a)

pub fn align_center_horizontal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_center_vertical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_end_horizontal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_end_vertical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_horizontal_distribute_center(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_horizontal_distribute_end(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_horizontal_distribute_start(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_horizontal_justify_center(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_horizontal_justify_end(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_horizontal_justify_start(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_horizontal_space_around(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_horizontal_space_between(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_justify(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_left(attributes: List(Attribute(a))) -> Element(a)

pub fn align_right(attributes: List(Attribute(a))) -> Element(a)

pub fn align_start_horizontal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_start_vertical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_vertical_distribute_center(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_vertical_distribute_end(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_vertical_distribute_start(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_vertical_justify_center(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_vertical_justify_end(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_vertical_justify_start(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_vertical_space_around(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn align_vertical_space_between(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn ambulance(attributes: List(Attribute(a))) -> Element(a)

pub fn ampersand(attributes: List(Attribute(a))) -> Element(a)

pub fn ampersands(attributes: List(Attribute(a))) -> Element(a)

pub fn amphora(attributes: List(Attribute(a))) -> Element(a)

pub fn anchor(attributes: List(Attribute(a))) -> Element(a)

pub fn angry(attributes: List(Attribute(a))) -> Element(a)

pub fn annoyed(attributes: List(Attribute(a))) -> Element(a)

pub fn antenna(attributes: List(Attribute(a))) -> Element(a)

pub fn anvil(attributes: List(Attribute(a))) -> Element(a)

pub fn aperture(attributes: List(Attribute(a))) -> Element(a)

pub fn app_window(attributes: List(Attribute(a))) -> Element(a)

pub fn app_window_mac(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn apple(attributes: List(Attribute(a))) -> Element(a)

pub fn archive(attributes: List(Attribute(a))) -> Element(a)

pub fn archive_restore(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn archive_x(attributes: List(Attribute(a))) -> Element(a)

pub fn armchair(attributes: List(Attribute(a))) -> Element(a)

pub fn arrow_big_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_big_down_dash(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_big_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_big_left_dash(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_big_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_big_right_dash(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_big_up(attributes: List(Attribute(a))) -> Element(a)

pub fn arrow_big_up_dash(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down(attributes: List(Attribute(a))) -> Element(a)

pub fn arrow_down_0_1(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_1_0(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_a_z(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_from_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_narrow_wide(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_to_dot(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_to_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_up(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_wide_narrow(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_down_z_a(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_left(attributes: List(Attribute(a))) -> Element(a)

pub fn arrow_left_from_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_left_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_left_to_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_right(attributes: List(Attribute(a))) -> Element(a)

pub fn arrow_right_from_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_right_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_right_to_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_up(attributes: List(Attribute(a))) -> Element(a)

pub fn arrow_up_0_1(attributes: List(Attribute(a))) -> Element(a)

pub fn arrow_up_1_0(attributes: List(Attribute(a))) -> Element(a)

pub fn arrow_up_a_z(attributes: List(Attribute(a))) -> Element(a)

pub fn arrow_up_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_up_from_dot(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_up_from_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_up_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_up_narrow_wide(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_up_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_up_to_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_up_wide_narrow(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn arrow_up_z_a(attributes: List(Attribute(a))) -> Element(a)

pub fn arrows_up_from_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn asterisk(attributes: List(Attribute(a))) -> Element(a)

pub fn at_sign(attributes: List(Attribute(a))) -> Element(a)

pub fn atom(attributes: List(Attribute(a))) -> Element(a)

pub fn audio_lines(attributes: List(Attribute(a))) -> Element(a)

pub fn audio_waveform(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn award(attributes: List(Attribute(a))) -> Element(a)

pub fn axe(attributes: List(Attribute(a))) -> Element(a)

pub fn axis_3d(attributes: List(Attribute(a))) -> Element(a)

pub fn baby(attributes: List(Attribute(a))) -> Element(a)

pub fn backpack(attributes: List(Attribute(a))) -> Element(a)

pub fn badge(attributes: List(Attribute(a))) -> Element(a)

pub fn badge_alert(attributes: List(Attribute(a))) -> Element(a)

pub fn badge_cent(attributes: List(Attribute(a))) -> Element(a)

pub fn badge_check(attributes: List(Attribute(a))) -> Element(a)

pub fn badge_dollar_sign(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn badge_euro(attributes: List(Attribute(a))) -> Element(a)

pub fn badge_help(attributes: List(Attribute(a))) -> Element(a)

pub fn badge_indian_rupee(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn badge_info(attributes: List(Attribute(a))) -> Element(a)

pub fn badge_japanese_yen(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn badge_minus(attributes: List(Attribute(a))) -> Element(a)

pub fn badge_percent(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn badge_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn badge_pound_sterling(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn badge_russian_ruble(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn badge_swiss_franc(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn badge_x(attributes: List(Attribute(a))) -> Element(a)

pub fn baggage_claim(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn ban(attributes: List(Attribute(a))) -> Element(a)

pub fn banana(attributes: List(Attribute(a))) -> Element(a)

pub fn bandage(attributes: List(Attribute(a))) -> Element(a)

pub fn banknote(attributes: List(Attribute(a))) -> Element(a)

pub fn barcode(attributes: List(Attribute(a))) -> Element(a)

pub fn baseline(attributes: List(Attribute(a))) -> Element(a)

pub fn bath(attributes: List(Attribute(a))) -> Element(a)

pub fn battery(attributes: List(Attribute(a))) -> Element(a)

pub fn battery_charging(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn battery_full(attributes: List(Attribute(a))) -> Element(a)

pub fn battery_low(attributes: List(Attribute(a))) -> Element(a)

pub fn battery_medium(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn battery_warning(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn beaker(attributes: List(Attribute(a))) -> Element(a)

pub fn bean(attributes: List(Attribute(a))) -> Element(a)

pub fn bean_off(attributes: List(Attribute(a))) -> Element(a)

pub fn bed(attributes: List(Attribute(a))) -> Element(a)

pub fn bed_double(attributes: List(Attribute(a))) -> Element(a)

pub fn bed_single(attributes: List(Attribute(a))) -> Element(a)

pub fn beef(attributes: List(Attribute(a))) -> Element(a)

pub fn beer(attributes: List(Attribute(a))) -> Element(a)

pub fn beer_off(attributes: List(Attribute(a))) -> Element(a)

pub fn bell(attributes: List(Attribute(a))) -> Element(a)

pub fn bell_dot(attributes: List(Attribute(a))) -> Element(a)

pub fn bell_electric(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn bell_minus(attributes: List(Attribute(a))) -> Element(a)

pub fn bell_off(attributes: List(Attribute(a))) -> Element(a)

pub fn bell_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn bell_ring(attributes: List(Attribute(a))) -> Element(a)

pub fn between_horizontal_end(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn between_horizontal_start(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn between_vertical_end(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn between_vertical_start(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn biceps_flexed(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn bike(attributes: List(Attribute(a))) -> Element(a)

pub fn binary(attributes: List(Attribute(a))) -> Element(a)

pub fn binoculars(attributes: List(Attribute(a))) -> Element(a)

pub fn biohazard(attributes: List(Attribute(a))) -> Element(a)

pub fn bird(attributes: List(Attribute(a))) -> Element(a)

pub fn bitcoin(attributes: List(Attribute(a))) -> Element(a)

pub fn blend(attributes: List(Attribute(a))) -> Element(a)

pub fn blinds(attributes: List(Attribute(a))) -> Element(a)

pub fn blocks(attributes: List(Attribute(a))) -> Element(a)

pub fn bluetooth(attributes: List(Attribute(a))) -> Element(a)

pub fn bluetooth_connected(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn bluetooth_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn bluetooth_searching(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn bold(attributes: List(Attribute(a))) -> Element(a)

pub fn bolt(attributes: List(Attribute(a))) -> Element(a)

pub fn bomb(attributes: List(Attribute(a))) -> Element(a)

pub fn bone(attributes: List(Attribute(a))) -> Element(a)

pub fn book(attributes: List(Attribute(a))) -> Element(a)

pub fn book_a(attributes: List(Attribute(a))) -> Element(a)

pub fn book_audio(attributes: List(Attribute(a))) -> Element(a)

pub fn book_check(attributes: List(Attribute(a))) -> Element(a)

pub fn book_copy(attributes: List(Attribute(a))) -> Element(a)

pub fn book_dashed(attributes: List(Attribute(a))) -> Element(a)

pub fn book_down(attributes: List(Attribute(a))) -> Element(a)

pub fn book_headphones(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn book_heart(attributes: List(Attribute(a))) -> Element(a)

pub fn book_image(attributes: List(Attribute(a))) -> Element(a)

pub fn book_key(attributes: List(Attribute(a))) -> Element(a)

pub fn book_lock(attributes: List(Attribute(a))) -> Element(a)

pub fn book_marked(attributes: List(Attribute(a))) -> Element(a)

pub fn book_minus(attributes: List(Attribute(a))) -> Element(a)

pub fn book_open(attributes: List(Attribute(a))) -> Element(a)

pub fn book_open_check(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn book_open_text(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn book_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn book_text(attributes: List(Attribute(a))) -> Element(a)

pub fn book_type(attributes: List(Attribute(a))) -> Element(a)

pub fn book_up(attributes: List(Attribute(a))) -> Element(a)

pub fn book_up_2(attributes: List(Attribute(a))) -> Element(a)

pub fn book_user(attributes: List(Attribute(a))) -> Element(a)

pub fn book_x(attributes: List(Attribute(a))) -> Element(a)

pub fn bookmark(attributes: List(Attribute(a))) -> Element(a)

pub fn bookmark_check(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn bookmark_minus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn bookmark_plus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn bookmark_x(attributes: List(Attribute(a))) -> Element(a)

pub fn boom_box(attributes: List(Attribute(a))) -> Element(a)

pub fn bot(attributes: List(Attribute(a))) -> Element(a)

pub fn bot_message_square(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn bot_off(attributes: List(Attribute(a))) -> Element(a)

pub fn box(attributes: List(Attribute(a))) -> Element(a)

pub fn boxes(attributes: List(Attribute(a))) -> Element(a)

pub fn braces(attributes: List(Attribute(a))) -> Element(a)

pub fn brackets(attributes: List(Attribute(a))) -> Element(a)

pub fn brain(attributes: List(Attribute(a))) -> Element(a)

pub fn brain_circuit(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn brain_cog(attributes: List(Attribute(a))) -> Element(a)

pub fn brick_wall(attributes: List(Attribute(a))) -> Element(a)

pub fn briefcase(attributes: List(Attribute(a))) -> Element(a)

pub fn briefcase_business(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn briefcase_conveyor_belt(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn briefcase_medical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn bring_to_front(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn brush(attributes: List(Attribute(a))) -> Element(a)

pub fn bug(attributes: List(Attribute(a))) -> Element(a)

pub fn bug_off(attributes: List(Attribute(a))) -> Element(a)

pub fn bug_play(attributes: List(Attribute(a))) -> Element(a)

pub fn building(attributes: List(Attribute(a))) -> Element(a)

pub fn building_2(attributes: List(Attribute(a))) -> Element(a)

pub fn bus(attributes: List(Attribute(a))) -> Element(a)

pub fn bus_front(attributes: List(Attribute(a))) -> Element(a)

pub fn cable(attributes: List(Attribute(a))) -> Element(a)

pub fn cable_car(attributes: List(Attribute(a))) -> Element(a)

pub fn cake(attributes: List(Attribute(a))) -> Element(a)

pub fn cake_slice(attributes: List(Attribute(a))) -> Element(a)

pub fn calculator(attributes: List(Attribute(a))) -> Element(a)

pub fn calendar(attributes: List(Attribute(a))) -> Element(a)

pub fn calendar_1(attributes: List(Attribute(a))) -> Element(a)

pub fn calendar_arrow_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_arrow_up(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_check(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_check_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_clock(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_cog(attributes: List(Attribute(a))) -> Element(a)

pub fn calendar_days(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_fold(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_heart(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_minus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_minus_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_off(attributes: List(Attribute(a))) -> Element(a)

pub fn calendar_plus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_plus_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_range(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_search(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn calendar_x(attributes: List(Attribute(a))) -> Element(a)

pub fn calendar_x_2(attributes: List(Attribute(a))) -> Element(a)

pub fn camera(attributes: List(Attribute(a))) -> Element(a)

pub fn camera_off(attributes: List(Attribute(a))) -> Element(a)

pub fn candy(attributes: List(Attribute(a))) -> Element(a)

pub fn candy_cane(attributes: List(Attribute(a))) -> Element(a)

pub fn candy_off(attributes: List(Attribute(a))) -> Element(a)

pub fn cannabis(attributes: List(Attribute(a))) -> Element(a)

pub fn captions(attributes: List(Attribute(a))) -> Element(a)

pub fn captions_off(attributes: List(Attribute(a))) -> Element(a)

pub fn car(attributes: List(Attribute(a))) -> Element(a)

pub fn car_front(attributes: List(Attribute(a))) -> Element(a)

pub fn car_taxi_front(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn caravan(attributes: List(Attribute(a))) -> Element(a)

pub fn carrot(attributes: List(Attribute(a))) -> Element(a)

pub fn case_lower(attributes: List(Attribute(a))) -> Element(a)

pub fn case_sensitive(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn case_upper(attributes: List(Attribute(a))) -> Element(a)

pub fn cassette_tape(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn cast(attributes: List(Attribute(a))) -> Element(a)

pub fn castle(attributes: List(Attribute(a))) -> Element(a)

pub fn cat(attributes: List(Attribute(a))) -> Element(a)

pub fn cctv(attributes: List(Attribute(a))) -> Element(a)

pub fn chart_area(attributes: List(Attribute(a))) -> Element(a)

pub fn chart_bar(attributes: List(Attribute(a))) -> Element(a)

pub fn chart_bar_big(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_bar_decreasing(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_bar_increasing(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_bar_stacked(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_candlestick(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_column(attributes: List(Attribute(a))) -> Element(a)

pub fn chart_column_big(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_column_decreasing(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_column_increasing(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_column_stacked(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_gantt(attributes: List(Attribute(a))) -> Element(a)

pub fn chart_line(attributes: List(Attribute(a))) -> Element(a)

pub fn chart_network(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_no_axes_column(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_no_axes_column_decreasing(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_no_axes_column_increasing(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_no_axes_combined(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_no_axes_gantt(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_pie(attributes: List(Attribute(a))) -> Element(a)

pub fn chart_scatter(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chart_spline(attributes: List(Attribute(a))) -> Element(a)

pub fn check(attributes: List(Attribute(a))) -> Element(a)

pub fn check_check(attributes: List(Attribute(a))) -> Element(a)

pub fn chef_hat(attributes: List(Attribute(a))) -> Element(a)

pub fn cherry(attributes: List(Attribute(a))) -> Element(a)

pub fn chevron_down(attributes: List(Attribute(a))) -> Element(a)

pub fn chevron_first(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chevron_last(attributes: List(Attribute(a))) -> Element(a)

pub fn chevron_left(attributes: List(Attribute(a))) -> Element(a)

pub fn chevron_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chevron_up(attributes: List(Attribute(a))) -> Element(a)

pub fn chevrons_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chevrons_down_up(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chevrons_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chevrons_left_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chevrons_left_right_ellipsis(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chevrons_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chevrons_right_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chevrons_up(attributes: List(Attribute(a))) -> Element(a)

pub fn chevrons_up_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn chrome(attributes: List(Attribute(a))) -> Element(a)

pub fn church(attributes: List(Attribute(a))) -> Element(a)

pub fn cigarette(attributes: List(Attribute(a))) -> Element(a)

pub fn cigarette_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_alert(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_arrow_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_arrow_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_arrow_out_down_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_arrow_out_down_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_arrow_out_up_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_arrow_out_up_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_arrow_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_arrow_up(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_check(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_check_big(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_chevron_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_chevron_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_chevron_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_chevron_up(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_dashed(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_divide(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_dollar_sign(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_dot(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_dot_dashed(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_ellipsis(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_equal(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_fading_arrow_up(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_fading_plus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_gauge(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_help(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_minus(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_off(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_parking(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_parking_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_pause(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_percent(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_play(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_power(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_slash(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_slash_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_stop(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_user(attributes: List(Attribute(a))) -> Element(a)

pub fn circle_user_round(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn circle_x(attributes: List(Attribute(a))) -> Element(a)

pub fn circuit_board(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn citrus(attributes: List(Attribute(a))) -> Element(a)

pub fn clapperboard(attributes: List(Attribute(a))) -> Element(a)

pub fn clipboard(attributes: List(Attribute(a))) -> Element(a)

pub fn clipboard_check(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn clipboard_copy(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn clipboard_list(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn clipboard_minus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn clipboard_paste(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn clipboard_pen(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn clipboard_pen_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn clipboard_plus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn clipboard_type(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn clipboard_x(attributes: List(Attribute(a))) -> Element(a)

pub fn clock(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_1(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_10(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_11(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_12(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_2(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_3(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_4(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_5(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_6(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_7(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_8(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_9(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_alert(attributes: List(Attribute(a))) -> Element(a)

pub fn clock_arrow_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn clock_arrow_up(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn cloud(attributes: List(Attribute(a))) -> Element(a)

pub fn cloud_cog(attributes: List(Attribute(a))) -> Element(a)

pub fn cloud_download(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn cloud_drizzle(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn cloud_fog(attributes: List(Attribute(a))) -> Element(a)

pub fn cloud_hail(attributes: List(Attribute(a))) -> Element(a)

pub fn cloud_lightning(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn cloud_moon(attributes: List(Attribute(a))) -> Element(a)

pub fn cloud_moon_rain(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn cloud_off(attributes: List(Attribute(a))) -> Element(a)

pub fn cloud_rain(attributes: List(Attribute(a))) -> Element(a)

pub fn cloud_rain_wind(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn cloud_snow(attributes: List(Attribute(a))) -> Element(a)

pub fn cloud_sun(attributes: List(Attribute(a))) -> Element(a)

pub fn cloud_sun_rain(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn cloud_upload(attributes: List(Attribute(a))) -> Element(a)

pub fn cloudy(attributes: List(Attribute(a))) -> Element(a)

pub fn clover(attributes: List(Attribute(a))) -> Element(a)

pub fn club(attributes: List(Attribute(a))) -> Element(a)

pub fn code(attributes: List(Attribute(a))) -> Element(a)

pub fn code_xml(attributes: List(Attribute(a))) -> Element(a)

pub fn codepen(attributes: List(Attribute(a))) -> Element(a)

pub fn codesandbox(attributes: List(Attribute(a))) -> Element(a)

pub fn coffee(attributes: List(Attribute(a))) -> Element(a)

pub fn cog(attributes: List(Attribute(a))) -> Element(a)

pub fn coins(attributes: List(Attribute(a))) -> Element(a)

pub fn columns_2(attributes: List(Attribute(a))) -> Element(a)

pub fn columns_3(attributes: List(Attribute(a))) -> Element(a)

pub fn columns_4(attributes: List(Attribute(a))) -> Element(a)

pub fn combine(attributes: List(Attribute(a))) -> Element(a)

pub fn command(attributes: List(Attribute(a))) -> Element(a)

pub fn compass(attributes: List(Attribute(a))) -> Element(a)

pub fn component(attributes: List(Attribute(a))) -> Element(a)

pub fn computer(attributes: List(Attribute(a))) -> Element(a)

pub fn concierge_bell(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn cone(attributes: List(Attribute(a))) -> Element(a)

pub fn construction(attributes: List(Attribute(a))) -> Element(a)

pub fn contact(attributes: List(Attribute(a))) -> Element(a)

pub fn contact_round(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn container(attributes: List(Attribute(a))) -> Element(a)

pub fn contrast(attributes: List(Attribute(a))) -> Element(a)

pub fn cookie(attributes: List(Attribute(a))) -> Element(a)

pub fn cooking_pot(attributes: List(Attribute(a))) -> Element(a)

pub fn copy(attributes: List(Attribute(a))) -> Element(a)

pub fn copy_check(attributes: List(Attribute(a))) -> Element(a)

pub fn copy_minus(attributes: List(Attribute(a))) -> Element(a)

pub fn copy_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn copy_slash(attributes: List(Attribute(a))) -> Element(a)

pub fn copy_x(attributes: List(Attribute(a))) -> Element(a)

pub fn copyleft(attributes: List(Attribute(a))) -> Element(a)

pub fn copyright(attributes: List(Attribute(a))) -> Element(a)

pub fn corner_down_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn corner_down_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn corner_left_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn corner_left_up(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn corner_right_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn corner_right_up(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn corner_up_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn corner_up_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn cpu(attributes: List(Attribute(a))) -> Element(a)

pub fn creative_commons(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn credit_card(attributes: List(Attribute(a))) -> Element(a)

pub fn croissant(attributes: List(Attribute(a))) -> Element(a)

pub fn crop(attributes: List(Attribute(a))) -> Element(a)

pub fn cross(attributes: List(Attribute(a))) -> Element(a)

pub fn crosshair(attributes: List(Attribute(a))) -> Element(a)

pub fn crown(attributes: List(Attribute(a))) -> Element(a)

pub fn cuboid(attributes: List(Attribute(a))) -> Element(a)

pub fn cup_soda(attributes: List(Attribute(a))) -> Element(a)

pub fn currency(attributes: List(Attribute(a))) -> Element(a)

pub fn cylinder(attributes: List(Attribute(a))) -> Element(a)

pub fn dam(attributes: List(Attribute(a))) -> Element(a)

pub fn database(attributes: List(Attribute(a))) -> Element(a)

pub fn database_backup(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn database_zap(attributes: List(Attribute(a))) -> Element(a)

pub fn delete(attributes: List(Attribute(a))) -> Element(a)

pub fn dessert(attributes: List(Attribute(a))) -> Element(a)

pub fn diameter(attributes: List(Attribute(a))) -> Element(a)

pub fn diamond(attributes: List(Attribute(a))) -> Element(a)

pub fn diamond_minus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn diamond_percent(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn diamond_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn dice_1(attributes: List(Attribute(a))) -> Element(a)

pub fn dice_2(attributes: List(Attribute(a))) -> Element(a)

pub fn dice_3(attributes: List(Attribute(a))) -> Element(a)

pub fn dice_4(attributes: List(Attribute(a))) -> Element(a)

pub fn dice_5(attributes: List(Attribute(a))) -> Element(a)

pub fn dice_6(attributes: List(Attribute(a))) -> Element(a)

pub fn dices(attributes: List(Attribute(a))) -> Element(a)

pub fn diff(attributes: List(Attribute(a))) -> Element(a)

pub fn disc(attributes: List(Attribute(a))) -> Element(a)

pub fn disc_2(attributes: List(Attribute(a))) -> Element(a)

pub fn disc_3(attributes: List(Attribute(a))) -> Element(a)

pub fn disc_album(attributes: List(Attribute(a))) -> Element(a)

pub fn divide(attributes: List(Attribute(a))) -> Element(a)

pub fn dna(attributes: List(Attribute(a))) -> Element(a)

pub fn dna_off(attributes: List(Attribute(a))) -> Element(a)

pub fn dock(attributes: List(Attribute(a))) -> Element(a)

pub fn dog(attributes: List(Attribute(a))) -> Element(a)

pub fn dollar_sign(attributes: List(Attribute(a))) -> Element(a)

pub fn donut(attributes: List(Attribute(a))) -> Element(a)

pub fn door_closed(attributes: List(Attribute(a))) -> Element(a)

pub fn door_open(attributes: List(Attribute(a))) -> Element(a)

pub fn dot(attributes: List(Attribute(a))) -> Element(a)

pub fn download(attributes: List(Attribute(a))) -> Element(a)

pub fn drafting_compass(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn drama(attributes: List(Attribute(a))) -> Element(a)

pub fn dribbble(attributes: List(Attribute(a))) -> Element(a)

pub fn drill(attributes: List(Attribute(a))) -> Element(a)

pub fn droplet(attributes: List(Attribute(a))) -> Element(a)

pub fn droplets(attributes: List(Attribute(a))) -> Element(a)

pub fn drum(attributes: List(Attribute(a))) -> Element(a)

pub fn drumstick(attributes: List(Attribute(a))) -> Element(a)

pub fn dumbbell(attributes: List(Attribute(a))) -> Element(a)

pub fn ear(attributes: List(Attribute(a))) -> Element(a)

pub fn ear_off(attributes: List(Attribute(a))) -> Element(a)

pub fn earth(attributes: List(Attribute(a))) -> Element(a)

pub fn earth_lock(attributes: List(Attribute(a))) -> Element(a)

pub fn eclipse(attributes: List(Attribute(a))) -> Element(a)

pub fn egg(attributes: List(Attribute(a))) -> Element(a)

pub fn egg_fried(attributes: List(Attribute(a))) -> Element(a)

pub fn egg_off(attributes: List(Attribute(a))) -> Element(a)

pub fn ellipsis(attributes: List(Attribute(a))) -> Element(a)

pub fn ellipsis_vertical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn equal(attributes: List(Attribute(a))) -> Element(a)

pub fn equal_not(attributes: List(Attribute(a))) -> Element(a)

pub fn eraser(attributes: List(Attribute(a))) -> Element(a)

pub fn ethernet_port(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn euro(attributes: List(Attribute(a))) -> Element(a)

pub fn expand(attributes: List(Attribute(a))) -> Element(a)

pub fn external_link(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn eye(attributes: List(Attribute(a))) -> Element(a)

pub fn eye_closed(attributes: List(Attribute(a))) -> Element(a)

pub fn eye_off(attributes: List(Attribute(a))) -> Element(a)

pub fn facebook(attributes: List(Attribute(a))) -> Element(a)

pub fn factory(attributes: List(Attribute(a))) -> Element(a)

pub fn fan(attributes: List(Attribute(a))) -> Element(a)

pub fn fast_forward(attributes: List(Attribute(a))) -> Element(a)

pub fn feather(attributes: List(Attribute(a))) -> Element(a)

pub fn fence(attributes: List(Attribute(a))) -> Element(a)

pub fn ferris_wheel(attributes: List(Attribute(a))) -> Element(a)

pub fn figma(attributes: List(Attribute(a))) -> Element(a)

pub fn file(attributes: List(Attribute(a))) -> Element(a)

pub fn file_archive(attributes: List(Attribute(a))) -> Element(a)

pub fn file_audio(attributes: List(Attribute(a))) -> Element(a)

pub fn file_audio_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_axis_3d(attributes: List(Attribute(a))) -> Element(a)

pub fn file_badge(attributes: List(Attribute(a))) -> Element(a)

pub fn file_badge_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_box(attributes: List(Attribute(a))) -> Element(a)

pub fn file_chart_column(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn file_chart_column_increasing(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn file_chart_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn file_chart_pie(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn file_check(attributes: List(Attribute(a))) -> Element(a)

pub fn file_check_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_clock(attributes: List(Attribute(a))) -> Element(a)

pub fn file_code(attributes: List(Attribute(a))) -> Element(a)

pub fn file_code_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_cog(attributes: List(Attribute(a))) -> Element(a)

pub fn file_diff(attributes: List(Attribute(a))) -> Element(a)

pub fn file_digit(attributes: List(Attribute(a))) -> Element(a)

pub fn file_down(attributes: List(Attribute(a))) -> Element(a)

pub fn file_heart(attributes: List(Attribute(a))) -> Element(a)

pub fn file_image(attributes: List(Attribute(a))) -> Element(a)

pub fn file_input(attributes: List(Attribute(a))) -> Element(a)

pub fn file_json(attributes: List(Attribute(a))) -> Element(a)

pub fn file_json_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_key(attributes: List(Attribute(a))) -> Element(a)

pub fn file_key_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_lock(attributes: List(Attribute(a))) -> Element(a)

pub fn file_lock_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_minus(attributes: List(Attribute(a))) -> Element(a)

pub fn file_minus_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_music(attributes: List(Attribute(a))) -> Element(a)

pub fn file_output(attributes: List(Attribute(a))) -> Element(a)

pub fn file_pen(attributes: List(Attribute(a))) -> Element(a)

pub fn file_pen_line(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn file_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn file_plus_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_question(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn file_scan(attributes: List(Attribute(a))) -> Element(a)

pub fn file_search(attributes: List(Attribute(a))) -> Element(a)

pub fn file_search_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn file_sliders(attributes: List(Attribute(a))) -> Element(a)

pub fn file_spreadsheet(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn file_stack(attributes: List(Attribute(a))) -> Element(a)

pub fn file_symlink(attributes: List(Attribute(a))) -> Element(a)

pub fn file_terminal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn file_text(attributes: List(Attribute(a))) -> Element(a)

pub fn file_type(attributes: List(Attribute(a))) -> Element(a)

pub fn file_type_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_up(attributes: List(Attribute(a))) -> Element(a)

pub fn file_user(attributes: List(Attribute(a))) -> Element(a)

pub fn file_video(attributes: List(Attribute(a))) -> Element(a)

pub fn file_video_2(attributes: List(Attribute(a))) -> Element(a)

pub fn file_volume(attributes: List(Attribute(a))) -> Element(a)

pub fn file_volume_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn file_warning(attributes: List(Attribute(a))) -> Element(a)

pub fn file_x(attributes: List(Attribute(a))) -> Element(a)

pub fn file_x_2(attributes: List(Attribute(a))) -> Element(a)

pub fn files(attributes: List(Attribute(a))) -> Element(a)

pub fn film(attributes: List(Attribute(a))) -> Element(a)

pub fn filter(attributes: List(Attribute(a))) -> Element(a)

pub fn filter_x(attributes: List(Attribute(a))) -> Element(a)

pub fn fingerprint(attributes: List(Attribute(a))) -> Element(a)

pub fn fire_extinguisher(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn fish(attributes: List(Attribute(a))) -> Element(a)

pub fn fish_off(attributes: List(Attribute(a))) -> Element(a)

pub fn fish_symbol(attributes: List(Attribute(a))) -> Element(a)

pub fn flag(attributes: List(Attribute(a))) -> Element(a)

pub fn flag_off(attributes: List(Attribute(a))) -> Element(a)

pub fn flag_triangle_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn flag_triangle_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn flame(attributes: List(Attribute(a))) -> Element(a)

pub fn flame_kindling(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn flashlight(attributes: List(Attribute(a))) -> Element(a)

pub fn flashlight_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn flask_conical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn flask_conical_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn flask_round(attributes: List(Attribute(a))) -> Element(a)

pub fn flip_horizontal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn flip_horizontal_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn flip_vertical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn flip_vertical_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn flower(attributes: List(Attribute(a))) -> Element(a)

pub fn flower_2(attributes: List(Attribute(a))) -> Element(a)

pub fn focus(attributes: List(Attribute(a))) -> Element(a)

pub fn fold_horizontal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn fold_vertical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn folder(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_archive(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn folder_check(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_clock(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_closed(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn folder_code(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_cog(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_dot(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_down(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_git(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_git_2(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_heart(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_input(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_kanban(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn folder_key(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_lock(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_minus(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_open(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_open_dot(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn folder_output(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn folder_pen(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_root(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_search(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn folder_search_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn folder_symlink(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn folder_sync(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_tree(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_up(attributes: List(Attribute(a))) -> Element(a)

pub fn folder_x(attributes: List(Attribute(a))) -> Element(a)

pub fn folders(attributes: List(Attribute(a))) -> Element(a)

pub fn footprints(attributes: List(Attribute(a))) -> Element(a)

pub fn forklift(attributes: List(Attribute(a))) -> Element(a)

pub fn forward(attributes: List(Attribute(a))) -> Element(a)

pub fn frame(attributes: List(Attribute(a))) -> Element(a)

pub fn framer(attributes: List(Attribute(a))) -> Element(a)

pub fn frown(attributes: List(Attribute(a))) -> Element(a)

pub fn fuel(attributes: List(Attribute(a))) -> Element(a)

pub fn fullscreen(attributes: List(Attribute(a))) -> Element(a)

pub fn gallery_horizontal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn gallery_horizontal_end(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn gallery_thumbnails(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn gallery_vertical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn gallery_vertical_end(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn gamepad(attributes: List(Attribute(a))) -> Element(a)

pub fn gamepad_2(attributes: List(Attribute(a))) -> Element(a)

pub fn gauge(attributes: List(Attribute(a))) -> Element(a)

pub fn gavel(attributes: List(Attribute(a))) -> Element(a)

pub fn gem(attributes: List(Attribute(a))) -> Element(a)

pub fn ghost(attributes: List(Attribute(a))) -> Element(a)

pub fn gift(attributes: List(Attribute(a))) -> Element(a)

pub fn git_branch(attributes: List(Attribute(a))) -> Element(a)

pub fn git_branch_plus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn git_commit_horizontal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn git_commit_vertical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn git_compare(attributes: List(Attribute(a))) -> Element(a)

pub fn git_compare_arrows(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn git_fork(attributes: List(Attribute(a))) -> Element(a)

pub fn git_graph(attributes: List(Attribute(a))) -> Element(a)

pub fn git_merge(attributes: List(Attribute(a))) -> Element(a)

pub fn git_pull_request(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn git_pull_request_arrow(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn git_pull_request_closed(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn git_pull_request_create(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn git_pull_request_create_arrow(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn git_pull_request_draft(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn github(attributes: List(Attribute(a))) -> Element(a)

pub fn gitlab(attributes: List(Attribute(a))) -> Element(a)

pub fn glass_water(attributes: List(Attribute(a))) -> Element(a)

pub fn glasses(attributes: List(Attribute(a))) -> Element(a)

pub fn globe(attributes: List(Attribute(a))) -> Element(a)

pub fn globe_lock(attributes: List(Attribute(a))) -> Element(a)

pub fn goal(attributes: List(Attribute(a))) -> Element(a)

pub fn grab(attributes: List(Attribute(a))) -> Element(a)

pub fn graduation_cap(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn grape(attributes: List(Attribute(a))) -> Element(a)

pub fn grid_2x2(attributes: List(Attribute(a))) -> Element(a)

pub fn grid_2x2_check(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn grid_2x2_plus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn grid_2x2_x(attributes: List(Attribute(a))) -> Element(a)

pub fn grid_3x3(attributes: List(Attribute(a))) -> Element(a)

pub fn grip(attributes: List(Attribute(a))) -> Element(a)

pub fn grip_horizontal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn grip_vertical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn group(attributes: List(Attribute(a))) -> Element(a)

pub fn guitar(attributes: List(Attribute(a))) -> Element(a)

pub fn ham(attributes: List(Attribute(a))) -> Element(a)

pub fn hammer(attributes: List(Attribute(a))) -> Element(a)

pub fn hand(attributes: List(Attribute(a))) -> Element(a)

pub fn hand_coins(attributes: List(Attribute(a))) -> Element(a)

pub fn hand_heart(attributes: List(Attribute(a))) -> Element(a)

pub fn hand_helping(attributes: List(Attribute(a))) -> Element(a)

pub fn hand_metal(attributes: List(Attribute(a))) -> Element(a)

pub fn hand_platter(attributes: List(Attribute(a))) -> Element(a)

pub fn handshake(attributes: List(Attribute(a))) -> Element(a)

pub fn hard_drive(attributes: List(Attribute(a))) -> Element(a)

pub fn hard_drive_download(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn hard_drive_upload(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn hard_hat(attributes: List(Attribute(a))) -> Element(a)

pub fn hash(attributes: List(Attribute(a))) -> Element(a)

pub fn haze(attributes: List(Attribute(a))) -> Element(a)

pub fn hdmi_port(attributes: List(Attribute(a))) -> Element(a)

pub fn heading(attributes: List(Attribute(a))) -> Element(a)

pub fn heading_1(attributes: List(Attribute(a))) -> Element(a)

pub fn heading_2(attributes: List(Attribute(a))) -> Element(a)

pub fn heading_3(attributes: List(Attribute(a))) -> Element(a)

pub fn heading_4(attributes: List(Attribute(a))) -> Element(a)

pub fn heading_5(attributes: List(Attribute(a))) -> Element(a)

pub fn heading_6(attributes: List(Attribute(a))) -> Element(a)

pub fn headphone_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn headphones(attributes: List(Attribute(a))) -> Element(a)

pub fn headset(attributes: List(Attribute(a))) -> Element(a)

pub fn heart(attributes: List(Attribute(a))) -> Element(a)

pub fn heart_crack(attributes: List(Attribute(a))) -> Element(a)

pub fn heart_handshake(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn heart_off(attributes: List(Attribute(a))) -> Element(a)

pub fn heart_pulse(attributes: List(Attribute(a))) -> Element(a)

pub fn heater(attributes: List(Attribute(a))) -> Element(a)

pub fn hexagon(attributes: List(Attribute(a))) -> Element(a)

pub fn highlighter(attributes: List(Attribute(a))) -> Element(a)

pub fn history(attributes: List(Attribute(a))) -> Element(a)

pub fn hop(attributes: List(Attribute(a))) -> Element(a)

pub fn hop_off(attributes: List(Attribute(a))) -> Element(a)

pub fn hospital(attributes: List(Attribute(a))) -> Element(a)

pub fn hotel(attributes: List(Attribute(a))) -> Element(a)

pub fn hourglass(attributes: List(Attribute(a))) -> Element(a)

pub fn house(attributes: List(Attribute(a))) -> Element(a)

pub fn house_plug(attributes: List(Attribute(a))) -> Element(a)

pub fn house_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn ice_cream_bowl(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn ice_cream_cone(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn id_card(attributes: List(Attribute(a))) -> Element(a)

pub fn image(attributes: List(Attribute(a))) -> Element(a)

pub fn image_down(attributes: List(Attribute(a))) -> Element(a)

pub fn image_minus(attributes: List(Attribute(a))) -> Element(a)

pub fn image_off(attributes: List(Attribute(a))) -> Element(a)

pub fn image_play(attributes: List(Attribute(a))) -> Element(a)

pub fn image_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn image_up(attributes: List(Attribute(a))) -> Element(a)

pub fn images(attributes: List(Attribute(a))) -> Element(a)

pub fn import_(attributes: List(Attribute(a))) -> Element(a)

pub fn inbox(attributes: List(Attribute(a))) -> Element(a)

pub fn indent_decrease(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn indent_increase(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn indian_rupee(attributes: List(Attribute(a))) -> Element(a)

pub fn infinity(attributes: List(Attribute(a))) -> Element(a)

pub fn info(attributes: List(Attribute(a))) -> Element(a)

pub fn inspection_panel(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn instagram(attributes: List(Attribute(a))) -> Element(a)

pub fn italic(attributes: List(Attribute(a))) -> Element(a)

pub fn iteration_ccw(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn iteration_cw(attributes: List(Attribute(a))) -> Element(a)

pub fn japanese_yen(attributes: List(Attribute(a))) -> Element(a)

pub fn joystick(attributes: List(Attribute(a))) -> Element(a)

pub fn kanban(attributes: List(Attribute(a))) -> Element(a)

pub fn key(attributes: List(Attribute(a))) -> Element(a)

pub fn key_round(attributes: List(Attribute(a))) -> Element(a)

pub fn key_square(attributes: List(Attribute(a))) -> Element(a)

pub fn keyboard(attributes: List(Attribute(a))) -> Element(a)

pub fn keyboard_music(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn keyboard_off(attributes: List(Attribute(a))) -> Element(a)

pub fn lamp(attributes: List(Attribute(a))) -> Element(a)

pub fn lamp_ceiling(attributes: List(Attribute(a))) -> Element(a)

pub fn lamp_desk(attributes: List(Attribute(a))) -> Element(a)

pub fn lamp_floor(attributes: List(Attribute(a))) -> Element(a)

pub fn lamp_wall_down(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn lamp_wall_up(attributes: List(Attribute(a))) -> Element(a)

pub fn land_plot(attributes: List(Attribute(a))) -> Element(a)

pub fn landmark(attributes: List(Attribute(a))) -> Element(a)

pub fn languages(attributes: List(Attribute(a))) -> Element(a)

pub fn laptop(attributes: List(Attribute(a))) -> Element(a)

pub fn laptop_minimal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn lasso(attributes: List(Attribute(a))) -> Element(a)

pub fn lasso_select(attributes: List(Attribute(a))) -> Element(a)

pub fn laugh(attributes: List(Attribute(a))) -> Element(a)

pub fn layers(attributes: List(Attribute(a))) -> Element(a)

pub fn layers_2(attributes: List(Attribute(a))) -> Element(a)

pub fn layers_3(attributes: List(Attribute(a))) -> Element(a)

pub fn layout_dashboard(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn layout_grid(attributes: List(Attribute(a))) -> Element(a)

pub fn layout_list(attributes: List(Attribute(a))) -> Element(a)

pub fn layout_panel_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn layout_panel_top(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn layout_template(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn leaf(attributes: List(Attribute(a))) -> Element(a)

pub fn leafy_green(attributes: List(Attribute(a))) -> Element(a)

pub fn lectern(attributes: List(Attribute(a))) -> Element(a)

pub fn letter_text(attributes: List(Attribute(a))) -> Element(a)

pub fn library(attributes: List(Attribute(a))) -> Element(a)

pub fn library_big(attributes: List(Attribute(a))) -> Element(a)

pub fn life_buoy(attributes: List(Attribute(a))) -> Element(a)

pub fn ligature(attributes: List(Attribute(a))) -> Element(a)

pub fn lightbulb(attributes: List(Attribute(a))) -> Element(a)

pub fn lightbulb_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn link(attributes: List(Attribute(a))) -> Element(a)

pub fn link_2(attributes: List(Attribute(a))) -> Element(a)

pub fn link_2_off(attributes: List(Attribute(a))) -> Element(a)

pub fn linkedin(attributes: List(Attribute(a))) -> Element(a)

pub fn list(attributes: List(Attribute(a))) -> Element(a)

pub fn list_check(attributes: List(Attribute(a))) -> Element(a)

pub fn list_checks(attributes: List(Attribute(a))) -> Element(a)

pub fn list_collapse(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn list_end(attributes: List(Attribute(a))) -> Element(a)

pub fn list_filter(attributes: List(Attribute(a))) -> Element(a)

pub fn list_minus(attributes: List(Attribute(a))) -> Element(a)

pub fn list_music(attributes: List(Attribute(a))) -> Element(a)

pub fn list_ordered(attributes: List(Attribute(a))) -> Element(a)

pub fn list_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn list_restart(attributes: List(Attribute(a))) -> Element(a)

pub fn list_start(attributes: List(Attribute(a))) -> Element(a)

pub fn list_todo(attributes: List(Attribute(a))) -> Element(a)

pub fn list_tree(attributes: List(Attribute(a))) -> Element(a)

pub fn list_video(attributes: List(Attribute(a))) -> Element(a)

pub fn list_x(attributes: List(Attribute(a))) -> Element(a)

pub fn loader(attributes: List(Attribute(a))) -> Element(a)

pub fn loader_circle(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn loader_pinwheel(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn locate(attributes: List(Attribute(a))) -> Element(a)

pub fn locate_fixed(attributes: List(Attribute(a))) -> Element(a)

pub fn locate_off(attributes: List(Attribute(a))) -> Element(a)

pub fn lock(attributes: List(Attribute(a))) -> Element(a)

pub fn lock_keyhole(attributes: List(Attribute(a))) -> Element(a)

pub fn lock_keyhole_open(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn lock_open(attributes: List(Attribute(a))) -> Element(a)

pub fn log_in(attributes: List(Attribute(a))) -> Element(a)

pub fn log_out(attributes: List(Attribute(a))) -> Element(a)

pub fn logs(attributes: List(Attribute(a))) -> Element(a)

pub fn lollipop(attributes: List(Attribute(a))) -> Element(a)

pub fn luggage(attributes: List(Attribute(a))) -> Element(a)

pub fn magnet(attributes: List(Attribute(a))) -> Element(a)

pub fn mail(attributes: List(Attribute(a))) -> Element(a)

pub fn mail_check(attributes: List(Attribute(a))) -> Element(a)

pub fn mail_minus(attributes: List(Attribute(a))) -> Element(a)

pub fn mail_open(attributes: List(Attribute(a))) -> Element(a)

pub fn mail_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn mail_question(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn mail_search(attributes: List(Attribute(a))) -> Element(a)

pub fn mail_warning(attributes: List(Attribute(a))) -> Element(a)

pub fn mail_x(attributes: List(Attribute(a))) -> Element(a)

pub fn mailbox(attributes: List(Attribute(a))) -> Element(a)

pub fn mails(attributes: List(Attribute(a))) -> Element(a)

pub fn map(attributes: List(Attribute(a))) -> Element(a)

pub fn map_pin(attributes: List(Attribute(a))) -> Element(a)

pub fn map_pin_check(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn map_pin_check_inside(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn map_pin_house(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn map_pin_minus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn map_pin_minus_inside(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn map_pin_off(attributes: List(Attribute(a))) -> Element(a)

pub fn map_pin_plus(attributes: List(Attribute(a))) -> Element(a)

pub fn map_pin_plus_inside(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn map_pin_x(attributes: List(Attribute(a))) -> Element(a)

pub fn map_pin_x_inside(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn map_pinned(attributes: List(Attribute(a))) -> Element(a)

pub fn martini(attributes: List(Attribute(a))) -> Element(a)

pub fn maximize(attributes: List(Attribute(a))) -> Element(a)

pub fn maximize_2(attributes: List(Attribute(a))) -> Element(a)

pub fn medal(attributes: List(Attribute(a))) -> Element(a)

pub fn megaphone(attributes: List(Attribute(a))) -> Element(a)

pub fn megaphone_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn meh(attributes: List(Attribute(a))) -> Element(a)

pub fn memory_stick(attributes: List(Attribute(a))) -> Element(a)

pub fn menu(attributes: List(Attribute(a))) -> Element(a)

pub fn merge(attributes: List(Attribute(a))) -> Element(a)

pub fn message_circle(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_circle_code(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_circle_dashed(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_circle_heart(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_circle_more(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_circle_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_circle_plus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_circle_question(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_circle_reply(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_circle_warning(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_circle_x(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_code(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_dashed(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_diff(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_dot(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_heart(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_lock(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_more(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_plus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_quote(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_reply(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_share(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_text(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_warning(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn message_square_x(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn messages_square(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn mic(attributes: List(Attribute(a))) -> Element(a)

pub fn mic_off(attributes: List(Attribute(a))) -> Element(a)

pub fn mic_vocal(attributes: List(Attribute(a))) -> Element(a)

pub fn microchip(attributes: List(Attribute(a))) -> Element(a)

pub fn microscope(attributes: List(Attribute(a))) -> Element(a)

pub fn microwave(attributes: List(Attribute(a))) -> Element(a)

pub fn milestone(attributes: List(Attribute(a))) -> Element(a)

pub fn milk(attributes: List(Attribute(a))) -> Element(a)

pub fn milk_off(attributes: List(Attribute(a))) -> Element(a)

pub fn minimize(attributes: List(Attribute(a))) -> Element(a)

pub fn minimize_2(attributes: List(Attribute(a))) -> Element(a)

pub fn minus(attributes: List(Attribute(a))) -> Element(a)

pub fn monitor(attributes: List(Attribute(a))) -> Element(a)

pub fn monitor_check(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn monitor_cog(attributes: List(Attribute(a))) -> Element(a)

pub fn monitor_dot(attributes: List(Attribute(a))) -> Element(a)

pub fn monitor_down(attributes: List(Attribute(a))) -> Element(a)

pub fn monitor_off(attributes: List(Attribute(a))) -> Element(a)

pub fn monitor_pause(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn monitor_play(attributes: List(Attribute(a))) -> Element(a)

pub fn monitor_smartphone(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn monitor_speaker(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn monitor_stop(attributes: List(Attribute(a))) -> Element(a)

pub fn monitor_up(attributes: List(Attribute(a))) -> Element(a)

pub fn monitor_x(attributes: List(Attribute(a))) -> Element(a)

pub fn moon(attributes: List(Attribute(a))) -> Element(a)

pub fn moon_star(attributes: List(Attribute(a))) -> Element(a)

pub fn mountain(attributes: List(Attribute(a))) -> Element(a)

pub fn mountain_snow(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn mouse(attributes: List(Attribute(a))) -> Element(a)

pub fn mouse_off(attributes: List(Attribute(a))) -> Element(a)

pub fn mouse_pointer(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn mouse_pointer_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn mouse_pointer_ban(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn mouse_pointer_click(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn move(attributes: List(Attribute(a))) -> Element(a)

pub fn move_3d(attributes: List(Attribute(a))) -> Element(a)

pub fn move_diagonal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn move_diagonal_2(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn move_down(attributes: List(Attribute(a))) -> Element(a)

pub fn move_down_left(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn move_down_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn move_horizontal(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn move_left(attributes: List(Attribute(a))) -> Element(a)

pub fn move_right(attributes: List(Attribute(a))) -> Element(a)

pub fn move_up(attributes: List(Attribute(a))) -> Element(a)

pub fn move_up_left(attributes: List(Attribute(a))) -> Element(a)

pub fn move_up_right(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn move_vertical(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn music(attributes: List(Attribute(a))) -> Element(a)

pub fn music_2(attributes: List(Attribute(a))) -> Element(a)

pub fn music_3(attributes: List(Attribute(a))) -> Element(a)

pub fn music_4(attributes: List(Attribute(a))) -> Element(a)

pub fn navigation(attributes: List(Attribute(a))) -> Element(a)

pub fn navigation_2(attributes: List(Attribute(a))) -> Element(a)

pub fn navigation_2_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn navigation_off(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn network(attributes: List(Attribute(a))) -> Element(a)

pub fn newspaper(attributes: List(Attribute(a))) -> Element(a)

pub fn nfc(attributes: List(Attribute(a))) -> Element(a)

pub fn notebook(attributes: List(Attribute(a))) -> Element(a)

pub fn notebook_pen(attributes: List(Attribute(a))) -> Element(a)

pub fn notebook_tabs(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn notebook_text(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn notepad_text(attributes: List(Attribute(a))) -> Element(a)

pub fn notepad_text_dashed(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn nut(attributes: List(Attribute(a))) -> Element(a)

pub fn nut_off(attributes: List(Attribute(a))) -> Element(a)

pub fn octagon(attributes: List(Attribute(a))) -> Element(a)

pub fn octagon_alert(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn octagon_minus(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn octagon_pause(
  attributes: List(Attribute(a)),
) -> Element(a)

pub fn octagon_x(attributes: List(Attribute(a))) -> Element(a)

pub fn omega(attributes: List(Attribute(a))) -> Element(a)

pub fn option(attributes: List(Attribute(a))) -> Element(a)

pub fn orbit(attributes: List(Attribute(a))) -> Element(a)

pub fn origami(attributes: List(Attribute(a))) -> Element(a)

pub fn package(attributes: List(Attribute(a))) -> Element(a)

pub fn package_2(attributes: List(Attribute(a))) -> Element(a)

pub fn package_check(
  attributes: List(Attribute(a)),
) -> Element(a)