@elastic/eui 112.2.0 → 112.3.0

package/optimize/es/components/icon/icon_map.js

@@ -7,834 +7,2183 @@
  */
 
 export var typeToPathMap = {
-  accessibility: 'accessibility',
-  addDataApp: 'app_add_data',
-  advancedSettingsApp: 'app_advanced_settings',
-  agentApp: 'app_fleet',
-  aggregate: 'aggregate',
-  alignBottom: 'align_bottom',
-  alignBottomLeft: 'align_bottom_left',
-  alignBottomRight: 'align_bottom_right',
-  alignCenterHorizontal: 'align_center_horizontal',
-  alignCenterVertical: 'align_center_vertical',
-  alignLeft: 'align_left',
-  alignRight: 'align_right',
-  alignTop: 'align_top',
-  alignTopLeft: 'align_top_left',
-  alignTopRight: 'align_top_right',
-  alert: 'warning',
+  accessibility: function accessibility() {
+    return import('./assets/accessibility');
+  },
+  addDataApp: function addDataApp() {
+    return import('./assets/app_add_data');
+  },
+  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: 'analyze_event',
-  annotation: 'annotation',
-  anomalyChart: 'chart_anomaly',
+  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: 'chart_anomaly',
-  anomalySwimLane: 'anomaly_swim_lane',
-  apmApp: 'app_apm',
-  apmTrace: 'chart_waterfall',
+  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: 'chart_waterfall',
-  appSearchApp: 'app_app_search',
-  apps: 'apps',
-  arrowDown: 'chevron_single_down',
+  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: 'chevron_single_down',
-  arrowLeft: 'chevron_single_left',
+  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: 'chevron_single_left',
-  arrowRight: 'chevron_single_right',
+  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: 'chevron_single_right',
-  arrowUp: 'chevron_single_up',
+  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: 'chevron_single_up',
-  arrowStart: 'chevron_limit_left',
+  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: 'chevron_limit_left',
-  arrowEnd: 'chevron_limit_right',
+  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: 'chevron_limit_right',
-  article: 'article',
-  asterisk: 'asterisk',
-  at: 'at',
-  archive: 'archive',
-  axisX: 'axis_x',
-  axisYLeft: 'axis_y_left',
-  axisYRight: 'axis_y_right',
-  auditbeatApp: 'app_auditbeat',
-  backgroundTask: 'background_task',
-  beaker: 'flask',
+  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: 'bell',
-  bellSlash: 'bell_slash',
-  beta: 'beta',
-  bolt: 'bolt',
-  boxesHorizontal: 'boxes_vertical',
+  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: 'boxes_vertical',
-  branch: 'branch',
-  briefcase: 'briefcase',
-  branchUser: 'branch_user',
-  broom: 'broom',
-  brush: 'brush',
-  bug: 'bug',
-  bulb: 'bulb',
-  bullseye: 'bullseye',
-  calendar: 'calendar',
-  canvasApp: 'app_canvas',
-  casesApp: 'app_cases',
-  changePointDetection: 'chart_change_point',
+  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: 'chart_change_point',
-  chartArea: 'chart_area',
-  chartAreaStack: 'chart_area_stack',
-  chartBarHorizontal: 'chart_bar_horizontal',
-  chartBarHorizontalStack: 'chart_bar_horizontal_stack',
-  chartBarVertical: 'chart_bar_vertical',
-  chartBarVerticalStack: 'chart_bar_vertical_stack',
-  chartGauge: 'chart_gauge',
-  chartHeatmap: 'chart_heatmap',
-  chartLine: 'chart_line',
-  chartPie: 'chart_pie',
-  chartTagCloud: 'chart_tag_cloud',
-  chartThreshold: 'chart_threshold',
-  check: 'check',
-  checkCircle: 'check_circle',
-  checkInCircleFilled: 'check_circle_fill',
+  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: 'check_circle_fill',
-  cheer: 'popper',
+  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: 'popper',
-  classificationJob: 'ml_classification_job',
-  clickLeft: 'click_left',
-  clickRight: 'click_right',
-  clock: 'clock',
-  clockCounter: 'clock_counter',
-  clockControl: 'clock_control',
-  cloud: 'cloud',
-  cloudDrizzle: 'cloud_drizzle',
-  cloudStormy: 'cloud_stormy',
-  cloudSunny: 'cloud_sunny',
-  cluster: 'cluster',
-  code: 'code',
-  codeApp: 'app_code',
-  color: 'paint_bucket',
+  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: 'paint_bucket',
-  commandLine: 'command_line',
-  comment: 'comment',
-  compare: 'compare',
-  compute: 'processor',
+  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: 'processor',
-  console: 'command_line',
+  processor: function processor() {
+    return import('./assets/processor');
+  },
+  console: function console() {
+    return import('./assets/command_line');
+  },
   // NOTE: To be deprecated in favor of commandLine
-  consoleApp: 'app_console',
-  container: 'container',
-  continuityAbove: 'continuity_above',
-  continuityAboveBelow: 'continuity_above_below',
-  continuityBelow: 'continuity_below',
-  continuityWithin: 'continuity_within',
-  contrast: 'contrast',
-  contrastHigh: 'contrast_fill',
+  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: 'contrast_fill',
-  controls: 'controls',
-  controlsHorizontal: 'controls',
+  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: 'controls',
+  controlsVertical: function controlsVertical() {
+    return import('./assets/controls');
+  },
   // NOTE: To be deprecated in favor of `controls`
-  copy: 'copy',
-  copyClipboard: 'copy',
+  copy: function copy() {
+    return import('./assets/copy');
+  },
+  copyClipboard: function copyClipboard() {
+    return import('./assets/copy');
+  },
   // NOTE: To be deprecated in favor of `copy`
-  crossProjectSearch: 'cross_project_search',
-  createAdvancedJob: 'ml_create_advanced_job',
-  createGenericJob: 'ml_create_generic_job',
-  createGeoJob: 'ml_create_geo_job',
-  createMultiMetricJob: 'ml_create_multi_metric_job',
-  createPopulationJob: 'ml_create_population_job',
-  createSingleMetricJob: 'ml_create_single_metric_job',
-  cross: 'cross',
-  crossClusterReplicationApp: 'app_cross_cluster_replication',
-  crossInCircle: 'cross_circle',
+  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: 'cross_circle',
-  crosshair: 'crosshair',
-  crosshairs: 'crosshair',
+  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: 'money',
+  currency: function currency() {
+    return import('./assets/money');
+  },
   // NOTE: To be deprecated in favor of money
-  money: 'money',
-  cut: 'scissors',
+  money: function money() {
+    return import('./assets/money');
+  },
+  cut: function cut() {
+    return import('./assets/scissors');
+  },
   // NOTE: To be deprecated in favor of scissors
-  scissors: 'scissors',
-  dashboardApp: 'app_dashboard',
-  dashedCircle: 'dashed_circle',
-  dataVisualizer: 'ml_data_visualizer',
-  database: 'database',
-  desktop: 'display',
+  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: 'display',
-  devToolsApp: 'app_devtools',
-  diff: 'compare',
+  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: 'app_discover',
-  distributeHorizontal: 'distribute_horizontal',
-  distributeVertical: 'distribute_vertical',
-  download: 'download',
-  drag: 'drag',
-  dragHorizontal: 'drag_horizontal',
-  dragVertical: 'drag_vertical',
-  discuss: 'comment',
+  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: 'document',
-  documentEdit: 'document_edit',
+  document: function document() {
+    return import('./assets/document');
+  },
+  documentEdit: function documentEdit() {
+    return import('./assets/document_edit');
+  },
   // NOTE: To be deprecated in favor of pencil
-  documentation: 'documentation',
-  documents: 'documents',
-  dot: 'dot',
-  dotInCircle: 'dot_in_circle',
-  doubleArrowLeft: 'chevron_double_left',
+  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: 'chevron_double_left',
-  doubleArrowRight: 'chevron_double_right',
+  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: 'chevron_double_right',
-  ellipsis: 'ellipsis',
-  editorAlignCenter: 'text_align_center',
+  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: 'text_align_center',
-  editorAlignLeft: 'text_align_left',
+  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: 'text_align_left',
-  editorAlignRight: 'text_align_right',
+  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: 'text_align_right',
-  editorBold: 'text_bold',
+  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: 'text_bold',
-  editorChecklist: 'list_check',
+  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: 'list_check',
-  editorCodeBlock: 'code',
+  listCheck: function listCheck() {
+    return import('./assets/list_check');
+  },
+  editorCodeBlock: function editorCodeBlock() {
+    return import('./assets/code');
+  },
   // NOTE: To be deprecated in favor of `code`
-  editorComment: 'comment',
+  editorComment: function editorComment() {
+    return import('./assets/comment');
+  },
   // NOTE: To be deprecated in favor of `comment`
-  editorDistributeHorizontal: 'editor_distribute_horizontal',
+  editorDistributeHorizontal: function editorDistributeHorizontal() {
+    return import('./assets/editor_distribute_horizontal');
+  },
   // NOTE: To be deprecated in favor of distributeHorizontal
-  editorDistributeVertical: 'editor_distribute_vertical',
+  editorDistributeVertical: function editorDistributeVertical() {
+    return import('./assets/editor_distribute_vertical');
+  },
   // NOTE: To be deprecated in favor of distributeVertical
-  editorHeading: 'text_heading',
+  editorHeading: function editorHeading() {
+    return import('./assets/text_heading');
+  },
   // NOTE: To be deprecated in favor of textHeading
-  textHeading: 'text_heading',
-  editorItalic: 'text_italic',
+  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: 'text_italic',
-  editorItemAlignBottom: 'editor_item_align_bottom',
+  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: 'editor_item_align_center',
+  editorItemAlignCenter: function editorItemAlignCenter() {
+    return import('./assets/editor_item_align_center');
+  },
   // NOTE: To be deprecated in favor of alignCenterHorizontal
-  editorItemAlignLeft: 'editor_item_align_left',
+  editorItemAlignLeft: function editorItemAlignLeft() {
+    return import('./assets/editor_item_align_left');
+  },
   // NOTE: To be deprecated in favor of alignLeft
-  editorItemAlignMiddle: 'editor_item_align_middle',
+  editorItemAlignMiddle: function editorItemAlignMiddle() {
+    return import('./assets/editor_item_align_middle');
+  },
   // NOTE: To be deprecated in favor of alignCenterVertical
-  editorItemAlignRight: 'editor_item_align_right',
+  editorItemAlignRight: function editorItemAlignRight() {
+    return import('./assets/editor_item_align_right');
+  },
   // NOTE: To be deprecated in favor of alignRight
-  editorItemAlignTop: 'editor_item_align_top',
+  editorItemAlignTop: function editorItemAlignTop() {
+    return import('./assets/editor_item_align_top');
+  },
   // NOTE: To be deprecated in favor of alignTop,
-  editorLink: 'link',
+  editorLink: function editorLink() {
+    return import('./assets/link');
+  },
   // NOTE: To be deprecated in favor of `link`
-  editorOrderedList: 'list_number',
+  editorOrderedList: function editorOrderedList() {
+    return import('./assets/list_number');
+  },
   // NOTE: To be deprecated in favor of listNumber
-  listNumber: 'list_number',
-  editorPositionBottomLeft: 'editor_position_bottom_left',
+  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: 'editor_position_bottom_right',
+  editorPositionBottomRight: function editorPositionBottomRight() {
+    return import('./assets/editor_position_bottom_right');
+  },
   // NOTE: To be deprecated in favor of alignBottomRight
-  editorPositionTopLeft: 'editor_position_top_left',
+  editorPositionTopLeft: function editorPositionTopLeft() {
+    return import('./assets/editor_position_top_left');
+  },
   // NOTE: To be deprecated in favor of alignTopLeft
-  editorPositionTopRight: 'editor_position_top_right',
+  editorPositionTopRight: function editorPositionTopRight() {
+    return import('./assets/editor_position_top_right');
+  },
   // NOTE: To be deprecated in favor of alignTopRight
-  editorRedo: 'redo',
+  editorRedo: function editorRedo() {
+    return import('./assets/redo');
+  },
   // NOTE: To be deprecated in favor of redo
-  redo: 'redo',
-  editorStrike: 'text_strike',
+  redo: function redo() {
+    return import('./assets/redo');
+  },
+  editorStrike: function editorStrike() {
+    return import('./assets/text_strike');
+  },
   // NOTE: To be deprecated in favor of textStrike
-  textStrike: 'text_strike',
-  editorTable: 'table',
+  textStrike: function textStrike() {
+    return import('./assets/text_strike');
+  },
+  editorTable: function editorTable() {
+    return import('./assets/table');
+  },
   // NOTE: To be deprecated in favor of table
-  table: 'table',
-  editorUnderline: 'text_underline',
+  table: function table() {
+    return import('./assets/table');
+  },
+  editorUnderline: function editorUnderline() {
+    return import('./assets/text_underline');
+  },
   // NOTE: To be deprecated in favor of textUnderline
-  textUnderline: 'text_underline',
-  editorUndo: 'undo',
+  textUnderline: function textUnderline() {
+    return import('./assets/text_underline');
+  },
+  editorUndo: function editorUndo() {
+    return import('./assets/undo');
+  },
   // NOTE: To be deprecated in favor of undo
-  undo: 'undo',
-  editorUnorderedList: 'list_bullet',
+  undo: function undo() {
+    return import('./assets/undo');
+  },
+  editorUnorderedList: function editorUnorderedList() {
+    return import('./assets/list_bullet');
+  },
   // NOTE: To be deprecated in favor of listBullet
-  listBullet: 'list_bullet',
-  email: 'mail',
+  listBullet: function listBullet() {
+    return import('./assets/list_bullet');
+  },
+  email: function email() {
+    return import('./assets/mail');
+  },
   // NOTE: To be deprecated in favor of mail
-  mail: 'mail',
-  empty: 'empty',
-  emsApp: 'app_ems',
-  endpoint: 'endpoint',
-  eql: 'query',
+  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: 'query',
-  eraser: 'eraser',
-  error: 'error',
-  errorFilled: 'error_fill',
+  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: 'error_fill',
-  esqlVis: 'esql_vis',
-  exit: 'log_out',
+  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: 'log_out',
-  expand: 'maximize',
+  logOut: function logOut() {
+    return import('./assets/log_out');
+  },
+  expand: function expand() {
+    return import('./assets/maximize');
+  },
   // NOTE: To be deprecated in favor of maximize
-  maximize: 'maximize',
-  expandMini: 'maximize',
+  maximize: function maximize() {
+    return import('./assets/maximize');
+  },
+  expandMini: function expandMini() {
+    return import('./assets/maximize');
+  },
   // NOTE: To be deprecated in favor of maximize
-  export: 'upload',
-  exportAction: 'upload',
+  export: function _export() {
+    return import('./assets/upload');
+  },
+  exportAction: function exportAction() {
+    return import('./assets/upload');
+  },
   // NOTE: To be deprecated in favor of upload
-  upload: 'upload',
-  external: 'external',
-  eye: 'eye',
-  eyeClosed: 'eye_slash',
+  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: 'eye_slash',
-  faceHappy: 'face_happy',
-  faceNeutral: 'face_neutral',
-  faceSad: 'face_sad',
-  fieldStatistics: 'table_info',
+  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: 'table_info',
-  filebeatApp: 'app_filebeat',
-  filter: 'filter',
-  filterExclude: 'filter_exclude',
-  filterIgnore: 'filter_ignore',
-  filterInclude: 'filter_include',
-  filterInCircle: 'filter_in_circle',
+  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: 'flask',
-  flag: 'flag',
-  fleetApp: 'app_agent',
-  fold: 'fold',
-  folder: 'folder_close',
-  folderClosed: 'folder_close',
-  folderClose: 'folder_close',
-  folderCheck: 'folder_check',
-  folderExclamation: 'folder_exclamation',
-  folderOpen: 'folder_open',
-  folderOpened: 'folder_open',
-  frameNext: 'frame_next',
-  framePrevious: 'frame_previous',
-  fullScreen: 'full_screen',
-  fullScreenExit: 'full_screen_exit',
-  function: 'function',
-  gear: 'gear',
-  gisApp: 'app_gis',
-  glasses: 'read_only',
+  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: 'globe',
-  grab: 'drag_vertical',
+  globe: function globe() {
+    return import('./assets/globe');
+  },
+  grab: function grab() {
+    return import('./assets/drag_vertical');
+  },
   // NOTE: To be deprecated in favor of dragVertical
-  grabHorizontal: 'drag_horizontal',
+  grabHorizontal: function grabHorizontal() {
+    return import('./assets/drag_horizontal');
+  },
   // NOTE: To be deprecated in favor of dragHorizontal
-  grabOmnidirectional: 'grab_omnidirectional',
+  grabOmnidirectional: function grabOmnidirectional() {
+    return import('./assets/grab_omnidirectional');
+  },
   // NOTE: To be deprecated in favor of drag,
-  gradient: 'gradient',
-  graphApp: 'app_graph',
-  grid: 'grid',
-  grokApp: 'app_grok',
-  heart: 'heart',
-  heartbeatApp: 'app_heartbeat',
-  heatmap: 'chart_heatmap',
+  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: 'help',
+  help: function help() {
+    return import('./assets/help');
+  },
   // NOTE: Might be deprecated later (not recommended in Kibana)
-  home: 'home',
-  hourglass: 'hourglass',
-  if: 'if',
-  info: 'info',
-  image: 'image',
-  importAction: 'download',
+  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: 'index',
-  indexClose: 'index_close',
-  indexEdit: 'index_edit',
-  indexFlush: 'chart_threshold',
+  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: 'app_index_management',
-  indexMapping: 'mapping',
+  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: 'mapping',
-  indexOpen: 'index_open',
-  indexPatternApp: 'app_index_pattern',
-  indexRollupApp: 'app_index_rollup',
-  indexRuntime: 'index_runtime',
-  indexSettings: 'index_settings',
-  indexTemporary: 'table_time',
+  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: 'table_time',
-  infinity: 'infinity',
-  inputOutput: 'input_output',
-  inspect: 'inspect',
-  invert: 'contrast',
+  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: 'ip',
-  key: 'key',
-  keyboard: 'keyboard',
-  kqlField: 'query_field',
+  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: 'query_field',
-  kqlFunction: 'kql_function',
-  kqlOperand: 'query_operand',
+  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: 'query_operand',
-  kqlSelector: 'query_selector',
+  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: 'query_selector',
-  kqlValue: 'query_value',
+  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: 'query_value',
-  kubernetesNode: 'kubernetes_node',
-  kubernetesPod: 'kubernetes_pod',
-  launch: 'rocket',
+  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: 'rocket',
-  layers: 'layers',
-  lensApp: 'app_lens',
-  lettering: 'text',
+  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: 'text',
-  lineBreak: 'line_break',
-  lineBreakSlash: 'line_break_slash',
-  lineDash: 'line_dash',
-  lineDashed: 'line_dash',
+  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: 'line_dot',
-  lineDotted: 'line_dot',
+  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: 'line_solid',
-  link: 'link',
-  linkSlash: 'link_slash',
-  list: 'list_bullet',
+  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: 'plus_circle',
+  listAdd: function listAdd() {
+    return import('./assets/plus_circle');
+  },
   // NOTE: To be deprecated in favor of `plus_circle`
-  lock: 'lock',
-  lockOpen: 'lock_open',
-  logPatternAnalysis: 'pattern',
+  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: 'pattern',
-  logRateAnalysis: 'log_rate_analysis',
-  logoAWS: 'logo_aws',
-  logoAWSMono: 'logo_aws_mono',
-  logoAerospike: 'logo_aerospike',
-  logoApache: 'logo_apache',
-  logoAppSearch: 'logo_app_search',
-  logoAzure: 'logo_azure',
-  logoAzureMono: 'logo_azure_mono',
-  logoBeats: 'logo_beats',
-  logoBusinessAnalytics: 'logo_business_analytics',
-  logoCeph: 'logo_ceph',
-  logoCloud: 'logo_cloud',
-  logoCloudEnterprise: 'logo_cloud_ece',
-  logoCode: 'logo_code',
-  logoCodesandbox: 'logo_codesandbox',
-  logoCouchbase: 'logo_couchbase',
-  logoDocker: 'logo_docker',
-  logoDropwizard: 'logo_dropwizard',
-  logoElastic: 'logo_elastic',
-  logoElasticStack: 'logo_elastic_stack',
-  logoElasticsearch: 'logo_elasticsearch',
-  logoEnterpriseSearch: 'logo_enterprise_search',
-  logoEtcd: 'logo_etcd',
-  logoGCP: 'logo_gcp',
-  logoGCPMono: 'logo_gcp_mono',
-  logoGithub: 'logo_github',
-  logoGmail: 'logo_gmail',
-  logoGolang: 'logo_golang',
-  logoGoogleG: 'logo_google_g',
-  logoHAproxy: 'logo_haproxy',
-  logoIBM: 'logo_ibm',
-  logoIBMMono: 'logo_ibm_mono',
-  logoKafka: 'logo_kafka',
-  logoKibana: 'logo_kibana',
-  logoKubernetes: 'logo_kubernetes',
-  logoLogging: 'logo_logging',
-  logoLogstash: 'logo_logstash',
-  logoMaps: 'logo_maps',
-  logoMemcached: 'logo_memcached',
-  logoMetrics: 'logo_metrics',
-  logoMongodb: 'logo_mongodb',
-  logoMySQL: 'logo_mysql',
-  logoNginx: 'logo_nginx',
-  logoObservability: 'logo_observability',
-  logoOsquery: 'logo_osquery',
-  logoPhp: 'logo_php',
-  logoPostgres: 'logo_postgres',
-  logoPrometheus: 'logo_prometheus',
-  logoRabbitmq: 'logo_rabbitmq',
-  logoRedis: 'logo_redis',
-  logoSecurity: 'logo_security',
-  logoSiteSearch: 'logo_site_search',
-  logoSketch: 'logo_sketch',
-  logoSlack: 'logo_slack',
-  logoUptime: 'logo_uptime',
-  logoVulnerabilityManagement: 'logo_vulnerability_management',
-  logoWebhook: 'logo_webhook',
-  logoWindows: 'logo_windows',
-  logoWorkplaceSearch: 'logo_workplace_search',
-  logsApp: 'app_logs',
-  logstashFilter: 'logstash_filter',
-  logstashIf: 'if',
+  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: 'logstash_input',
-  logstashOutput: 'logstash_output',
-  logstashQueue: 'queue',
+  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: 'queue',
-  machineLearningApp: 'app_ml',
-  magnet: 'magnet',
-  magnify: 'magnify',
-  magnifyExclamation: 'magnify_exclamation',
-  magnifyMinus: 'magnify_minus',
-  magnifyPlus: 'magnify_plus',
-  magnifyWithExclamation: 'magnify_with_exclamation',
+  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: 'magnify_with_minus',
+  magnifyWithMinus: function magnifyWithMinus() {
+    return import('./assets/magnify_with_minus');
+  },
   // NOTE: To be deprecated in favor of magnifyMinus
-  magnifyWithPlus: 'magnify_with_plus',
+  magnifyWithPlus: function magnifyWithPlus() {
+    return import('./assets/magnify_with_plus');
+  },
   // NOTE: To be deprecated in favor of magnifyPlus,
-  managementApp: 'app_management',
-  map: 'map',
-  mapMarker: 'waypoint',
+  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: 'waypoint',
-  megaphone: 'megaphone',
-  memory: 'memory',
-  menu: 'menu',
-  menuDown: 'menu_down',
-  menuLeft: 'menu_left',
-  menuRight: 'menu_right',
-  menuUp: 'menu_up',
-  merge: 'merge',
-  metricbeatApp: 'app_metricbeat',
-  metricsApp: 'app_metrics',
-  minimize: 'minimize',
-  minus: 'minus',
-  minusCircle: 'minus_circle',
-  minusInCircle: 'minus_circle',
+  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: 'minus_circle',
+  minusInCircleFilled: function minusInCircleFilled() {
+    return import('./assets/minus_circle');
+  },
   // NOTE: To be deprecated in favor of minusCircle
-  minusInSquare: 'minus_square',
+  minusInSquare: function minusInSquare() {
+    return import('./assets/minus_square');
+  },
   // NOTE: To be deprecated in favor of minusSquare
-  minusSquare: 'minus_square',
-  mobile: 'mobile',
-  monitoringApp: 'app_monitoring',
-  moon: 'moon',
-  move: 'move',
-  namespace: 'namespace',
-  nested: 'nested',
-  newChat: 'plus_circle',
+  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: 'vector_triangle',
+  node: function node() {
+    return import('./assets/vector_triangle');
+  },
   // NOTE: To be deprecated in favor of vectorTriangle
-  vectorTriangle: 'vector_triangle',
-  notebookApp: 'app_notebook',
-  number: 'number',
-  offline: 'wifi_slash',
+  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: 'wifi_slash',
-  online: 'wifi',
+  wifiSlash: function wifiSlash() {
+    return import('./assets/wifi_slash');
+  },
+  online: function online() {
+    return import('./assets/wifi');
+  },
   // NOTE: To be deprecated in favor of wifi
-  wifi: 'wifi',
-  outlierDetectionJob: 'ml_outlier_detection_job',
-  package: 'package',
-  packetbeatApp: 'app_packetbeat',
-  pageSelect: 'page_select',
-  pagesSelect: 'pages_select',
-  palette: 'palette',
-  paperClip: 'paper_clip',
-  partial: 'partial',
-  pause: 'pause',
-  payment: 'payment',
-  pencil: 'pencil',
-  percent: 'percent',
-  pin: 'pin',
-  pinFill: 'pin_fill',
-  pinFilled: 'pin_fill',
+  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: 'line_break',
+  pipeBreaks: function pipeBreaks() {
+    return import('./assets/line_break');
+  },
   // NOTE: To be deprecated in favor of lineBreak
-  pipelineApp: 'app_pipeline',
-  pipeNoBreaks: 'line_break_slash',
+  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: 'pivot',
-  play: 'play',
-  playFilled: 'play_filled',
+  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: 'plugs',
-  plus: 'plus',
-  plusCircle: 'plus_circle',
-  plusInCircle: 'plus_circle',
+  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: 'plus_circle',
+  plusInCircleFilled: function plusInCircleFilled() {
+    return import('./assets/plus_circle');
+  },
   // NOTE: To be deprecated in favor of plusCircle
-  plusInSquare: 'plus_square',
+  plusInSquare: function plusInSquare() {
+    return import('./assets/plus_square');
+  },
   // NOTE: To be deprecated in favor of plusSquare
-  plusSquare: 'plus_square',
-  popout: 'external',
+  plusSquare: function plusSquare() {
+    return import('./assets/plus_square');
+  },
+  popout: function popout() {
+    return import('./assets/external');
+  },
   // NOTE: To be deprecated in favor of external
-  presentation: 'presentation',
-  productRobot: 'product_agent',
+  presentation: function presentation() {
+    return import('./assets/presentation');
+  },
+  productRobot: function productRobot() {
+    return import('./assets/product_agent');
+  },
   // NOTE: To be deprecated in favor of productAgent
-  productAgent: 'product_agent',
-  productCloudInfra: 'product_cloud_infra',
-  productDashboard: 'product_dashboard',
-  productDiscover: 'product_discover',
-  productML: 'product_ml',
-  productStreamsClassic: 'product_streams_classic',
-  productStreamsWired: 'product_streams_wired',
-  push: 'send',
+  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: 'send',
-  question: 'question',
-  quote: 'quote',
-  radar: 'radar',
-  readOnly: 'read_only',
-  recentlyViewedApp: 'app_recently_viewed',
-  refresh: 'refresh',
-  regressionJob: 'ml_regression_job',
-  reporter: 'reporter',
-  reportingApp: 'app_reporting',
-  return: 'return',
-  returnKey: 'return',
+  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: 'save',
-  savedObjectsApp: 'app_saved_objects',
-  scale: 'scale',
-  search: 'magnify',
+  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: 'app_search_profiler',
-  section: 'section',
-  securityAnalyticsApp: 'app_security_analytics',
-  securityApp: 'app_security',
-  securitySignal: 'security_signal',
+  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: 'security_signal_detected',
-  securitySignalResolved: 'security_signal_resolved',
-  sessionViewer: 'session_viewer',
-  shard: 'shard',
-  share: 'share',
-  singleMetricViewer: 'single_metric_viewer',
-  snowflake: 'snowflake',
-  sortAscending: 'sort_ascending',
-  sortDescending: 'sort_descending',
-  sortDown: 'sort_down',
-  sortLeft: 'sort_left',
-  sortRight: 'sort_right',
-  sortUp: 'sort_up',
-  sortable: 'sortable',
-  spaces: 'spaces',
-  spacesApp: 'app_spaces',
-  sparkles: 'sparkles',
-  sqlApp: 'app_sql',
-  star: 'star',
-  starEmpty: 'star',
+  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: 'star_empty_space',
-  starFill: 'star_fill',
-  starFilled: 'star_fill',
+  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: 'star_fill_space',
-  starFilledSpace: 'star_fill_space',
+  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: 'star_minus_empty',
-  starMinusFill: 'star_minus_fill',
-  starMinusFilled: 'star_minus_fill',
+  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: 'star_plus_empty',
-  starPlusFill: 'star_plus_fill',
-  starPlusFilled: 'star_plus_fill',
+  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: 'stats',
-  stop: 'stop',
-  stopFill: 'stop_fill',
-  stopFilled: 'stop_fill',
+  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: 'stop_slash',
-  storage: 'storage',
-  streamsClassic: 'product_streams_classic',
+  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: 'product_streams_wired',
+  streamsWired: function streamsWired() {
+    return import('./assets/product_streams_wired');
+  },
   // NOTE: To be deprecated in favor of productStreamsWired
-  string: 'string',
-  submodule: 'merge',
+  string: function string() {
+    return import('./assets/string');
+  },
+  submodule: function submodule() {
+    return import('./assets/merge');
+  },
   // NOTE: To be deprecated in favor of `merge`
-  sun: 'sun',
-  swatchInput: 'swatch_input',
+  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: 'symlink',
-  tableDensityCompact: 'table_density_high',
+  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: 'table_density_high',
-  tableDensityExpanded: 'table_density_low',
+  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: 'table_density_low',
-  tableDensityNormal: 'table',
+  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: 'table_of_contents',
-  tag: 'tag',
-  tear: 'tear',
-  temperature: 'thermometer',
+  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: 'thermometer',
-  thumbDown: 'thumb_down',
-  thumbUp: 'thumb_up',
-  timeline: 'timeline',
-  timelineWithArrow: 'timeline_with_arrow',
-  timelionApp: 'app_timelion',
-  timeRefresh: 'refresh_time',
+  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: 'refresh_time',
-  timeslider: 'clock_control',
+  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: 'presentation',
+  training: function training() {
+    return import('./assets/presentation');
+  },
   // NOTE: To be deprecated in favor of presentation,
-  transitionLeftIn: 'transition_left_in',
-  transitionLeftOut: 'transition_left_out',
-  transitionTopIn: 'transition_top_in',
-  transitionTopOut: 'transition_top_out',
-  trash: 'trash',
-  unfold: 'unfold',
-  unlink: 'link_slash',
+  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: 'app_upgrade_assistant',
-  uptimeApp: 'app_uptime',
-  user: 'user',
-  userAvatar: 'user',
+  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: 'users',
-  usersRolesApp: 'app_users_roles',
-  unarchive: 'unarchive',
-  vector: 'vector_square',
+  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: 'vector_square',
-  videoPlayer: 'video_player',
-  visArea: 'chart_area',
+  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: 'chart_area_stack',
+  visAreaStacked: function visAreaStacked() {
+    return import('./assets/chart_area_stack');
+  },
   // NOTE: To be deprecated in favor of chartAreaStack
-  visBarHorizontal: 'chart_bar_horizontal',
+  visBarHorizontal: function visBarHorizontal() {
+    return import('./assets/chart_bar_horizontal');
+  },
   // NOTE: To be deprecated in favor of chartBarHorizontal
-  visBarHorizontalStacked: 'chart_bar_horizontal_stack',
+  visBarHorizontalStacked: function visBarHorizontalStacked() {
+    return import('./assets/chart_bar_horizontal_stack');
+  },
   // NOTE: To be deprecated in favor of chartBarHorizontalStack
-  visBarVertical: 'chart_bar_vertical',
+  visBarVertical: function visBarVertical() {
+    return import('./assets/chart_bar_vertical');
+  },
   // NOTE: To be deprecated in favor of chartBarVertical
-  visBarVerticalStacked: 'chart_bar_vertical_stack',
+  visBarVerticalStacked: function visBarVerticalStacked() {
+    return import('./assets/chart_bar_vertical_stack');
+  },
   // NOTE: To be deprecated in favor of chartBarVerticalStack
-  visGauge: 'chart_gauge',
+  visGauge: function visGauge() {
+    return import('./assets/chart_gauge');
+  },
   // NOTE: To be deprecated in favor of chartGauge
-  visGoal: 'vis_goal',
-  visLine: 'chart_line',
+  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: 'waypoint',
+  visMapCoordinate: function visMapCoordinate() {
+    return import('./assets/waypoint');
+  },
   // NOTE: To be deprecated in favor of waypoint
-  visMapRegion: 'map',
+  visMapRegion: function visMapRegion() {
+    return import('./assets/map');
+  },
   // NOTE: To be deprecated in favor of map
-  visMetric: 'chart_metric',
+  visMetric: function visMetric() {
+    return import('./assets/chart_metric');
+  },
   // NOTE: To be deprecated in favor of chartMetric
-  chartMetric: 'chart_metric',
-  visPie: 'chart_pie',
+  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: 'table',
+  visTable: function visTable() {
+    return import('./assets/table');
+  },
   // NOTE: To be deprecated in favor of table
-  visTagCloud: 'chart_tag_cloud',
+  visTagCloud: function visTagCloud() {
+    return import('./assets/chart_tag_cloud');
+  },
   // NOTE: To be deprecated in favor of chartTagCloud
-  visText: 'text',
+  visText: function visText() {
+    return import('./assets/text');
+  },
   // NOTE: To be deprecated in favor of text,
-  visTimelion: 'vis_timelion',
-  visVega: 'code',
+  visTimelion: function visTimelion() {
+    return import('./assets/vis_timelion');
+  },
+  visVega: function visVega() {
+    return import('./assets/code');
+  },
   // NOTE: To be deprecated in favor of `code`
-  visVisualBuilder: 'vis_visual_builder',
-  visualizeApp: 'app_visualize',
-  vulnerabilityManagementApp: 'app_vulnerability_management',
-  warning: 'warning',
-  warningFilled: 'warning_fill',
+  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: 'warning_fill',
-  watchesApp: 'app_watches',
-  web: 'web',
-  wordWrap: 'word_wrap',
-  wordWrapDisabled: 'word_wrap_disabled',
-  workflowsApp: 'app_workflows',
-  workflow: 'workflow',
-  workplaceSearchApp: 'app_workplace_search',
-  wrench: 'wrench',
+  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: 'token_alias',
-  tokenAnnotation: 'token_annotation',
-  tokenArray: 'token_array',
-  tokenBinary: 'token_binary',
-  tokenBoolean: 'token_boolean',
-  tokenClass: 'token_class',
-  tokenCompletionSuggester: 'token_completion_suggester',
-  tokenConstant: 'token_constant',
-  tokenDate: 'token_date',
-  tokenDimension: 'token_dimension',
-  tokenElement: 'token_element',
-  tokenEnum: 'token_enum',
-  tokenEnumMember: 'token_enum_member',
-  tokenEvent: 'token_event',
-  tokenException: 'token_exception',
-  tokenField: 'token_field',
-  tokenFile: 'token_file',
-  tokenFlattened: 'token_flattened',
-  tokenFunction: 'token_function',
-  tokenGeo: 'token_geo',
-  tokenHistogram: 'token_histogram',
-  tokenInterface: 'token_interface',
-  tokenIP: 'token_ip',
-  tokenJoin: 'token_join',
-  tokenKey: 'token_key',
-  tokenKeyword: 'token_keyword',
-  tokenMethod: 'token_method',
-  tokenMetricCounter: 'token_metric_counter',
-  tokenMetricGauge: 'token_metric_gauge',
-  tokenModule: 'token_module',
-  tokenNamespace: 'token_namespace',
-  tokenNested: 'token_nested',
-  tokenNull: 'token_null',
-  tokenNumber: 'token_number',
-  tokenObject: 'token_object',
-  tokenOperator: 'token_operator',
-  tokenPackage: 'token_package',
-  tokenParameter: 'token_parameter',
-  tokenPercolator: 'token_percolator',
-  tokenProperty: 'token_property',
-  tokenRange: 'token_range',
-  tokenRankFeature: 'token_rank_feature',
-  tokenRankFeatures: 'token_rank_features',
-  tokenRepo: 'token_repo',
-  tokenSearchType: 'token_search_type',
-  tokenSemanticText: 'token_semantic_text',
-  tokenShape: 'token_shape',
-  tokenString: 'token_string',
-  tokenStruct: 'token_struct',
-  tokenSymbol: 'token_symbol',
-  tokenTag: 'token_tag',
-  tokenText: 'token_text',
-  tokenTokenCount: 'token_token_count',
-  tokenVariable: 'token_variable',
-  tokenVectorDense: 'token_vector_dense',
-  tokenDenseVector: 'token_vector_dense',
+  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: 'token_vector_sparse'
+  tokenVectorSparse: function tokenVectorSparse() {
+    return import('./assets/token_vector_sparse');
+  }
 };