@elastic/eui/es/components/icon/icon_map.js

Elastic UI Component Library

/*
 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
 * or more contributor license agreements. Licensed under the Elastic License
 * 2.0 and the Server Side Public License, v 1; you may not use this file except
 * in compliance with, at your election, the Elastic License 2.0 or the Server
 * Side Public License, v 1.
 */

export var typeToPathMap = {
  accessibility: function accessibility() {
    return import('./assets/accessibility');
  },
  addDataApp: function addDataApp() {
    return import('./assets/app_add_data');
  },
  addToDashboard: function addToDashboard() {
    return import('./assets/add_to_dashboard');
  },
  advancedSettingsApp: function advancedSettingsApp() {
    return import('./assets/app_advanced_settings');
  },
  agentApp: function agentApp() {
    return import('./assets/app_fleet');
  },
  aggregate: function aggregate() {
    return import('./assets/aggregate');
  },
  alignBottom: function alignBottom() {
    return import('./assets/align_bottom');
  },
  alignBottomLeft: function alignBottomLeft() {
    return import('./assets/align_bottom_left');
  },
  alignBottomRight: function alignBottomRight() {
    return import('./assets/align_bottom_right');
  },
  alignCenterHorizontal: function alignCenterHorizontal() {
    return import('./assets/align_center_horizontal');
  },
  alignCenterVertical: function alignCenterVertical() {
    return import('./assets/align_center_vertical');
  },
  alignLeft: function alignLeft() {
    return import('./assets/align_left');
  },
  alignRight: function alignRight() {
    return import('./assets/align_right');
  },
  alignTop: function alignTop() {
    return import('./assets/align_top');
  },
  alignTopLeft: function alignTopLeft() {
    return import('./assets/align_top_left');
  },
  alignTopRight: function alignTopRight() {
    return import('./assets/align_top_right');
  },
  alert: function alert() {
    return import('./assets/warning');
  },
  // NOTE: To be deprecated in favor of `warning`
  analyzeEvent: function analyzeEvent() {
    return import('./assets/analyze_event');
  },
  annotation: function annotation() {
    return import('./assets/annotation');
  },
  anomalyChart: function anomalyChart() {
    return import('./assets/chart_anomaly');
  },
  // NOTE: To be deprecated in favor of chartAnomaly
  chartAnomaly: function chartAnomaly() {
    return import('./assets/chart_anomaly');
  },
  anomalySwimLane: function anomalySwimLane() {
    return import('./assets/anomaly_swim_lane');
  },
  apmApp: function apmApp() {
    return import('./assets/app_apm');
  },
  apmTrace: function apmTrace() {
    return import('./assets/chart_waterfall');
  },
  // NOTE: To be deprecated in favor of chartWaterfall
  chartWaterfall: function chartWaterfall() {
    return import('./assets/chart_waterfall');
  },
  appSearchApp: function appSearchApp() {
    return import('./assets/app_app_search');
  },
  apps: function apps() {
    return import('./assets/apps');
  },
  arrowDown: function arrowDown() {
    return import('./assets/chevron_single_down');
  },
  // NOTE: To be deprecated in favor of chevronSingleDown
  chevronSingleDown: function chevronSingleDown() {
    return import('./assets/chevron_single_down');
  },
  arrowLeft: function arrowLeft() {
    return import('./assets/chevron_single_left');
  },
  // NOTE: To be deprecated in favor of chevronSingleLeft
  chevronSingleLeft: function chevronSingleLeft() {
    return import('./assets/chevron_single_left');
  },
  arrowRight: function arrowRight() {
    return import('./assets/chevron_single_right');
  },
  // NOTE: To be deprecated in favor of chevronSinglRight
  chevronSingleRight: function chevronSingleRight() {
    return import('./assets/chevron_single_right');
  },
  arrowUp: function arrowUp() {
    return import('./assets/chevron_single_up');
  },
  // NOTE: To be deprecated in favor of chevronSingleUp
  chevronSingleUp: function chevronSingleUp() {
    return import('./assets/chevron_single_up');
  },
  arrowStart: function arrowStart() {
    return import('./assets/chevron_limit_left');
  },
  // NOTE: To be deprecated in favor of chevronLimitLeft
  chevronLimitLeft: function chevronLimitLeft() {
    return import('./assets/chevron_limit_left');
  },
  arrowEnd: function arrowEnd() {
    return import('./assets/chevron_limit_right');
  },
  // NOTE: To be deprecated in favor of chevronLimitRight
  chevronLimitRight: function chevronLimitRight() {
    return import('./assets/chevron_limit_right');
  },
  article: function article() {
    return import('./assets/article');
  },
  asterisk: function asterisk() {
    return import('./assets/asterisk');
  },
  at: function at() {
    return import('./assets/at');
  },
  archive: function archive() {
    return import('./assets/archive');
  },
  axisX: function axisX() {
    return import('./assets/axis_x');
  },
  axisYLeft: function axisYLeft() {
    return import('./assets/axis_y_left');
  },
  axisYRight: function axisYRight() {
    return import('./assets/axis_y_right');
  },
  auditbeatApp: function auditbeatApp() {
    return import('./assets/app_auditbeat');
  },
  backgroundTask: function backgroundTask() {
    return import('./assets/background_task');
  },
  beaker: function beaker() {
    return import('./assets/flask');
  },
  // NOTE: To be deprecated in favor of `flask`
  bell: function bell() {
    return import('./assets/bell');
  },
  bellSlash: function bellSlash() {
    return import('./assets/bell_slash');
  },
  beta: function beta() {
    return import('./assets/beta');
  },
  bolt: function bolt() {
    return import('./assets/bolt');
  },
  boxesHorizontal: function boxesHorizontal() {
    return import('./assets/boxes_vertical');
  },
  // NOTE: To be deprecated in favor of `boxes_vertical`
  boxesVertical: function boxesVertical() {
    return import('./assets/boxes_vertical');
  },
  branch: function branch() {
    return import('./assets/branch');
  },
  briefcase: function briefcase() {
    return import('./assets/briefcase');
  },
  branchUser: function branchUser() {
    return import('./assets/branch_user');
  },
  broom: function broom() {
    return import('./assets/broom');
  },
  brush: function brush() {
    return import('./assets/brush');
  },
  bug: function bug() {
    return import('./assets/bug');
  },
  bulb: function bulb() {
    return import('./assets/bulb');
  },
  bullseye: function bullseye() {
    return import('./assets/bullseye');
  },
  calendar: function calendar() {
    return import('./assets/calendar');
  },
  canvasApp: function canvasApp() {
    return import('./assets/app_canvas');
  },
  casesApp: function casesApp() {
    return import('./assets/app_cases');
  },
  changePointDetection: function changePointDetection() {
    return import('./assets/chart_change_point');
  },
  // NOTE: To be deprecated in favor of chartChangePoint
  chartChangePoint: function chartChangePoint() {
    return import('./assets/chart_change_point');
  },
  chartArea: function chartArea() {
    return import('./assets/chart_area');
  },
  chartAreaStack: function chartAreaStack() {
    return import('./assets/chart_area_stack');
  },
  chartBarHorizontal: function chartBarHorizontal() {
    return import('./assets/chart_bar_horizontal');
  },
  chartBarHorizontalStack: function chartBarHorizontalStack() {
    return import('./assets/chart_bar_horizontal_stack');
  },
  chartBarVertical: function chartBarVertical() {
    return import('./assets/chart_bar_vertical');
  },
  chartBarVerticalStack: function chartBarVerticalStack() {
    return import('./assets/chart_bar_vertical_stack');
  },
  chartGauge: function chartGauge() {
    return import('./assets/chart_gauge');
  },
  chartHeatmap: function chartHeatmap() {
    return import('./assets/chart_heatmap');
  },
  chartLine: function chartLine() {
    return import('./assets/chart_line');
  },
  chartPie: function chartPie() {
    return import('./assets/chart_pie');
  },
  chartTagCloud: function chartTagCloud() {
    return import('./assets/chart_tag_cloud');
  },
  chartThreshold: function chartThreshold() {
    return import('./assets/chart_threshold');
  },
  check: function check() {
    return import('./assets/check');
  },
  checkCircle: function checkCircle() {
    return import('./assets/check_circle');
  },
  checkInCircleFilled: function checkInCircleFilled() {
    return import('./assets/check_circle_fill');
  },
  // NOTE: To be deprecated in favor of checkCircleFill
  checkCircleFill: function checkCircleFill() {
    return import('./assets/check_circle_fill');
  },
  cheer: function cheer() {
    return import('./assets/popper');
  },
  // NOTE: To be deprecated in favor of popper
  popper: function popper() {
    return import('./assets/popper');
  },
  classificationJob: function classificationJob() {
    return import('./assets/ml_classification_job');
  },
  clickLeft: function clickLeft() {
    return import('./assets/click_left');
  },
  clickRight: function clickRight() {
    return import('./assets/click_right');
  },
  clock: function clock() {
    return import('./assets/clock');
  },
  clockCounter: function clockCounter() {
    return import('./assets/clock_counter');
  },
  clockControl: function clockControl() {
    return import('./assets/clock_control');
  },
  cloud: function cloud() {
    return import('./assets/cloud');
  },
  cloudDrizzle: function cloudDrizzle() {
    return import('./assets/cloud_drizzle');
  },
  cloudStormy: function cloudStormy() {
    return import('./assets/cloud_stormy');
  },
  cloudSunny: function cloudSunny() {
    return import('./assets/cloud_sunny');
  },
  cluster: function cluster() {
    return import('./assets/cluster');
  },
  code: function code() {
    return import('./assets/code');
  },
  codeApp: function codeApp() {
    return import('./assets/app_code');
  },
  color: function color() {
    return import('./assets/paint_bucket');
  },
  // NOTE: To be deprecated in favor of paintBucket
  paintBucket: function paintBucket() {
    return import('./assets/paint_bucket');
  },
  commandLine: function commandLine() {
    return import('./assets/command_line');
  },
  comment: function comment() {
    return import('./assets/comment');
  },
  compare: function compare() {
    return import('./assets/compare');
  },
  compute: function compute() {
    return import('./assets/processor');
  },
  // NOTE: To be deprecated in favor of processor
  processor: function processor() {
    return import('./assets/processor');
  },
  console: function console() {
    return import('./assets/command_line');
  },
  // NOTE: To be deprecated in favor of commandLine
  consoleApp: function consoleApp() {
    return import('./assets/app_console');
  },
  container: function container() {
    return import('./assets/container');
  },
  continuityAbove: function continuityAbove() {
    return import('./assets/continuity_above');
  },
  continuityAboveBelow: function continuityAboveBelow() {
    return import('./assets/continuity_above_below');
  },
  continuityBelow: function continuityBelow() {
    return import('./assets/continuity_below');
  },
  continuityWithin: function continuityWithin() {
    return import('./assets/continuity_within');
  },
  contrast: function contrast() {
    return import('./assets/contrast');
  },
  contrastHigh: function contrastHigh() {
    return import('./assets/contrast_fill');
  },
  // NOTE: To be deprecated in favor of contrastFill
  contrastFill: function contrastFill() {
    return import('./assets/contrast_fill');
  },
  controls: function controls() {
    return import('./assets/controls');
  },
  controlsHorizontal: function controlsHorizontal() {
    return import('./assets/controls');
  },
  // NOTE: To be deprecated in favor of `controls`
  controlsVertical: function controlsVertical() {
    return import('./assets/controls');
  },
  // NOTE: To be deprecated in favor of `controls`
  copy: function copy() {
    return import('./assets/copy');
  },
  copyClipboard: function copyClipboard() {
    return import('./assets/copy');
  },
  // NOTE: To be deprecated in favor of `copy`
  crossProjectSearch: function crossProjectSearch() {
    return import('./assets/cross_project_search');
  },
  createAdvancedJob: function createAdvancedJob() {
    return import('./assets/ml_create_advanced_job');
  },
  createGenericJob: function createGenericJob() {
    return import('./assets/ml_create_generic_job');
  },
  createGeoJob: function createGeoJob() {
    return import('./assets/ml_create_geo_job');
  },
  createMultiMetricJob: function createMultiMetricJob() {
    return import('./assets/ml_create_multi_metric_job');
  },
  createPopulationJob: function createPopulationJob() {
    return import('./assets/ml_create_population_job');
  },
  createSingleMetricJob: function createSingleMetricJob() {
    return import('./assets/ml_create_single_metric_job');
  },
  cross: function cross() {
    return import('./assets/cross');
  },
  crossClusterReplicationApp: function crossClusterReplicationApp() {
    return import('./assets/app_cross_cluster_replication');
  },
  crossInCircle: function crossInCircle() {
    return import('./assets/cross_circle');
  },
  // NOTE: To be deprecated in favor of crossCircle
  crossCircle: function crossCircle() {
    return import('./assets/cross_circle');
  },
  crosshair: function crosshair() {
    return import('./assets/crosshair');
  },
  crosshairs: function crosshairs() {
    return import('./assets/crosshair');
  },
  // NOTE: To be deprecated in favor of crosshair
  currency: function currency() {
    return import('./assets/money');
  },
  // NOTE: To be deprecated in favor of money
  money: function money() {
    return import('./assets/money');
  },
  cut: function cut() {
    return import('./assets/scissors');
  },
  // NOTE: To be deprecated in favor of scissors
  scissors: function scissors() {
    return import('./assets/scissors');
  },
  dashboardApp: function dashboardApp() {
    return import('./assets/app_dashboard');
  },
  dashedCircle: function dashedCircle() {
    return import('./assets/dashed_circle');
  },
  dataVisualizer: function dataVisualizer() {
    return import('./assets/ml_data_visualizer');
  },
  database: function database() {
    return import('./assets/database');
  },
  desktop: function desktop() {
    return import('./assets/display');
  },
  // NOTE: To be deprecated in favor of display
  display: function display() {
    return import('./assets/display');
  },
  devToolsApp: function devToolsApp() {
    return import('./assets/app_devtools');
  },
  diff: function diff() {
    return import('./assets/compare');
  },
  // NOTE: To be deprecated in favor of compare
  discoverApp: function discoverApp() {
    return import('./assets/app_discover');
  },
  distributeHorizontal: function distributeHorizontal() {
    return import('./assets/distribute_horizontal');
  },
  distributeVertical: function distributeVertical() {
    return import('./assets/distribute_vertical');
  },
  download: function download() {
    return import('./assets/download');
  },
  drag: function drag() {
    return import('./assets/drag');
  },
  dragHorizontal: function dragHorizontal() {
    return import('./assets/drag_horizontal');
  },
  dragVertical: function dragVertical() {
    return import('./assets/drag_vertical');
  },
  discuss: function discuss() {
    return import('./assets/comment');
  },
  // NOTE: To be deprecated in favor of `comment`
  document: function document() {
    return import('./assets/document');
  },
  documentEdit: function documentEdit() {
    return import('./assets/document_edit');
  },
  // NOTE: To be deprecated in favor of pencil
  documentation: function documentation() {
    return import('./assets/documentation');
  },
  documents: function documents() {
    return import('./assets/documents');
  },
  dot: function dot() {
    return import('./assets/dot');
  },
  dotInCircle: function dotInCircle() {
    return import('./assets/dot_in_circle');
  },
  doubleArrowLeft: function doubleArrowLeft() {
    return import('./assets/chevron_double_left');
  },
  // NOTE: To be deprecated in favor of chevronDoubleLeft
  chevronDoubleLeft: function chevronDoubleLeft() {
    return import('./assets/chevron_double_left');
  },
  doubleArrowRight: function doubleArrowRight() {
    return import('./assets/chevron_double_right');
  },
  // NOTE: To be deprecated in favor of chevronDoubleRight
  chevronDoubleRight: function chevronDoubleRight() {
    return import('./assets/chevron_double_right');
  },
  ellipsis: function ellipsis() {
    return import('./assets/ellipsis');
  },
  editorAlignCenter: function editorAlignCenter() {
    return import('./assets/text_align_center');
  },
  // NOTE: To be deprecated in favor of textAlignCenter
  textAlignCenter: function textAlignCenter() {
    return import('./assets/text_align_center');
  },
  editorAlignLeft: function editorAlignLeft() {
    return import('./assets/text_align_left');
  },
  // NOTE: To be deprecated in favor of textAlignLeft
  textAlignLeft: function textAlignLeft() {
    return import('./assets/text_align_left');
  },
  editorAlignRight: function editorAlignRight() {
    return import('./assets/text_align_right');
  },
  // NOTE: To be deprecated in favor of textAlignRight
  textAlignRight: function textAlignRight() {
    return import('./assets/text_align_right');
  },
  editorBold: function editorBold() {
    return import('./assets/text_bold');
  },
  // NOTE: To be deprecated in favor of textBold
  textBold: function textBold() {
    return import('./assets/text_bold');
  },
  editorChecklist: function editorChecklist() {
    return import('./assets/list_check');
  },
  // NOTE: To be deprecated in favor of listCheck
  listCheck: function listCheck() {
    return import('./assets/list_check');
  },
  editorCodeBlock: function editorCodeBlock() {
    return import('./assets/code');
  },
  // NOTE: To be deprecated in favor of `code`
  editorComment: function editorComment() {
    return import('./assets/comment');
  },
  // NOTE: To be deprecated in favor of `comment`
  editorDistributeHorizontal: function editorDistributeHorizontal() {
    return import('./assets/editor_distribute_horizontal');
  },
  // NOTE: To be deprecated in favor of distributeHorizontal
  editorDistributeVertical: function editorDistributeVertical() {
    return import('./assets/editor_distribute_vertical');
  },
  // NOTE: To be deprecated in favor of distributeVertical
  editorHeading: function editorHeading() {
    return import('./assets/text_heading');
  },
  // NOTE: To be deprecated in favor of textHeading
  textHeading: function textHeading() {
    return import('./assets/text_heading');
  },
  editorItalic: function editorItalic() {
    return import('./assets/text_italic');
  },
  // NOTE: To be deprecated in favor of textItalic
  textItalic: function textItalic() {
    return import('./assets/text_italic');
  },
  editorItemAlignBottom: function editorItemAlignBottom() {
    return import('./assets/editor_item_align_bottom');
  },
  // NOTE: To be deprecated in favor of alignBottom
  editorItemAlignCenter: function editorItemAlignCenter() {
    return import('./assets/editor_item_align_center');
  },
  // NOTE: To be deprecated in favor of alignCenterHorizontal
  editorItemAlignLeft: function editorItemAlignLeft() {
    return import('./assets/editor_item_align_left');
  },
  // NOTE: To be deprecated in favor of alignLeft
  editorItemAlignMiddle: function editorItemAlignMiddle() {
    return import('./assets/editor_item_align_middle');
  },
  // NOTE: To be deprecated in favor of alignCenterVertical
  editorItemAlignRight: function editorItemAlignRight() {
    return import('./assets/editor_item_align_right');
  },
  // NOTE: To be deprecated in favor of alignRight
  editorItemAlignTop: function editorItemAlignTop() {
    return import('./assets/editor_item_align_top');
  },
  // NOTE: To be deprecated in favor of alignTop,
  editorLink: function editorLink() {
    return import('./assets/link');
  },
  // NOTE: To be deprecated in favor of `link`
  editorOrderedList: function editorOrderedList() {
    return import('./assets/list_number');
  },
  // NOTE: To be deprecated in favor of listNumber
  listNumber: function listNumber() {
    return import('./assets/list_number');
  },
  editorPositionBottomLeft: function editorPositionBottomLeft() {
    return import('./assets/editor_position_bottom_left');
  },
  // NOTE: To be deprecated in favor of alignBottomLeft
  editorPositionBottomRight: function editorPositionBottomRight() {
    return import('./assets/editor_position_bottom_right');
  },
  // NOTE: To be deprecated in favor of alignBottomRight
  editorPositionTopLeft: function editorPositionTopLeft() {
    return import('./assets/editor_position_top_left');
  },
  // NOTE: To be deprecated in favor of alignTopLeft
  editorPositionTopRight: function editorPositionTopRight() {
    return import('./assets/editor_position_top_right');
  },
  // NOTE: To be deprecated in favor of alignTopRight
  editorRedo: function editorRedo() {
    return import('./assets/redo');
  },
  // NOTE: To be deprecated in favor of redo
  redo: function redo() {
    return import('./assets/redo');
  },
  editorStrike: function editorStrike() {
    return import('./assets/text_strike');
  },
  // NOTE: To be deprecated in favor of textStrike
  textStrike: function textStrike() {
    return import('./assets/text_strike');
  },
  editorTable: function editorTable() {
    return import('./assets/table');
  },
  // NOTE: To be deprecated in favor of table
  table: function table() {
    return import('./assets/table');
  },
  editorUnderline: function editorUnderline() {
    return import('./assets/text_underline');
  },
  // NOTE: To be deprecated in favor of textUnderline
  textUnderline: function textUnderline() {
    return import('./assets/text_underline');
  },
  editorUndo: function editorUndo() {
    return import('./assets/undo');
  },
  // NOTE: To be deprecated in favor of undo
  undo: function undo() {
    return import('./assets/undo');
  },
  editorUnorderedList: function editorUnorderedList() {
    return import('./assets/list_bullet');
  },
  // NOTE: To be deprecated in favor of listBullet
  listBullet: function listBullet() {
    return import('./assets/list_bullet');
  },
  email: function email() {
    return import('./assets/mail');
  },
  // NOTE: To be deprecated in favor of mail
  mail: function mail() {
    return import('./assets/mail');
  },
  empty: function empty() {
    return import('./assets/empty');
  },
  emsApp: function emsApp() {
    return import('./assets/app_ems');
  },
  endpoint: function endpoint() {
    return import('./assets/endpoint');
  },
  eql: function eql() {
    return import('./assets/query');
  },
  // NOTE: To be deprecated in favor of query
  query: function query() {
    return import('./assets/query');
  },
  eraser: function eraser() {
    return import('./assets/eraser');
  },
  error: function error() {
    return import('./assets/error');
  },
  errorFilled: function errorFilled() {
    return import('./assets/error_fill');
  },
  // NOTE: To be deprecated in favor of errorFill
  errorFill: function errorFill() {
    return import('./assets/error_fill');
  },
  esqlVis: function esqlVis() {
    return import('./assets/esql_vis');
  },
  exit: function exit() {
    return import('./assets/log_out');
  },
  // NOTE: To be deprecated in favor of logOut
  logOut: function logOut() {
    return import('./assets/log_out');
  },
  expand: function expand() {
    return import('./assets/maximize');
  },
  // NOTE: To be deprecated in favor of maximize
  maximize: function maximize() {
    return import('./assets/maximize');
  },
  expandMini: function expandMini() {
    return import('./assets/maximize');
  },
  // NOTE: To be deprecated in favor of maximize
  export: function _export() {
    return import('./assets/upload');
  },
  exportAction: function exportAction() {
    return import('./assets/upload');
  },
  // NOTE: To be deprecated in favor of upload
  upload: function upload() {
    return import('./assets/upload');
  },
  external: function external() {
    return import('./assets/external');
  },
  eye: function eye() {
    return import('./assets/eye');
  },
  eyeClosed: function eyeClosed() {
    return import('./assets/eye_slash');
  },
  // NOTE: To be deprecated in favor of eyeSlash
  eyeSlash: function eyeSlash() {
    return import('./assets/eye_slash');
  },
  faceHappy: function faceHappy() {
    return import('./assets/face_happy');
  },
  faceNeutral: function faceNeutral() {
    return import('./assets/face_neutral');
  },
  faceSad: function faceSad() {
    return import('./assets/face_sad');
  },
  fieldStatistics: function fieldStatistics() {
    return import('./assets/table_info');
  },
  // NOTE: To be deprecated in favor of tableInfo
  tableInfo: function tableInfo() {
    return import('./assets/table_info');
  },
  filebeatApp: function filebeatApp() {
    return import('./assets/app_filebeat');
  },
  filter: function filter() {
    return import('./assets/filter');
  },
  filterExclude: function filterExclude() {
    return import('./assets/filter_exclude');
  },
  filterIgnore: function filterIgnore() {
    return import('./assets/filter_ignore');
  },
  filterInclude: function filterInclude() {
    return import('./assets/filter_include');
  },
  filterInCircle: function filterInCircle() {
    return import('./assets/filter_in_circle');
  },
  // NOTE: To be deprecated in favor of filter
  flask: function flask() {
    return import('./assets/flask');
  },
  flag: function flag() {
    return import('./assets/flag');
  },
  fleetApp: function fleetApp() {
    return import('./assets/app_agent');
  },
  fold: function fold() {
    return import('./assets/fold');
  },
  folder: function folder() {
    return import('./assets/folder_close');
  },
  folderClosed: function folderClosed() {
    return import('./assets/folder_close');
  },
  folderClose: function folderClose() {
    return import('./assets/folder_close');
  },
  folderCheck: function folderCheck() {
    return import('./assets/folder_check');
  },
  folderExclamation: function folderExclamation() {
    return import('./assets/folder_exclamation');
  },
  folderOpen: function folderOpen() {
    return import('./assets/folder_open');
  },
  folderOpened: function folderOpened() {
    return import('./assets/folder_open');
  },
  frameNext: function frameNext() {
    return import('./assets/frame_next');
  },
  framePrevious: function framePrevious() {
    return import('./assets/frame_previous');
  },
  fullScreen: function fullScreen() {
    return import('./assets/full_screen');
  },
  fullScreenExit: function fullScreenExit() {
    return import('./assets/full_screen_exit');
  },
  function: function _function() {
    return import('./assets/function');
  },
  gear: function gear() {
    return import('./assets/gear');
  },
  gisApp: function gisApp() {
    return import('./assets/app_gis');
  },
  glasses: function glasses() {
    return import('./assets/read_only');
  },
  // NOTE: To be deprecated in favor of `readOnly`
  globe: function globe() {
    return import('./assets/globe');
  },
  grab: function grab() {
    return import('./assets/drag_vertical');
  },
  // NOTE: To be deprecated in favor of dragVertical
  grabHorizontal: function grabHorizontal() {
    return import('./assets/drag_horizontal');
  },
  // NOTE: To be deprecated in favor of dragHorizontal
  grabOmnidirectional: function grabOmnidirectional() {
    return import('./assets/grab_omnidirectional');
  },
  // NOTE: To be deprecated in favor of drag,
  gradient: function gradient() {
    return import('./assets/gradient');
  },
  graphApp: function graphApp() {
    return import('./assets/app_graph');
  },
  grid: function grid() {
    return import('./assets/grid');
  },
  grokApp: function grokApp() {
    return import('./assets/app_grok');
  },
  heart: function heart() {
    return import('./assets/heart');
  },
  heartbeatApp: function heartbeatApp() {
    return import('./assets/app_heartbeat');
  },
  heatmap: function heatmap() {
    return import('./assets/chart_heatmap');
  },
  // NOTE: To be deprecated in favor of chartHeatmap
  help: function help() {
    return import('./assets/help');
  },
  // NOTE: Might be deprecated later (not recommended in Kibana)
  home: function home() {
    return import('./assets/home');
  },
  hourglass: function hourglass() {
    return import('./assets/hourglass');
  },
  if: function _if() {
    return import('./assets/if');
  },
  info: function info() {
    return import('./assets/info');
  },
  image: function image() {
    return import('./assets/image');
  },
  importAction: function importAction() {
    return import('./assets/download');
  },
  // NOTE: To be deprecated in favor of download
  index: function index() {
    return import('./assets/index');
  },
  indexClose: function indexClose() {
    return import('./assets/index_close');
  },
  indexEdit: function indexEdit() {
    return import('./assets/index_edit');
  },
  indexFlush: function indexFlush() {
    return import('./assets/chart_threshold');
  },
  // NOTE: To be deprecated in favor of chartThreshold
  indexManagementApp: function indexManagementApp() {
    return import('./assets/app_index_management');
  },
  indexMapping: function indexMapping() {
    return import('./assets/mapping');
  },
  // NOTE: To be deprecated in favor of mapping
  mapping: function mapping() {
    return import('./assets/mapping');
  },
  indexOpen: function indexOpen() {
    return import('./assets/index_open');
  },
  indexPatternApp: function indexPatternApp() {
    return import('./assets/app_index_pattern');
  },
  indexRollupApp: function indexRollupApp() {
    return import('./assets/app_index_rollup');
  },
  indexRuntime: function indexRuntime() {
    return import('./assets/index_runtime');
  },
  indexSettings: function indexSettings() {
    return import('./assets/index_settings');
  },
  indexTemporary: function indexTemporary() {
    return import('./assets/table_time');
  },
  // NOTE: To be deprecated in favor of tableTime
  tableTime: function tableTime() {
    return import('./assets/table_time');
  },
  infinity: function infinity() {
    return import('./assets/infinity');
  },
  inputOutput: function inputOutput() {
    return import('./assets/input_output');
  },
  inspect: function inspect() {
    return import('./assets/inspect');
  },
  invert: function invert() {
    return import('./assets/contrast');
  },
  // NOTE: To be deprecated in favor of contrast
  ip: function ip() {
    return import('./assets/ip');
  },
  key: function key() {
    return import('./assets/key');
  },
  keyboard: function keyboard() {
    return import('./assets/keyboard');
  },
  kqlField: function kqlField() {
    return import('./assets/query_field');
  },
  // NOTE: To be deprecated in favor of queryField
  queryField: function queryField() {
    return import('./assets/query_field');
  },
  kqlFunction: function kqlFunction() {
    return import('./assets/kql_function');
  },
  kqlOperand: function kqlOperand() {
    return import('./assets/query_operand');
  },
  // NOTE: To be deprecated in favor of queryOperand
  queryOperand: function queryOperand() {
    return import('./assets/query_operand');
  },
  kqlSelector: function kqlSelector() {
    return import('./assets/query_selector');
  },
  // NOTE: To be deprecated in favor of querySelector
  querySelector: function querySelector() {
    return import('./assets/query_selector');
  },
  kqlValue: function kqlValue() {
    return import('./assets/query_value');
  },
  // NOTE: To be deprecated in favor of queryValue
  queryValue: function queryValue() {
    return import('./assets/query_value');
  },
  kubernetesNode: function kubernetesNode() {
    return import('./assets/kubernetes_node');
  },
  kubernetesPod: function kubernetesPod() {
    return import('./assets/kubernetes_pod');
  },
  launch: function launch() {
    return import('./assets/rocket');
  },
  // NOTE: To be deprecated in favor of rocket
  rocket: function rocket() {
    return import('./assets/rocket');
  },
  layers: function layers() {
    return import('./assets/layers');
  },
  lensApp: function lensApp() {
    return import('./assets/app_lens');
  },
  lettering: function lettering() {
    return import('./assets/text');
  },
  // NOTE: To be deprecated in favor of text
  text: function text() {
    return import('./assets/text');
  },
  lineBreak: function lineBreak() {
    return import('./assets/line_break');
  },
  lineBreakSlash: function lineBreakSlash() {
    return import('./assets/line_break_slash');
  },
  lineDash: function lineDash() {
    return import('./assets/line_dash');
  },
  lineDashed: function lineDashed() {
    return import('./assets/line_dash');
  },
  // NOTE: To be deprecated in favor of lineDash
  lineDot: function lineDot() {
    return import('./assets/line_dot');
  },
  lineDotted: function lineDotted() {
    return import('./assets/line_dot');
  },
  // NOTE: To be deprecated in favor of lineDot
  lineSolid: function lineSolid() {
    return import('./assets/line_solid');
  },
  link: function link() {
    return import('./assets/link');
  },
  linkSlash: function linkSlash() {
    return import('./assets/link_slash');
  },
  list: function list() {
    return import('./assets/list_bullet');
  },
  // NOTE: To be deprecated in favor of listBullet,
  listAdd: function listAdd() {
    return import('./assets/plus_circle');
  },
  // NOTE: To be deprecated in favor of `plus_circle`
  lock: function lock() {
    return import('./assets/lock');
  },
  lockOpen: function lockOpen() {
    return import('./assets/lock_open');
  },
  logPatternAnalysis: function logPatternAnalysis() {
    return import('./assets/pattern');
  },
  // NOTE: To be deprecated in favor of pattern
  pattern: function pattern() {
    return import('./assets/pattern');
  },
  logRateAnalysis: function logRateAnalysis() {
    return import('./assets/log_rate_analysis');
  },
  logoAWS: function logoAWS() {
    return import('./assets/logo_aws');
  },
  logoAWSMono: function logoAWSMono() {
    return import('./assets/logo_aws_mono');
  },
  logoAerospike: function logoAerospike() {
    return import('./assets/logo_aerospike');
  },
  logoApache: function logoApache() {
    return import('./assets/logo_apache');
  },
  logoAppSearch: function logoAppSearch() {
    return import('./assets/logo_app_search');
  },
  logoAzure: function logoAzure() {
    return import('./assets/logo_azure');
  },
  logoAzureMono: function logoAzureMono() {
    return import('./assets/logo_azure_mono');
  },
  logoBeats: function logoBeats() {
    return import('./assets/logo_beats');
  },
  logoBusinessAnalytics: function logoBusinessAnalytics() {
    return import('./assets/logo_business_analytics');
  },
  logoCeph: function logoCeph() {
    return import('./assets/logo_ceph');
  },
  logoCloud: function logoCloud() {
    return import('./assets/logo_cloud');
  },
  logoCloudEnterprise: function logoCloudEnterprise() {
    return import('./assets/logo_cloud_ece');
  },
  logoCode: function logoCode() {
    return import('./assets/logo_code');
  },
  logoCodesandbox: function logoCodesandbox() {
    return import('./assets/logo_codesandbox');
  },
  logoCouchbase: function logoCouchbase() {
    return import('./assets/logo_couchbase');
  },
  logoDocker: function logoDocker() {
    return import('./assets/logo_docker');
  },
  logoDropwizard: function logoDropwizard() {
    return import('./assets/logo_dropwizard');
  },
  logoElastic: function logoElastic() {
    return import('./assets/logo_elastic');
  },
  logoElasticStack: function logoElasticStack() {
    return import('./assets/logo_elastic_stack');
  },
  logoElasticsearch: function logoElasticsearch() {
    return import('./assets/logo_elasticsearch');
  },
  logoEnterpriseSearch: function logoEnterpriseSearch() {
    return import('./assets/logo_enterprise_search');
  },
  logoEtcd: function logoEtcd() {
    return import('./assets/logo_etcd');
  },
  logoGCP: function logoGCP() {
    return import('./assets/logo_gcp');
  },
  logoGCPMono: function logoGCPMono() {
    return import('./assets/logo_gcp_mono');
  },
  logoGithub: function logoGithub() {
    return import('./assets/logo_github');
  },
  logoGmail: function logoGmail() {
    return import('./assets/logo_gmail');
  },
  logoGolang: function logoGolang() {
    return import('./assets/logo_golang');
  },
  logoGoogleG: function logoGoogleG() {
    return import('./assets/logo_google_g');
  },
  logoHAproxy: function logoHAproxy() {
    return import('./assets/logo_haproxy');
  },
  logoIBM: function logoIBM() {
    return import('./assets/logo_ibm');
  },
  logoIBMMono: function logoIBMMono() {
    return import('./assets/logo_ibm_mono');
  },
  logoKafka: function logoKafka() {
    return import('./assets/logo_kafka');
  },
  logoKibana: function logoKibana() {
    return import('./assets/logo_kibana');
  },
  logoKubernetes: function logoKubernetes() {
    return import('./assets/logo_kubernetes');
  },
  logoLogging: function logoLogging() {
    return import('./assets/logo_logging');
  },
  logoLogstash: function logoLogstash() {
    return import('./assets/logo_logstash');
  },
  logoMaps: function logoMaps() {
    return import('./assets/logo_maps');
  },
  logoMemcached: function logoMemcached() {
    return import('./assets/logo_memcached');
  },
  logoMetrics: function logoMetrics() {
    return import('./assets/logo_metrics');
  },
  logoMongodb: function logoMongodb() {
    return import('./assets/logo_mongodb');
  },
  logoMySQL: function logoMySQL() {
    return import('./assets/logo_mysql');
  },
  logoNginx: function logoNginx() {
    return import('./assets/logo_nginx');
  },
  logoObservability: function logoObservability() {
    return import('./assets/logo_observability');
  },
  logoOsquery: function logoOsquery() {
    return import('./assets/logo_osquery');
  },
  logoPhp: function logoPhp() {
    return import('./assets/logo_php');
  },
  logoPostgres: function logoPostgres() {
    return import('./assets/logo_postgres');
  },
  logoPrometheus: function logoPrometheus() {
    return import('./assets/logo_prometheus');
  },
  logoRabbitmq: function logoRabbitmq() {
    return import('./assets/logo_rabbitmq');
  },
  logoRedis: function logoRedis() {
    return import('./assets/logo_redis');
  },
  logoSecurity: function logoSecurity() {
    return import('./assets/logo_security');
  },
  logoSiteSearch: function logoSiteSearch() {
    return import('./assets/logo_site_search');
  },
  logoSketch: function logoSketch() {
    return import('./assets/logo_sketch');
  },
  logoSlack: function logoSlack() {
    return import('./assets/logo_slack');
  },
  logoUptime: function logoUptime() {
    return import('./assets/logo_uptime');
  },
  logoVectorDB: function logoVectorDB() {
    return import('./assets/logo_vector_db');
  },
  logoVulnerabilityManagement: function logoVulnerabilityManagement() {
    return import('./assets/logo_vulnerability_management');
  },
  logoWebhook: function logoWebhook() {
    return import('./assets/logo_webhook');
  },
  logoWindows: function logoWindows() {
    return import('./assets/logo_windows');
  },
  logoWorkplaceSearch: function logoWorkplaceSearch() {
    return import('./assets/logo_workplace_search');
  },
  logsApp: function logsApp() {
    return import('./assets/app_logs');
  },
  logstashFilter: function logstashFilter() {
    return import('./assets/logstash_filter');
  },
  logstashIf: function logstashIf() {
    return import('./assets/if');
  },
  // NOTE: To be deprecated in favor of if
  logstashInput: function logstashInput() {
    return import('./assets/logstash_input');
  },
  logstashOutput: function logstashOutput() {
    return import('./assets/logstash_output');
  },
  logstashQueue: function logstashQueue() {
    return import('./assets/queue');
  },
  // NOTE: To be deprecated in favor of queue
  queue: function queue() {
    return import('./assets/queue');
  },
  machineLearningApp: function machineLearningApp() {
    return import('./assets/app_ml');
  },
  magnet: function magnet() {
    return import('./assets/magnet');
  },
  magnify: function magnify() {
    return import('./assets/magnify');
  },
  magnifyExclamation: function magnifyExclamation() {
    return import('./assets/magnify_exclamation');
  },
  magnifyMinus: function magnifyMinus() {
    return import('./assets/magnify_minus');
  },
  magnifyPlus: function magnifyPlus() {
    return import('./assets/magnify_plus');
  },
  magnifyWithExclamation: function magnifyWithExclamation() {
    return import('./assets/magnify_with_exclamation');
  },
  // NOTE: To be deprecated in favor of magnifyExclamation
  magnifyWithMinus: function magnifyWithMinus() {
    return import('./assets/magnify_with_minus');
  },
  // NOTE: To be deprecated in favor of magnifyMinus
  magnifyWithPlus: function magnifyWithPlus() {
    return import('./assets/magnify_with_plus');
  },
  // NOTE: To be deprecated in favor of magnifyPlus,
  managementApp: function managementApp() {
    return import('./assets/app_management');
  },
  map: function map() {
    return import('./assets/map');
  },
  mapMarker: function mapMarker() {
    return import('./assets/waypoint');
  },
  // NOTE: To be deprecated in favor of waypoint
  waypoint: function waypoint() {
    return import('./assets/waypoint');
  },
  megaphone: function megaphone() {
    return import('./assets/megaphone');
  },
  memory: function memory() {
    return import('./assets/memory');
  },
  menu: function menu() {
    return import('./assets/menu');
  },
  menuDown: function menuDown() {
    return import('./assets/menu_down');
  },
  menuLeft: function menuLeft() {
    return import('./assets/menu_left');
  },
  menuRight: function menuRight() {
    return import('./assets/menu_right');
  },
  menuUp: function menuUp() {
    return import('./assets/menu_up');
  },
  merge: function merge() {
    return import('./assets/merge');
  },
  metricbeatApp: function metricbeatApp() {
    return import('./assets/app_metricbeat');
  },
  metricsApp: function metricsApp() {
    return import('./assets/app_metrics');
  },
  minimize: function minimize() {
    return import('./assets/minimize');
  },
  minus: function minus() {
    return import('./assets/minus');
  },
  minusCircle: function minusCircle() {
    return import('./assets/minus_circle');
  },
  minusInCircle: function minusInCircle() {
    return import('./assets/minus_circle');
  },
  // NOTE: To be deprecated in favor of minusCircle
  minusInCircleFilled: function minusInCircleFilled() {
    return import('./assets/minus_circle');
  },
  // NOTE: To be deprecated in favor of minusCircle
  minusInSquare: function minusInSquare() {
    return import('./assets/minus_square');
  },
  // NOTE: To be deprecated in favor of minusSquare
  minusSquare: function minusSquare() {
    return import('./assets/minus_square');
  },
  mobile: function mobile() {
    return import('./assets/mobile');
  },
  monitoringApp: function monitoringApp() {
    return import('./assets/app_monitoring');
  },
  moon: function moon() {
    return import('./assets/moon');
  },
  move: function move() {
    return import('./assets/move');
  },
  namespace: function namespace() {
    return import('./assets/namespace');
  },
  nested: function nested() {
    return import('./assets/nested');
  },
  newChat: function newChat() {
    return import('./assets/plus_circle');
  },
  // NOTE: To be deprecated in favor of plusCircle
  node: function node() {
    return import('./assets/vector_triangle');
  },
  // NOTE: To be deprecated in favor of vectorTriangle
  vectorTriangle: function vectorTriangle() {
    return import('./assets/vector_triangle');
  },
  notebookApp: function notebookApp() {
    return import('./assets/app_notebook');
  },
  number: function number() {
    return import('./assets/number');
  },
  offline: function offline() {
    return import('./assets/wifi_slash');
  },
  // NOTE: To be deprecated in favor of wifiSlash
  wifiSlash: function wifiSlash() {
    return import('./assets/wifi_slash');
  },
  online: function online() {
    return import('./assets/wifi');
  },
  // NOTE: To be deprecated in favor of wifi
  wifi: function wifi() {
    return import('./assets/wifi');
  },
  outlierDetectionJob: function outlierDetectionJob() {
    return import('./assets/ml_outlier_detection_job');
  },
  package: function _package() {
    return import('./assets/package');
  },
  packetbeatApp: function packetbeatApp() {
    return import('./assets/app_packetbeat');
  },
  pageSelect: function pageSelect() {
    return import('./assets/page_select');
  },
  pagesSelect: function pagesSelect() {
    return import('./assets/pages_select');
  },
  palette: function palette() {
    return import('./assets/palette');
  },
  paperClip: function paperClip() {
    return import('./assets/paper_clip');
  },
  partial: function partial() {
    return import('./assets/partial');
  },
  pause: function pause() {
    return import('./assets/pause');
  },
  payment: function payment() {
    return import('./assets/payment');
  },
  pencil: function pencil() {
    return import('./assets/pencil');
  },
  percent: function percent() {
    return import('./assets/percent');
  },
  pin: function pin() {
    return import('./assets/pin');
  },
  pinFill: function pinFill() {
    return import('./assets/pin_fill');
  },
  pinFilled: function pinFilled() {
    return import('./assets/pin_fill');
  },
  // NOTE: To be deprecated in favor of pinFill
  pipeBreaks: function pipeBreaks() {
    return import('./assets/line_break');
  },
  // NOTE: To be deprecated in favor of lineBreak
  pipelineApp: function pipelineApp() {
    return import('./assets/app_pipeline');
  },
  pipeNoBreaks: function pipeNoBreaks() {
    return import('./assets/line_break_slash');
  },
  // NOTE: To be deprecated in favor of lineBreakSlash
  pivot: function pivot() {
    return import('./assets/pivot');
  },
  play: function play() {
    return import('./assets/play');
  },
  playFilled: function playFilled() {
    return import('./assets/play_filled');
  },
  // NOTE: To be deprecated in favor of play
  plugs: function plugs() {
    return import('./assets/plugs');
  },
  plus: function plus() {
    return import('./assets/plus');
  },
  plusCircle: function plusCircle() {
    return import('./assets/plus_circle');
  },
  plusInCircle: function plusInCircle() {
    return import('./assets/plus_circle');
  },
  // NOTE: To be deprecated in favor of plusCircle
  plusInCircleFilled: function plusInCircleFilled() {
    return import('./assets/plus_circle');
  },
  // NOTE: To be deprecated in favor of plusCircle
  plusInSquare: function plusInSquare() {
    return import('./assets/plus_square');
  },
  // NOTE: To be deprecated in favor of plusSquare
  plusSquare: function plusSquare() {
    return import('./assets/plus_square');
  },
  popout: function popout() {
    return import('./assets/external');
  },
  // NOTE: To be deprecated in favor of external
  presentation: function presentation() {
    return import('./assets/presentation');
  },
  productRobot: function productRobot() {
    return import('./assets/product_agent');
  },
  // NOTE: To be deprecated in favor of productAgent
  productAgent: function productAgent() {
    return import('./assets/product_agent');
  },
  productCloudInfra: function productCloudInfra() {
    return import('./assets/product_cloud_infra');
  },
  productDashboard: function productDashboard() {
    return import('./assets/product_dashboard');
  },
  productDiscover: function productDiscover() {
    return import('./assets/product_discover');
  },
  productML: function productML() {
    return import('./assets/product_ml');
  },
  productStreamsClassic: function productStreamsClassic() {
    return import('./assets/product_streams_classic');
  },
  productStreamsWired: function productStreamsWired() {
    return import('./assets/product_streams_wired');
  },
  push: function push() {
    return import('./assets/send');
  },
  // NOTE: To be deprecated in favor of send
  send: function send() {
    return import('./assets/send');
  },
  question: function question() {
    return import('./assets/question');
  },
  quote: function quote() {
    return import('./assets/quote');
  },
  radar: function radar() {
    return import('./assets/radar');
  },
  readOnly: function readOnly() {
    return import('./assets/read_only');
  },
  recentlyViewedApp: function recentlyViewedApp() {
    return import('./assets/app_recently_viewed');
  },
  refresh: function refresh() {
    return import('./assets/refresh');
  },
  regressionJob: function regressionJob() {
    return import('./assets/ml_regression_job');
  },
  reporter: function reporter() {
    return import('./assets/reporter');
  },
  reportingApp: function reportingApp() {
    return import('./assets/app_reporting');
  },
  return: function _return() {
    return import('./assets/return');
  },
  returnKey: function returnKey() {
    return import('./assets/return');
  },
  // NOTE: To be deprecated in favor of return
  save: function save() {
    return import('./assets/save');
  },
  savedObjectsApp: function savedObjectsApp() {
    return import('./assets/app_saved_objects');
  },
  scale: function scale() {
    return import('./assets/scale');
  },
  search: function search() {
    return import('./assets/magnify');
  },
  // N