/*
 * 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');
  },
  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');
  },
  // NOTE: To be deprecated in favor of magnify
  searchProfilerApp: function searchProfilerApp() {
    return import('./assets/app_search_profiler');
  },
  section: function section() {
    return import('./assets/section');
  },
  securityAnalyticsApp: function securityAnalyticsApp() {
    return import('./assets/app_security_analytics');
  },
  securityApp: function securityApp() {
    return import('./assets/app_security');
  },
  securitySignal: function securitySignal() {
    return import('./assets/security_signal');
  },
  // NOTE: To be deprecated in favor of radar
  securitySignalDetected: function securitySignalDetected() {
    return import('./assets/security_signal_detected');
  },
  securitySignalResolved: function securitySignalResolved() {
    return import('./assets/security_signal_resolved');
  },
  server: function server() {
    return import('./assets/server');
  },
  sessionViewer: function sessionViewer() {
    return import('./assets/session_viewer');
  },
  shard: function shard() {
    return import('./assets/shard');
  },
  share: function share() {
    return import('./assets/share');
  },
  singleMetricViewer: function singleMetricViewer() {
    return import('./assets/single_metric_viewer');
  },
  snowflake: function snowflake() {
    return import('./assets/snowflake');
  },
  sortAscending: function sortAscending() {
    return import('./assets/sort_ascending');
  },
  sortDescending: function sortDescending() {
    return import('./assets/sort_descending');
  },
  sortDown: function sortDown() {
    return import('./assets/sort_down');
  },
  sortLeft: function sortLeft() {
    return import('./assets/sort_left');
  },
  sortRight: function sortRight() {
    return import('./assets/sort_right');
  },
  sortUp: function sortUp() {
    return import('./assets/sort_up');
  },
  sortable: function sortable() {
    return import('./assets/sortable');
  },
  spaces: function spaces() {
    return import('./assets/spaces');
  },
  spacesApp: function spacesApp() {
    return import('./assets/app_spaces');
  },
  sparkles: function sparkles() {
    return import('./assets/sparkles');
  },
  sqlApp: function sqlApp() {
    return import('./assets/app_sql');
  },
  star: function star() {
    return import('./assets/star');
  },
  starEmpty: function starEmpty() {
    return import('./assets/star');
  },
  // NOTE: To be deprecated in favor of star
  starEmptySpace: function starEmptySpace() {
    return import('./assets/star_empty_space');
  },
  starFill: function starFill() {
    return import('./assets/star_fill');
  },
  starFilled: function starFilled() {
    return import('./assets/star_fill');
  },
  // NOTE: To be deprecated in favor of starFill,
  starFillSpace: function starFillSpace() {
    return import('./assets/star_fill_space');
  },
  starFilledSpace: function starFilledSpace() {
    return import('./assets/star_fill_space');
  },
  // NOTE: To be deprecated in favor of starFillSpace
  starMinusEmpty: function starMinusEmpty() {
    return import('./assets/star_minus_empty');
  },
  starMinusFill: function starMinusFill() {
    return import('./assets/star_minus_fill');
  },
  starMinusFilled: function starMinusFilled() {
    return import('./assets/star_minus_fill');
  },
  // NOTE: To be deprecated in favor of starMinusFill
  starPlusEmpty: function starPlusEmpty() {
    return import('./assets/star_plus_empty');
  },
  starPlusFill: function starPlusFill() {
    return import('./assets/star_plus_fill');
  },
  starPlusFilled: function starPlusFilled() {
    return import('./assets/star_plus_fill');
  },
  // NOTE: To be deprecated in favor of starPlusFill
  stats: function stats() {
    return import('./assets/stats');
  },
  stop: function stop() {
    return import('./assets/stop');
  },
  stopFill: function stopFill() {
    return import('./assets/stop_fill');
  },
  stopFilled: function stopFilled() {
    return import('./assets/stop_fill');
  },
  // NOTE: To be deprecated in favor of stopFill
  stopSlash: function stopSlash() {
    return import('./assets/stop_slash');
  },
  storage: function storage() {
    return import('./assets/storage');
  },
  streamsClassic: function streamsClassic() {
    return import('./assets/product_streams_classic');
  },
  // NOTE: To be deprecated in favor of productStreamsClassic
  streamsWired: function streamsWired() {
    return import('./assets/product_streams_wired');
  },
  // NOTE: To be deprecated in favor of productStreamsWired
  string: function string() {
    return import('./assets/string');
  },
  submodule: function submodule() {
    return import('./assets/merge');
  },
  // NOTE: To be deprecated in favor of `merge`
  sun: function sun() {
    return import('./assets/sun');
  },
  swatchInput: function swatchInput() {
    return import('./assets/swatch_input');
  },
  // Undocumented on purpose. Has an extra stroke for EuiColorPicker
  symlink: function symlink() {
    return import('./assets/symlink');
  },
  tableDensityCompact: function tableDensityCompact() {
    return import('./assets/table_density_high');
  },
  // NOTE: To be deprecated in favor of tableDensityHigh
  tableDensityHigh: function tableDensityHigh() {
    return import('./assets/table_density_high');
  },
  tableDensityExpanded: function tableDensityExpanded() {
    return import('./assets/table_density_low');
  },
  // NOTE: To be deprecated in favor of tableDensityLow
  tableDensityLow: function tableDensityLow() {
    return import('./assets/table_density_low');
  },
  tableDensityNormal: function tableDensityNormal() {
    return import('./assets/table');
  },
  // NOTE: To be deprecated in favor of table
  tableOfContents: function tableOfContents() {
    return import('./assets/table_of_contents');
  },
  tag: function tag() {
    return import('./assets/tag');
  },
  tear: function tear() {
    return import('./assets/tear');
  },
  temperature: function temperature() {
    return import('./assets/thermometer');
  },
  // NOTE: To be deprecated in favor of thermometer
  thermometer: function thermometer() {
    return import('./assets/thermometer');
  },
  thumbDown: function thumbDown() {
    return import('./assets/thumb_down');
  },
  thumbUp: function thumbUp() {
    return import('./assets/thumb_up');
  },
  timeline: function timeline() {
    return import('./assets/timeline');
  },
  timelineWithArrow: function timelineWithArrow() {
    return import('./assets/timeline_with_arrow');
  },
  timelionApp: function timelionApp() {
    return import('./assets/app_timelion');
  },
  timeRefresh: function timeRefresh() {
    return import('./assets/refresh_time');
  },
  // NOTE: To be deprecated in favor of refreshTime
  refreshTime: function refreshTime() {
    return import('./assets/refresh_time');
  },
  timeslider: function timeslider() {
    return import('./assets/clock_control');
  },
  // NOTE: To be deprecated in favor of clockControl
  training: function training() {
    return import('./assets/presentation');
  },
  // NOTE: To be deprecated in favor of presentation,
  transitionBottomIn: function transitionBottomIn() {
    return import('./assets/transition_bottom_in');
  },
  transitionBottomOut: function transitionBottomOut() {
    return import('./assets/transition_bottom_out');
  },
  transitionLeftIn: function transitionLeftIn() {
    return import('./assets/transition_left_in');
  },
  transitionLeftOut: function transitionLeftOut() {
    return import('./assets/transition_left_out');
  },
  transitionTopIn: function transitionTopIn() {
    return import('./assets/transition_top_in');
  },
  transitionTopOut: function transitionTopOut() {
    return import('./assets/transition_top_out');
  },
  trash: function trash() {
    return import('./assets/trash');
  },
  unfold: function unfold() {
    return import('./assets/unfold');
  },
  unlink: function unlink() {
    return import('./assets/link_slash');
  },
  // NOTE: To be deprecated in favor of linkSlash
  upgradeAssistantApp: function upgradeAssistantApp() {
    return import('./assets/app_upgrade_assistant');
  },
  uptimeApp: function uptimeApp() {
    return import('./assets/app_uptime');
  },
  user: function user() {
    return import('./assets/user');
  },
  userAvatar: function userAvatar() {
    return import('./assets/user');
  },
  // NOTE: To be deprecated in favor of `user`
  users: function users() {
    return import('./assets/users');
  },
  usersRolesApp: function usersRolesApp() {
    return import('./assets/app_users_roles');
  },
  unarchive: function unarchive() {
    return import('./assets/unarchive');
  },
  vector: function vector() {
    return import('./assets/vector_square');
  },
  // NOTE: To be deprecated in favor of vectorSquare
  vectorSquare: function vectorSquare() {
    return import('./assets/vector_square');
  },
  videoPlayer: function videoPlayer() {
    return import('./assets/video_player');
  },
  visArea: function visArea() {
    return import('./assets/chart_area');
  },
  // NOTE: To be deprecated in favor of chartArea
  visAreaStacked: function visAreaStacked() {
    return import('./assets/chart_area_stack');
  },
  // NOTE: To be deprecated in favor of chartAreaStack
  visBarHorizontal: function visBarHorizontal() {
    return import('./assets/chart_bar_horizontal');
  },
  // NOTE: To be deprecated in favor of chartBarHorizontal
  visBarHorizontalStacked: function visBarHorizontalStacked() {
    return import('./assets/chart_bar_horizontal_stack');
  },
  // NOTE: To be deprecated in favor of chartBarHorizontalStack
  visBarVertical: function visBarVertical() {
    return import('./assets/chart_bar_vertical');
  },
  // NOTE: To be deprecated in favor of chartBarVertical
  visBarVerticalStacked: function visBarVerticalStacked() {
    return import('./assets/chart_bar_vertical_stack');
  },
  // NOTE: To be deprecated in favor of chartBarVerticalStack
  visGauge: function visGauge() {
    return import('./assets/chart_gauge');
  },
  // NOTE: To be deprecated in favor of chartGauge
  visGoal: function visGoal() {
    return import('./assets/vis_goal');
  },
  visLine: function visLine() {
    return import('./assets/chart_line');
  },
  // NOTE: To be deprecated in favor of chartLine
  visMapCoordinate: function visMapCoordinate() {
    return import('./assets/waypoint');
  },
  // NOTE: To be deprecated in favor of waypoint
  visMapRegion: function visMapRegion() {
    return import('./assets/map');
  },
  // NOTE: To be deprecated in favor of map
  visMetric: function visMetric() {
    return import('./assets/chart_metric');
  },
  // NOTE: To be deprecated in favor of chartMetric
  chartMetric: function chartMetric() {
    return import('./assets/chart_metric');
  },
  visPie: function visPie() {
    return import('./assets/chart_pie');
  },
  // NOTE: To be deprecated in favor of chartPie
  visTable: function visTable() {
    return import('./assets/table');
  },
  // NOTE: To be deprecated in favor of table
  visTagCloud: function visTagCloud() {
    return import('./assets/chart_tag_cloud');
  },
  // NOTE: To be deprecated in favor of chartTagCloud
  visText: function visText() {
    return import('./assets/text');
  },
  // NOTE: To be deprecated in favor of text,
  visTimelion: function visTimelion() {
    return import('./assets/vis_timelion');
  },
  visVega: function visVega() {
    return import('./assets/code');
  },
  // NOTE: To be deprecated in favor of `code`
  visVisualBuilder: function visVisualBuilder() {
    return import('./assets/vis_visual_builder');
  },
  visualizeApp: function visualizeApp() {
    return import('./assets/app_visualize');
  },
  vulnerabilityManagementApp: function vulnerabilityManagementApp() {
    return import('./assets/app_vulnerability_management');
  },
  warning: function warning() {
    return import('./assets/warning');
  },
  warningFilled: function warningFilled() {
    return import('./assets/warning_fill');
  },
  // NOTE: To be deprecated in favor of warningFill
  warningFill: function warningFill() {
    return import('./assets/warning_fill');
  },
  watchesApp: function watchesApp() {
    return import('./assets/app_watches');
  },
  web: function web() {
    return import('./assets/web');
  },
  wordWrap: function wordWrap() {
    return import('./assets/word_wrap');
  },
  wordWrapDisabled: function wordWrapDisabled() {
    return import('./assets/word_wrap_disabled');
  },
  workflowsApp: function workflowsApp() {
    return import('./assets/app_workflows');
  },
  workflow: function workflow() {
    return import('./assets/workflow');
  },
  workplaceSearchApp: function workplaceSearchApp() {
    return import('./assets/app_workplace_search');
  },
  wrench: function wrench() {
    return import('./assets/wrench');
  },
  // Token Icon Imports
  tokenAlias: function tokenAlias() {
    return import('./assets/token_alias');
  },
  tokenAnnotation: function tokenAnnotation() {
    return import('./assets/token_annotation');
  },
  tokenArray: function tokenArray() {
    return import('./assets/token_array');
  },
  tokenBinary: function tokenBinary() {
    return import('./assets/token_binary');
  },
  tokenBoolean: function tokenBoolean() {
    return import('./assets/token_boolean');
  },
  tokenClass: function tokenClass() {
    return import('./assets/token_class');
  },
  tokenCompletionSuggester: function tokenCompletionSuggester() {
    return import('./assets/token_completion_suggester');
  },
  tokenConstant: function tokenConstant() {
    return import('./assets/token_constant');
  },
  tokenDate: function tokenDate() {
    return import('./assets/token_date');
  },
  tokenDimension: function tokenDimension() {
    return import('./assets/token_dimension');
  },
  tokenElement: function tokenElement() {
    return import('./assets/token_element');
  },
  tokenEnum: function tokenEnum() {
    return import('./assets/token_enum');
  },
  tokenEnumMember: function tokenEnumMember() {
    return import('./assets/token_enum_member');
  },
  tokenEvent: function tokenEvent() {
    return import('./assets/token_event');
  },
  tokenException: function tokenException() {
    return import('./assets/token_exception');
  },
  tokenField: function tokenField() {
    return import('./assets/token_field');
  },
  tokenFile: function tokenFile() {
    return import('./assets/token_file');
  },
  tokenFlattened: function tokenFlattened() {
    return import('./assets/token_flattened');
  },
  tokenFunction: function tokenFunction() {
    return import('./assets/token_function');
  },
  tokenGeo: function tokenGeo() {
    return import('./assets/token_geo');
  },
  tokenHistogram: function tokenHistogram() {
    return import('./assets/token_histogram');
  },
  tokenInterface: function tokenInterface() {
    return import('./assets/token_interface');
  },
  tokenIP: function tokenIP() {
    return import('./assets/token_ip');
  },
  tokenJoin: function tokenJoin() {
    return import('./assets/token_join');
  },
  tokenKey: function tokenKey() {
    return import('./assets/token_key');
  },
  tokenKeyword: function tokenKeyword() {
    return import('./assets/token_keyword');
  },
  tokenMethod: function tokenMethod() {
    return import('./assets/token_method');
  },
  tokenMetricCounter: function tokenMetricCounter() {
    return import('./assets/token_metric_counter');
  },
  tokenMetricGauge: function tokenMetricGauge() {
    return import('./assets/token_metric_gauge');
  },
  tokenModule: function tokenModule() {
    return import('./assets/token_module');
  },
  tokenNamespace: function tokenNamespace() {
    return import('./assets/token_namespace');
  },
  tokenNested: function tokenNested() {
    return import('./assets/token_nested');
  },
  tokenNull: function tokenNull() {
    return import('./assets/token_null');
  },
  tokenNumber: function tokenNumber() {
    return import('./assets/token_number');
  },
  tokenObject: function tokenObject() {
    return import('./assets/token_object');
  },
  tokenOperator: function tokenOperator() {
    return import('./assets/token_operator');
  },
  tokenPackage: function tokenPackage() {
    return import('./assets/token_package');
  },
  tokenParameter: function tokenParameter() {
    return import('./assets/token_parameter');
  },
  tokenPercolator: function tokenPercolator() {
    return import('./assets/token_percolator');
  },
  tokenProperty: function tokenProperty() {
    return import('./assets/token_property');
  },
  tokenRange: function tokenRange() {
    return import('./assets/token_range');
  },
  tokenRankFeature: function tokenRankFeature() {
    return import('./assets/token_rank_feature');
  },
  tokenRankFeatures: function tokenRankFeatures() {
    return import('./assets/token_rank_features');
  },
  tokenRepo: function tokenRepo() {
    return import('./assets/token_repo');
  },
  tokenSearchType: function tokenSearchType() {
    return import('./assets/token_search_type');
  },
  tokenSemanticText: function tokenSemanticText() {
    return import('./assets/token_semantic_text');
  },
  tokenShape: function tokenShape() {
    return import('./assets/token_shape');
  },
  tokenString: function tokenString() {
    return import('./assets/token_string');
  },
  tokenStruct: function tokenStruct() {
    return import('./assets/token_struct');
  },
  tokenSymbol: function tokenSymbol() {
    return import('./assets/token_symbol');
  },
  tokenTag: function tokenTag() {
    return import('./assets/token_tag');
  },
  tokenText: function tokenText() {
    return import('./assets/token_text');
  },
  tokenTokenCount: function tokenTokenCount() {
    return import('./assets/token_token_count');
  },
  tokenVariable: function tokenVariable() {
    return import('./assets/token_variable');
  },
  tokenVectorDense: function tokenVectorDense() {
    return import('./assets/token_vector_dense');
  },
  tokenDenseVector: function tokenDenseVector() {
    return import('./assets/token_vector_dense');
  },
  // NOTE: This is an undocumented alias for `tokenVectorDense`, added for legacy compatability
  tokenVectorSparse: function tokenVectorSparse() {
    return import('./assets/token_vector_sparse');
  }
};