@elastic/eui 116.5.0 → 117.0.0-snapshot.1783954480414

package/es/components/icon/icon_map.js

@@ -1,3 +1,9 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 /*
  * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
  * or more contributor license agreements. Licensed under the Elastic License
@@ -6,55 +12,96 @@
  * Side Public License, v 1.
  */
 
+var withMetadata = function withMetadata(loader) {
+  var metadata = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return Object.assign(loader, {
+    metadata: metadata
+  });
+};
 export var typeToPathMap = {
-  accessibility: function accessibility() {
+  accessibility: withMetadata(function () {
     return import('./assets/accessibility');
-  },
-  addDataApp: function addDataApp() {
+  }, {
+    synonyms: ['a11y', 'inclusive', 'disability', 'wcag', 'assistive', 'screen reader', 'universal design']
+  }),
+  addDataApp: withMetadata(function () {
     return import('./assets/app_add_data');
+  }, {
+    category: 'app'
+  }),
+  addToChat: function addToChat() {
+    return import('./assets/add_to_chat');
   },
-  addToDashboard: function addToDashboard() {
+  addToDashboard: withMetadata(function () {
     return import('./assets/add_to_dashboard');
-  },
-  advancedSettingsApp: function advancedSettingsApp() {
+  }, {
+    synonyms: ['dashboard', 'add', 'pin', 'widget', 'panel', 'insert', 'save view']
+  }),
+  advancedSettingsApp: withMetadata(function () {
     return import('./assets/app_advanced_settings');
-  },
-  agentApp: function agentApp() {
+  }, {
+    category: 'app'
+  }),
+  agentApp: withMetadata(function () {
     return import('./assets/app_fleet');
-  },
-  aggregate: function aggregate() {
+  }, {
+    category: 'app'
+  }),
+  aggregate: withMetadata(function () {
     return import('./assets/aggregate');
-  },
-  alignBottom: function alignBottom() {
+  }, {
+    synonyms: ['combine', 'sum', 'group', 'collection', 'merge', 'total', 'rollup']
+  }),
+  alignBottom: withMetadata(function () {
     return import('./assets/align_bottom');
-  },
-  alignBottomLeft: function alignBottomLeft() {
+  }, {
+    synonyms: ['align', 'bottom', 'vertical', 'position', 'layout', 'dock']
+  }),
+  alignBottomLeft: withMetadata(function () {
     return import('./assets/align_bottom_left');
-  },
-  alignBottomRight: function alignBottomRight() {
+  }, {
+    synonyms: ['align', 'bottom', 'left', 'corner', 'position', 'layout']
+  }),
+  alignBottomRight: withMetadata(function () {
     return import('./assets/align_bottom_right');
-  },
-  alignCenterHorizontal: function alignCenterHorizontal() {
+  }, {
+    synonyms: ['align', 'bottom', 'right', 'corner', 'position', 'layout']
+  }),
+  alignCenterHorizontal: withMetadata(function () {
     return import('./assets/align_center_horizontal');
-  },
-  alignCenterVertical: function alignCenterVertical() {
+  }, {
+    synonyms: ['align', 'center', 'horizontal', 'middle', 'position', 'layout']
+  }),
+  alignCenterVertical: withMetadata(function () {
     return import('./assets/align_center_vertical');
-  },
-  alignLeft: function alignLeft() {
+  }, {
+    synonyms: ['align', 'center', 'vertical', 'middle', 'position', 'layout']
+  }),
+  alignLeft: withMetadata(function () {
     return import('./assets/align_left');
-  },
-  alignRight: function alignRight() {
+  }, {
+    synonyms: ['align', 'left', 'horizontal', 'position', 'layout', 'flush']
+  }),
+  alignRight: withMetadata(function () {
     return import('./assets/align_right');
-  },
-  alignTop: function alignTop() {
+  }, {
+    synonyms: ['align', 'right', 'horizontal', 'position', 'layout', 'flush']
+  }),
+  alignTop: withMetadata(function () {
     return import('./assets/align_top');
-  },
-  alignTopLeft: function alignTopLeft() {
+  }, {
+    synonyms: ['align', 'top', 'vertical', 'position', 'layout', 'dock']
+  }),
+  alignTopLeft: withMetadata(function () {
     return import('./assets/align_top_left');
-  },
-  alignTopRight: function alignTopRight() {
+  }, {
+    synonyms: ['align', 'top', 'left', 'corner', 'position', 'layout']
+  }),
+  alignTopRight: withMetadata(function () {
     return import('./assets/align_top_right');
-  },
+  }, {
+    synonyms: ['align', 'top', 'right', 'corner', 'position', 'layout']
+  }),
   alert: function alert() {
     return import('./assets/warning');
   },
@@ -69,25 +116,33 @@ export var typeToPathMap = {
     return import('./assets/chart_anomaly');
   },
   // NOTE: To be deprecated in favor of chartAnomaly
-  chartAnomaly: function chartAnomaly() {
+  chartAnomaly: withMetadata(function () {
     return import('./assets/chart_anomaly');
-  },
+  }, {
+    synonyms: ['anomaly', 'chart', 'outlier', 'detection', 'spike', 'unusual']
+  }),
   anomalySwimLane: function anomalySwimLane() {
     return import('./assets/anomaly_swim_lane');
   },
-  apmApp: function apmApp() {
+  apmApp: withMetadata(function () {
     return import('./assets/app_apm');
-  },
+  }, {
+    category: 'app'
+  }),
   apmTrace: function apmTrace() {
     return import('./assets/chart_waterfall');
   },
   // NOTE: To be deprecated in favor of chartWaterfall
-  chartWaterfall: function chartWaterfall() {
+  chartWaterfall: withMetadata(function () {
     return import('./assets/chart_waterfall');
-  },
-  appSearchApp: function appSearchApp() {
+  }, {
+    synonyms: ['waterfall chart', 'cascade', 'steps', 'bridge', 'cumulative', 'breakdown']
+  }),
+  appSearchApp: withMetadata(function () {
     return import('./assets/app_app_search');
-  },
+  }, {
+    category: 'app'
+  }),
   apps: function apps() {
     return import('./assets/apps');
   },
@@ -95,87 +150,123 @@ export var typeToPathMap = {
     return import('./assets/chevron_single_down');
   },
   // NOTE: To be deprecated in favor of chevronSingleDown
-  chevronSingleDown: function chevronSingleDown() {
+  chevronSingleDown: withMetadata(function () {
     return import('./assets/chevron_single_down');
-  },
+  }, {
+    synonyms: ['chevron', 'down', 'dropdown', 'expand', 'arrow', 'caret']
+  }),
   arrowLeft: function arrowLeft() {
     return import('./assets/chevron_single_left');
   },
   // NOTE: To be deprecated in favor of chevronSingleLeft
-  chevronSingleLeft: function chevronSingleLeft() {
+  chevronSingleLeft: withMetadata(function () {
     return import('./assets/chevron_single_left');
-  },
+  }, {
+    synonyms: ['chevron', 'left', 'back', 'previous', 'arrow', 'caret']
+  }),
   arrowRight: function arrowRight() {
     return import('./assets/chevron_single_right');
   },
-  // NOTE: To be deprecated in favor of chevronSinglRight
-  chevronSingleRight: function chevronSingleRight() {
+  // NOTE: To be deprecated in favor of chevronSingleRight
+  chevronSingleRight: withMetadata(function () {
     return import('./assets/chevron_single_right');
-  },
+  }, {
+    synonyms: ['chevron', 'right', 'next', 'forward', 'arrow', 'caret']
+  }),
   arrowUp: function arrowUp() {
     return import('./assets/chevron_single_up');
   },
   // NOTE: To be deprecated in favor of chevronSingleUp
-  chevronSingleUp: function chevronSingleUp() {
+  chevronSingleUp: withMetadata(function () {
     return import('./assets/chevron_single_up');
-  },
+  }, {
+    synonyms: ['chevron', 'up', 'collapse', 'arrow', 'caret']
+  }),
   arrowStart: function arrowStart() {
     return import('./assets/chevron_limit_left');
   },
   // NOTE: To be deprecated in favor of chevronLimitLeft
-  chevronLimitLeft: function chevronLimitLeft() {
+  chevronLimitLeft: withMetadata(function () {
     return import('./assets/chevron_limit_left');
-  },
+  }, {
+    synonyms: ['chevron', 'limit', 'first', 'start', 'beginning', 'jump', 'skip']
+  }),
   arrowEnd: function arrowEnd() {
     return import('./assets/chevron_limit_right');
   },
   // NOTE: To be deprecated in favor of chevronLimitRight
-  chevronLimitRight: function chevronLimitRight() {
+  chevronLimitRight: withMetadata(function () {
     return import('./assets/chevron_limit_right');
-  },
+  }, {
+    synonyms: ['chevron', 'limit', 'last', 'end', 'final', 'jump', 'skip']
+  }),
   article: function article() {
     return import('./assets/article');
   },
-  asterisk: function asterisk() {
+  asterisk: withMetadata(function () {
     return import('./assets/asterisk');
-  },
-  at: function at() {
+  }, {
+    synonyms: ['star', 'wildcard', 'required', 'multiply', 'reference', 'footnote']
+  }),
+  at: withMetadata(function () {
     return import('./assets/at');
-  },
-  archive: function archive() {
+  }, {
+    synonyms: ['email', 'mention', 'address', 'symbol', 'contact', 'handle']
+  }),
+  archive: withMetadata(function () {
     return import('./assets/archive');
-  },
-  axisX: function axisX() {
+  }, {
+    synonyms: ['storage', 'box', 'store', 'backup', 'file away', 'saved', 'repository']
+  }),
+  axisX: withMetadata(function () {
     return import('./assets/axis_x');
-  },
-  axisYLeft: function axisYLeft() {
+  }, {
+    synonyms: ['x axis', 'horizontal axis', 'chart', 'graph', 'dimension', 'abscissa']
+  }),
+  axisYLeft: withMetadata(function () {
     return import('./assets/axis_y_left');
-  },
-  axisYRight: function axisYRight() {
+  }, {
+    synonyms: ['y axis', 'left', 'vertical axis', 'chart', 'graph', 'ordinate']
+  }),
+  axisYRight: withMetadata(function () {
     return import('./assets/axis_y_right');
-  },
-  auditbeatApp: function auditbeatApp() {
+  }, {
+    synonyms: ['y axis', 'right', 'vertical axis', 'chart', 'graph', 'ordinate']
+  }),
+  auditbeatApp: withMetadata(function () {
     return import('./assets/app_auditbeat');
-  },
-  backgroundTask: function backgroundTask() {
+  }, {
+    category: 'app'
+  }),
+  backgroundTask: withMetadata(function () {
     return import('./assets/background_task');
-  },
+  }, {
+    synonyms: ['background', 'async', 'job', 'task', 'process', 'worker', 'queue']
+  }),
   beaker: function beaker() {
     return import('./assets/flask');
   },
   // NOTE: To be deprecated in favor of `flask`
-  bell: function bell() {
+  bell: withMetadata(function () {
     return import('./assets/bell');
-  },
-  bellSlash: function bellSlash() {
+  }, {
+    synonyms: ['notification', 'alert', 'alarm', 'notify', 'ring', 'reminder', 'announcements']
+  }),
+  bellSlash: withMetadata(function () {
     return import('./assets/bell_slash');
-  },
-  beta: function beta() {
+  }, {
+    synonyms: ['mute', 'notification off', 'silence', 'bell disabled', 'alerts off', 'quiet']
+  }),
+  beta: withMetadata(function () {
     return import('./assets/beta');
-  },
-  bolt: function bolt() {
+  }, {
+    synonyms: ['greek', 'test', 'experimental', 'preview', 'version', 'letter']
+  }),
+  bolt: withMetadata(function () {
     return import('./assets/bolt');
-  },
+  }, {
+    synonyms: ['lightning', 'fast', 'power', 'electric', 'speed', 'energy']
+  }),
   boxesHorizontal: function boxesHorizontal() {
     return import('./assets/boxes_vertical');
   },
@@ -183,123 +274,191 @@ export var typeToPathMap = {
   boxesVertical: function boxesVertical() {
     return import('./assets/boxes_vertical');
   },
-  branch: function branch() {
+  branch: withMetadata(function () {
     return import('./assets/branch');
-  },
-  briefcase: function briefcase() {
+  }, {
+    synonyms: ['git', 'version control', 'fork', 'tree', 'split', 'divergence']
+  }),
+  briefcase: withMetadata(function () {
     return import('./assets/briefcase');
-  },
+  }, {
+    synonyms: ['work', 'business', 'job', 'portfolio', 'office', 'career']
+  }),
   branchUser: function branchUser() {
     return import('./assets/branch_user');
   },
-  broom: function broom() {
+  broom: withMetadata(function () {
     return import('./assets/broom');
-  },
-  brush: function brush() {
+  }, {
+    synonyms: ['clean', 'sweep', 'clear', 'tidy', 'wipe', 'brush off']
+  }),
+  brush: withMetadata(function () {
     return import('./assets/brush');
-  },
-  bug: function bug() {
+  }, {
+    synonyms: ['paint', 'draw', 'art', 'design', 'stroke', 'brush tool']
+  }),
+  bug: withMetadata(function () {
     return import('./assets/bug');
-  },
-  bulb: function bulb() {
+  }, {
+    synonyms: ['insect', 'defect', 'issue', 'error', 'debug', 'glitch']
+  }),
+  bulb: withMetadata(function () {
     return import('./assets/bulb');
-  },
-  bullseye: function bullseye() {
+  }, {
+    synonyms: ['light', 'idea', 'lamp', 'insight', 'bright', 'hint']
+  }),
+  bullseye: withMetadata(function () {
     return import('./assets/bullseye');
-  },
-  calendar: function calendar() {
+  }, {
+    synonyms: ['findings', 'target', 'aim', 'goal', 'focus', 'dartboard', 'precision', 'center']
+  }),
+  calendar: withMetadata(function () {
     return import('./assets/calendar');
-  },
-  canvasApp: function canvasApp() {
+  }, {
+    synonyms: ['date', 'schedule', 'event', 'day', 'month', 'time']
+  }),
+  canvasApp: withMetadata(function () {
     return import('./assets/app_canvas');
-  },
-  casesApp: function casesApp() {
+  }, {
+    category: 'app'
+  }),
+  casesApp: withMetadata(function () {
     return import('./assets/app_cases');
-  },
+  }, {
+    category: 'app'
+  }),
   changePointDetection: function changePointDetection() {
     return import('./assets/chart_change_point');
   },
   // NOTE: To be deprecated in favor of chartChangePoint
-  chartChangePoint: function chartChangePoint() {
+  chartChangePoint: withMetadata(function () {
     return import('./assets/chart_change_point');
-  },
-  chartArea: function chartArea() {
+  }, {
+    synonyms: ['change point', 'chart', 'breakpoint', 'shift', 'detection', 'regime']
+  }),
+  chartArea: withMetadata(function () {
     return import('./assets/chart_area');
-  },
-  chartAreaStack: function chartAreaStack() {
+  }, {
+    synonyms: ['area chart', 'graph', 'visualization', 'filled', 'trend', 'plot']
+  }),
+  chartAreaStack: withMetadata(function () {
     return import('./assets/chart_area_stack');
-  },
-  chartBarHorizontal: function chartBarHorizontal() {
+  }, {
+    synonyms: ['stacked area', 'chart', 'graph', 'layers', 'visualization', 'plot']
+  }),
+  chartBarHorizontal: withMetadata(function () {
     return import('./assets/chart_bar_horizontal');
-  },
-  chartBarHorizontalStack: function chartBarHorizontalStack() {
+  }, {
+    synonyms: ['bar chart', 'horizontal', 'graph', 'bars', 'visualization', 'plot']
+  }),
+  chartBarHorizontalStack: withMetadata(function () {
     return import('./assets/chart_bar_horizontal_stack');
-  },
-  chartBarVertical: function chartBarVertical() {
+  }, {
+    synonyms: ['stacked bar', 'horizontal', 'chart', 'graph', 'grouped', 'plot']
+  }),
+  chartBarVertical: withMetadata(function () {
     return import('./assets/chart_bar_vertical');
-  },
-  chartBarVerticalStack: function chartBarVerticalStack() {
+  }, {
+    synonyms: ['bar chart', 'vertical', 'graph', 'columns', 'visualization', 'plot']
+  }),
+  chartBarVerticalStack: withMetadata(function () {
     return import('./assets/chart_bar_vertical_stack');
-  },
-  chartGauge: function chartGauge() {
+  }, {
+    synonyms: ['stacked bar', 'vertical', 'chart', 'graph', 'grouped', 'plot']
+  }),
+  chartGauge: withMetadata(function () {
     return import('./assets/chart_gauge');
-  },
-  chartHeatmap: function chartHeatmap() {
+  }, {
+    synonyms: ['gauge', 'meter', 'dial', 'chart', 'metric', 'speedometer']
+  }),
+  chartHeatmap: withMetadata(function () {
     return import('./assets/chart_heatmap');
-  },
-  chartLine: function chartLine() {
+  }, {
+    synonyms: ['heatmap', 'matrix', 'density', 'chart', 'grid', 'correlation']
+  }),
+  chartLine: withMetadata(function () {
     return import('./assets/chart_line');
-  },
-  chartPie: function chartPie() {
+  }, {
+    synonyms: ['line chart', 'graph', 'trend', 'visualization', 'plot', 'time series']
+  }),
+  chartPie: withMetadata(function () {
     return import('./assets/chart_pie');
-  },
-  chartTagCloud: function chartTagCloud() {
+  }, {
+    synonyms: ['pie chart', 'donut', 'proportion', 'circle', 'segments', 'share']
+  }),
+  chartTagCloud: withMetadata(function () {
     return import('./assets/chart_tag_cloud');
-  },
-  chartThreshold: function chartThreshold() {
+  }, {
+    synonyms: ['tag cloud', 'word cloud', 'text', 'chart', 'keywords', 'frequency']
+  }),
+  chartThreshold: withMetadata(function () {
     return import('./assets/chart_threshold');
-  },
-  check: function check() {
+  }, {
+    synonyms: ['threshold', 'limit', 'chart', 'boundary', 'alert line', 'cutoff']
+  }),
+  check: withMetadata(function () {
     return import('./assets/check');
-  },
-  checkCircle: function checkCircle() {
+  }, {
+    synonyms: ['tick', 'confirm', 'done', 'yes', 'approve', 'mark']
+  }),
+  checkCircle: withMetadata(function () {
     return import('./assets/check_circle');
-  },
+  }, {
+    synonyms: ['check', 'circle', 'success', 'confirm', 'complete', 'ok']
+  }),
   checkInCircleFilled: function checkInCircleFilled() {
     return import('./assets/check_circle_fill');
   },
   // NOTE: To be deprecated in favor of checkCircleFill
-  checkCircleFill: function checkCircleFill() {
+  checkCircleFill: withMetadata(function () {
     return import('./assets/check_circle_fill');
-  },
+  }, {
+    synonyms: ['check', 'filled', 'success', 'confirm', 'complete', 'ok']
+  }),
   cheer: function cheer() {
     return import('./assets/popper');
   },
   // NOTE: To be deprecated in favor of popper
-  popper: function popper() {
+  popper: withMetadata(function () {
     return import('./assets/popper');
-  },
-  classificationJob: function classificationJob() {
+  }, {
+    synonyms: ['popper', 'tooltip', 'overlay', 'popup', 'floating']
+  }),
+  classificationJob: withMetadata(function () {
     return import('./assets/ml_classification_job');
-  },
-  clickLeft: function clickLeft() {
+  }, {
+    category: 'ml'
+  }),
+  clickLeft: withMetadata(function () {
     return import('./assets/click_left');
-  },
-  clickRight: function clickRight() {
+  }, {
+    synonyms: ['click', 'left', 'mouse', 'pointer', 'button', 'tap']
+  }),
+  clickRight: withMetadata(function () {
     return import('./assets/click_right');
-  },
-  clock: function clock() {
+  }, {
+    synonyms: ['click', 'right', 'mouse', 'context', 'button', 'tap']
+  }),
+  clock: withMetadata(function () {
     return import('./assets/clock');
-  },
-  clockCounter: function clockCounter() {
+  }, {
+    synonyms: ['clock']
+  }),
+  clockCounter: withMetadata(function () {
     return import('./assets/clock_counter');
-  },
-  clockControl: function clockControl() {
+  }, {
+    synonyms: ['clock', 'counter', 'countdown', 'timer', 'time', 'elapsed']
+  }),
+  clockControl: withMetadata(function () {
     return import('./assets/clock_control');
-  },
-  cloud: function cloud() {
+  }, {
+    synonyms: ['clock', 'control', 'time', 'schedule', 'timer', 'settings']
+  }),
+  cloud: withMetadata(function () {
     return import('./assets/cloud');
-  },
+  }, {
+    synonyms: ['cloud', 'online', 'hosting', 'saas', 'remote']
+  }),
   cloudDrizzle: function cloudDrizzle() {
     return import('./assets/cloud_drizzle');
   },
@@ -309,45 +468,63 @@ export var typeToPathMap = {
   cloudSunny: function cloudSunny() {
     return import('./assets/cloud_sunny');
   },
-  cluster: function cluster() {
+  cluster: withMetadata(function () {
     return import('./assets/cluster');
-  },
-  code: function code() {
+  }, {
+    synonyms: ['cluster', 'nodes', 'group', 'collection', 'distributed']
+  }),
+  code: withMetadata(function () {
     return import('./assets/code');
-  },
-  codeApp: function codeApp() {
+  }, {
+    synonyms: ['code', 'developer', 'programming', 'script', 'source']
+  }),
+  codeApp: withMetadata(function () {
     return import('./assets/app_code');
-  },
+  }, {
+    category: 'app'
+  }),
   color: function color() {
     return import('./assets/paint_bucket');
   },
   // NOTE: To be deprecated in favor of paintBucket
-  paintBucket: function paintBucket() {
+  paintBucket: withMetadata(function () {
     return import('./assets/paint_bucket');
-  },
-  commandLine: function commandLine() {
+  }, {
+    synonyms: ['paint', 'fill', 'bucket', 'color', 'flood fill']
+  }),
+  commandLine: withMetadata(function () {
     return import('./assets/command_line');
-  },
-  comment: function comment() {
+  }, {
+    synonyms: ['terminal', 'cli', 'console', 'shell', 'command', 'prompt']
+  }),
+  comment: withMetadata(function () {
     return import('./assets/comment');
-  },
-  compare: function compare() {
+  }, {
+    synonyms: ['comment', 'chat', 'message', 'feedback', 'discussion']
+  }),
+  compare: withMetadata(function () {
     return import('./assets/compare');
-  },
+  }, {
+    synonyms: ['compare', 'diff', 'versus', 'side by side']
+  }),
   compute: function compute() {
     return import('./assets/processor');
   },
   // NOTE: To be deprecated in favor of processor
-  processor: function processor() {
+  processor: withMetadata(function () {
     return import('./assets/processor');
-  },
+  }, {
+    synonyms: ['processor', 'compute', 'cpu', 'transform', 'ingest']
+  }),
   console: function console() {
     return import('./assets/command_line');
   },
   // NOTE: To be deprecated in favor of commandLine
-  consoleApp: function consoleApp() {
+  consoleApp: withMetadata(function () {
     return import('./assets/app_console');
-  },
+  }, {
+    category: 'app'
+  }),
   container: function container() {
     return import('./assets/container');
   },
@@ -363,19 +540,25 @@ export var typeToPathMap = {
   continuityWithin: function continuityWithin() {
     return import('./assets/continuity_within');
   },
-  contrast: function contrast() {
+  contrast: withMetadata(function () {
     return import('./assets/contrast');
-  },
+  }, {
+    synonyms: ['contrast', 'accessibility', 'visibility', 'a11y']
+  }),
   contrastHigh: function contrastHigh() {
     return import('./assets/contrast_fill');
   },
   // NOTE: To be deprecated in favor of contrastFill
-  contrastFill: function contrastFill() {
+  contrastFill: withMetadata(function () {
     return import('./assets/contrast_fill');
-  },
-  controls: function controls() {
+  }, {
+    synonyms: ['contrast', 'filled', 'accessibility', 'visibility', 'a11y', 'display']
+  }),
+  controls: withMetadata(function () {
     return import('./assets/controls');
-  },
+  }, {
+    synonyms: ['controls', 'sliders', 'settings', 'adjust', 'panel']
+  }),
   controlsHorizontal: function controlsHorizontal() {
     return import('./assets/controls');
   },
@@ -384,50 +567,74 @@ export var typeToPathMap = {
     return import('./assets/controls');
   },
   // NOTE: To be deprecated in favor of `controls`
-  copy: function copy() {
+  copy: withMetadata(function () {
     return import('./assets/copy');
-  },
+  }, {
+    synonyms: ['duplicate', 'clone', 'clipboard', 'replicate', 'paste']
+  }),
   copyClipboard: function copyClipboard() {
     return import('./assets/copy');
   },
   // NOTE: To be deprecated in favor of `copy`
-  crossProjectSearch: function crossProjectSearch() {
+  crossProjectSearch: withMetadata(function () {
     return import('./assets/cross_project_search');
-  },
-  createAdvancedJob: function createAdvancedJob() {
+  }, {
+    synonyms: ['search', 'cross project', 'global', 'find', 'lookup', 'explore']
+  }),
+  createAdvancedJob: withMetadata(function () {
     return import('./assets/ml_create_advanced_job');
-  },
-  createGenericJob: function createGenericJob() {
+  }, {
+    category: 'ml'
+  }),
+  createGenericJob: withMetadata(function () {
     return import('./assets/ml_create_generic_job');
-  },
-  createGeoJob: function createGeoJob() {
+  }, {
+    category: 'ml'
+  }),
+  createGeoJob: withMetadata(function () {
     return import('./assets/ml_create_geo_job');
-  },
-  createMultiMetricJob: function createMultiMetricJob() {
+  }, {
+    category: 'ml'
+  }),
+  createMultiMetricJob: withMetadata(function () {
     return import('./assets/ml_create_multi_metric_job');
-  },
-  createPopulationJob: function createPopulationJob() {
+  }, {
+    category: 'ml'
+  }),
+  createPopulationJob: withMetadata(function () {
     return import('./assets/ml_create_population_job');
-  },
-  createSingleMetricJob: function createSingleMetricJob() {
+  }, {
+    category: 'ml'
+  }),
+  createSingleMetricJob: withMetadata(function () {
     return import('./assets/ml_create_single_metric_job');
-  },
-  cross: function cross() {
+  }, {
+    category: 'ml'
+  }),
+  cross: withMetadata(function () {
     return import('./assets/cross');
-  },
-  crossClusterReplicationApp: function crossClusterReplicationApp() {
+  }, {
+    synonyms: ['cross', 'close', 'cancel', 'delete']
+  }),
+  crossClusterReplicationApp: withMetadata(function () {
     return import('./assets/app_cross_cluster_replication');
-  },
+  }, {
+    category: 'app'
+  }),
   crossInCircle: function crossInCircle() {
     return import('./assets/cross_circle');
   },
   // NOTE: To be deprecated in favor of crossCircle
-  crossCircle: function crossCircle() {
+  crossCircle: withMetadata(function () {
     return import('./assets/cross_circle');
-  },
-  crosshair: function crosshair() {
+  }, {
+    synonyms: ['cross circle', 'cross', 'close', 'cancel', 'delete', 'circle']
+  }),
+  crosshair: withMetadata(function () {
     return import('./assets/crosshair');
-  },
+  }, {
+    synonyms: ['crosshair']
+  }),
   crosshairs: function crosshairs() {
     return import('./assets/crosshair');
   },
@@ -436,83 +643,121 @@ export var typeToPathMap = {
     return import('./assets/money');
   },
   // NOTE: To be deprecated in favor of money
-  money: function money() {
+  money: withMetadata(function () {
     return import('./assets/money');
-  },
+  }, {
+    synonyms: ['money', 'payment', 'billing', 'cost', 'finance']
+  }),
   cut: function cut() {
     return import('./assets/scissors');
   },
   // NOTE: To be deprecated in favor of scissors
-  scissors: function scissors() {
+  scissors: withMetadata(function () {
     return import('./assets/scissors');
-  },
-  dashboardApp: function dashboardApp() {
+  }, {
+    synonyms: ['scissors']
+  }),
+  dashboardApp: withMetadata(function () {
     return import('./assets/app_dashboard');
-  },
-  dashedCircle: function dashedCircle() {
+  }, {
+    category: 'app'
+  }),
+  dashedCircle: withMetadata(function () {
     return import('./assets/dashed_circle');
-  },
-  dataVisualizer: function dataVisualizer() {
+  }, {
+    synonyms: ['dashed', 'circle', 'pending', 'incomplete', 'outline', 'status']
+  }),
+  dataVisualizer: withMetadata(function () {
     return import('./assets/ml_data_visualizer');
-  },
-  database: function database() {
+  }, {
+    category: 'ml'
+  }),
+  database: withMetadata(function () {
     return import('./assets/database');
-  },
+  }, {
+    synonyms: ['database', 'data', 'storage', 'sql', 'records']
+  }),
   desktop: function desktop() {
     return import('./assets/display');
   },
   // NOTE: To be deprecated in favor of display
-  display: function display() {
+  display: withMetadata(function () {
     return import('./assets/display');
-  },
-  devToolsApp: function devToolsApp() {
+  }, {
+    synonyms: ['display']
+  }),
+  devToolsApp: withMetadata(function () {
     return import('./assets/app_devtools');
-  },
+  }, {
+    category: 'app'
+  }),
   diff: function diff() {
     return import('./assets/compare');
   },
   // NOTE: To be deprecated in favor of compare
-  discoverApp: function discoverApp() {
+  discoverApp: withMetadata(function () {
     return import('./assets/app_discover');
-  },
-  distributeHorizontal: function distributeHorizontal() {
+  }, {
+    category: 'app'
+  }),
+  distributeHorizontal: withMetadata(function () {
     return import('./assets/distribute_horizontal');
-  },
-  distributeVertical: function distributeVertical() {
+  }, {
+    synonyms: ['distribute horizontal', 'distribute', 'horizontal']
+  }),
+  distributeVertical: withMetadata(function () {
     return import('./assets/distribute_vertical');
-  },
-  download: function download() {
+  }, {
+    synonyms: ['distribute vertical', 'distribute', 'vertical']
+  }),
+  download: withMetadata(function () {
     return import('./assets/download');
-  },
-  drag: function drag() {
+  }, {
+    synonyms: ['save', 'export', 'retrieve', 'get file', 'arrow down', 'pull']
+  }),
+  drag: withMetadata(function () {
     return import('./assets/drag');
-  },
-  dragHorizontal: function dragHorizontal() {
+  }, {
+    synonyms: ['drag', 'move', 'grab', 'reorder', 'handle']
+  }),
+  dragHorizontal: withMetadata(function () {
     return import('./assets/drag_horizontal');
-  },
-  dragVertical: function dragVertical() {
+  }, {
+    synonyms: ['drag horizontal', 'drag', 'move', 'grab', 'reorder', 'handle', 'horizontal']
+  }),
+  dragVertical: withMetadata(function () {
     return import('./assets/drag_vertical');
-  },
+  }, {
+    synonyms: ['drag vertical', 'drag', 'move', 'grab', 'reorder', 'handle', 'vertical']
+  }),
   discuss: function discuss() {
     return import('./assets/comment');
   },
   // NOTE: To be deprecated in favor of `comment`
-  document: function document() {
+  document: withMetadata(function () {
     return import('./assets/document');
-  },
+  }, {
+    synonyms: ['document', 'file', 'page', 'paper', 'doc']
+  }),
   documentEdit: function documentEdit() {
     return import('./assets/document_edit');
   },
   // NOTE: To be deprecated in favor of pencil
-  documentation: function documentation() {
+  documentation: withMetadata(function () {
     return import('./assets/documentation');
-  },
-  documents: function documents() {
+  }, {
+    synonyms: ['documentation', 'docs', 'help', 'guide', 'manual']
+  }),
+  documents: withMetadata(function () {
     return import('./assets/documents');
-  },
-  dot: function dot() {
+  }, {
+    synonyms: ['documents', 'files', 'pages', 'papers', 'library']
+  }),
+  dot: withMetadata(function () {
     return import('./assets/dot');
-  },
+  }, {
+    synonyms: ['dot', 'point', 'bullet', 'period', 'circle']
+  }),
   dotInCircle: function dotInCircle() {
     return import('./assets/dot_in_circle');
   },
@@ -520,54 +765,70 @@ export var typeToPathMap = {
     return import('./assets/chevron_double_left');
   },
   // NOTE: To be deprecated in favor of chevronDoubleLeft
-  chevronDoubleLeft: function chevronDoubleLeft() {
+  chevronDoubleLeft: withMetadata(function () {
     return import('./assets/chevron_double_left');
-  },
+  }, {
+    synonyms: ['chevron', 'double', 'left', 'rewind', 'back', 'previous']
+  }),
   doubleArrowRight: function doubleArrowRight() {
     return import('./assets/chevron_double_right');
   },
   // NOTE: To be deprecated in favor of chevronDoubleRight
-  chevronDoubleRight: function chevronDoubleRight() {
+  chevronDoubleRight: withMetadata(function () {
     return import('./assets/chevron_double_right');
-  },
-  ellipsis: function ellipsis() {
+  }, {
+    synonyms: ['chevron', 'double', 'right', 'forward', 'skip', 'next']
+  }),
+  ellipsis: withMetadata(function () {
     return import('./assets/ellipsis');
-  },
+  }, {
+    synonyms: ['ellipsis', 'more', 'menu', 'overflow', 'dots']
+  }),
   editorAlignCenter: function editorAlignCenter() {
     return import('./assets/text_align_center');
   },
   // NOTE: To be deprecated in favor of textAlignCenter
-  textAlignCenter: function textAlignCenter() {
+  textAlignCenter: withMetadata(function () {
     return import('./assets/text_align_center');
-  },
+  }, {
+    synonyms: ['text', 'align', 'center', 'middle', 'typography']
+  }),
   editorAlignLeft: function editorAlignLeft() {
     return import('./assets/text_align_left');
   },
   // NOTE: To be deprecated in favor of textAlignLeft
-  textAlignLeft: function textAlignLeft() {
+  textAlignLeft: withMetadata(function () {
     return import('./assets/text_align_left');
-  },
+  }, {
+    synonyms: ['text', 'align', 'left', 'typography', 'paragraph']
+  }),
   editorAlignRight: function editorAlignRight() {
     return import('./assets/text_align_right');
   },
   // NOTE: To be deprecated in favor of textAlignRight
-  textAlignRight: function textAlignRight() {
+  textAlignRight: withMetadata(function () {
     return import('./assets/text_align_right');
-  },
+  }, {
+    synonyms: ['text', 'align', 'right', 'typography', 'paragraph']
+  }),
   editorBold: function editorBold() {
     return import('./assets/text_bold');
   },
   // NOTE: To be deprecated in favor of textBold
-  textBold: function textBold() {
+  textBold: withMetadata(function () {
     return import('./assets/text_bold');
-  },
+  }, {
+    synonyms: ['text bold', 'text', 'bold', 'typography', 'formatting']
+  }),
   editorChecklist: function editorChecklist() {
     return import('./assets/list_check');
   },
   // NOTE: To be deprecated in favor of listCheck
-  listCheck: function listCheck() {
+  listCheck: withMetadata(function () {
     return import('./assets/list_check');
-  },
+  }, {
+    synonyms: ['list check', 'list', 'bullet', 'items', 'rows', 'check', 'tick', 'confirm']
+  }),
   editorCodeBlock: function editorCodeBlock() {
     return import('./assets/code');
   },
@@ -588,16 +849,20 @@ export var typeToPathMap = {
     return import('./assets/text_heading');
   },
   // NOTE: To be deprecated in favor of textHeading
-  textHeading: function textHeading() {
+  textHeading: withMetadata(function () {
     return import('./assets/text_heading');
-  },
+  }, {
+    synonyms: ['text', 'heading', 'title', 'h1', 'typography', 'header']
+  }),
   editorItalic: function editorItalic() {
     return import('./assets/text_italic');
   },
   // NOTE: To be deprecated in favor of textItalic
-  textItalic: function textItalic() {
+  textItalic: withMetadata(function () {
     return import('./assets/text_italic');
-  },
+  }, {
+    synonyms: ['text italic', 'text', 'italic', 'typography', 'formatting']
+  }),
   editorItemAlignBottom: function editorItemAlignBottom() {
     return import('./assets/editor_item_align_bottom');
   },
@@ -630,9 +895,11 @@ export var typeToPathMap = {
     return import('./assets/list_number');
   },
   // NOTE: To be deprecated in favor of listNumber
-  listNumber: function listNumber() {
+  listNumber: withMetadata(function () {
     return import('./assets/list_number');
-  },
+  }, {
+    synonyms: ['list number', 'list', 'bullet', 'items', 'rows', 'number', 'digit', 'numeric']
+  }),
   editorPositionBottomLeft: function editorPositionBottomLeft() {
     return import('./assets/editor_position_bottom_left');
   },
@@ -653,80 +920,108 @@ export var typeToPathMap = {
     return import('./assets/redo');
   },
   // NOTE: To be deprecated in favor of redo
-  redo: function redo() {
+  redo: withMetadata(function () {
     return import('./assets/redo');
-  },
+  }, {
+    synonyms: ['redo', 'repeat', 'forward', 'again']
+  }),
   editorStrike: function editorStrike() {
     return import('./assets/text_strike');
   },
   // NOTE: To be deprecated in favor of textStrike
-  textStrike: function textStrike() {
+  textStrike: withMetadata(function () {
     return import('./assets/text_strike');
-  },
+  }, {
+    synonyms: ['text', 'strikethrough', 'strike', 'delete', 'typography']
+  }),
   editorTable: function editorTable() {
     return import('./assets/table');
   },
   // NOTE: To be deprecated in favor of table
-  table: function table() {
+  table: withMetadata(function () {
     return import('./assets/table');
-  },
+  }, {
+    synonyms: ['table']
+  }),
   editorUnderline: function editorUnderline() {
     return import('./assets/text_underline');
   },
   // NOTE: To be deprecated in favor of textUnderline
-  textUnderline: function textUnderline() {
+  textUnderline: withMetadata(function () {
     return import('./assets/text_underline');
-  },
+  }, {
+    synonyms: ['text underline', 'text', 'underline', 'typography', 'formatting']
+  }),
   editorUndo: function editorUndo() {
     return import('./assets/undo');
   },
   // NOTE: To be deprecated in favor of undo
-  undo: function undo() {
+  undo: withMetadata(function () {
     return import('./assets/undo');
-  },
+  }, {
+    synonyms: ['undo', 'revert', 'back', 'previous action']
+  }),
   editorUnorderedList: function editorUnorderedList() {
     return import('./assets/list_bullet');
   },
   // NOTE: To be deprecated in favor of listBullet
-  listBullet: function listBullet() {
+  listBullet: withMetadata(function () {
     return import('./assets/list_bullet');
-  },
+  }, {
+    synonyms: ['list bullet', 'list', 'bullet', 'items', 'rows']
+  }),
   email: function email() {
     return import('./assets/mail');
   },
   // NOTE: To be deprecated in favor of mail
-  mail: function mail() {
+  mail: withMetadata(function () {
     return import('./assets/mail');
-  },
-  empty: function empty() {
+  }, {
+    synonyms: ['mail', 'email', 'envelope', 'message', 'inbox']
+  }),
+  empty: withMetadata(function () {
     return import('./assets/empty');
-  },
-  emsApp: function emsApp() {
+  }, {
+    synonyms: ['empty', 'blank', 'none', 'placeholder', 'void']
+  }),
+  emsApp: withMetadata(function () {
     return import('./assets/app_ems');
-  },
-  endpoint: function endpoint() {
+  }, {
+    category: 'app'
+  }),
+  endpoint: withMetadata(function () {
     return import('./assets/endpoint');
-  },
+  }, {
+    synonyms: ['endpoint', 'api', 'url', 'connection', 'target']
+  }),
   eql: function eql() {
     return import('./assets/query');
   },
   // NOTE: To be deprecated in favor of query
-  query: function query() {
+  query: withMetadata(function () {
     return import('./assets/query');
-  },
-  eraser: function eraser() {
+  }, {
+    synonyms: ['query', 'search', 'sql', 'lucene', 'filter']
+  }),
+  eraser: withMetadata(function () {
     return import('./assets/eraser');
-  },
-  error: function error() {
+  }, {
+    synonyms: ['eraser', 'clear', 'remove', 'delete', 'rubber']
+  }),
+  error: withMetadata(function () {
     return import('./assets/error');
-  },
+  }, {
+    synonyms: ['error', 'failure', 'problem', 'invalid', 'cross']
+  }),
   errorFilled: function errorFilled() {
     return import('./assets/error_fill');
   },
   // NOTE: To be deprecated in favor of errorFill
-  errorFill: function errorFill() {
+  errorFill: withMetadata(function () {
     return import('./assets/error_fill');
-  },
+  }, {
+    synonyms: ['error fill', 'error', 'failure', 'problem', 'invalid', 'cross', 'fill', 'filled']
+  }),
   esqlVis: function esqlVis() {
     return import('./assets/esql_vis');
   },
@@ -734,16 +1029,20 @@ export var typeToPathMap = {
     return import('./assets/log_out');
   },
   // NOTE: To be deprecated in favor of logOut
-  logOut: function logOut() {
+  logOut: withMetadata(function () {
     return import('./assets/log_out');
-  },
+  }, {
+    synonyms: ['log out', 'log', 'out']
+  }),
   expand: function expand() {
     return import('./assets/maximize');
   },
   // NOTE: To be deprecated in favor of maximize
-  maximize: function maximize() {
+  maximize: withMetadata(function () {
     return import('./assets/maximize');
-  },
+  }, {
+    synonyms: ['maximize']
+  }),
   expandMini: function expandMini() {
     return import('./assets/maximize');
   },
@@ -755,66 +1054,98 @@ export var typeToPathMap = {
     return import('./assets/upload');
   },
   // NOTE: To be deprecated in favor of upload
-  upload: function upload() {
+  upload: withMetadata(function () {
     return import('./assets/upload');
-  },
-  external: function external() {
+  }, {
+    synonyms: ['upload', 'import', 'send', 'cloud', 'arrow up']
+  }),
+  external: withMetadata(function () {
     return import('./assets/external');
-  },
-  eye: function eye() {
+  }, {
+    synonyms: ['external', 'open new', 'link out', 'outside']
+  }),
+  eye: withMetadata(function () {
     return import('./assets/eye');
-  },
+  }, {
+    synonyms: ['eye', 'view', 'visible', 'show', 'preview', 'watch']
+  }),
   eyeClosed: function eyeClosed() {
     return import('./assets/eye_slash');
   },
   // NOTE: To be deprecated in favor of eyeSlash
-  eyeSlash: function eyeSlash() {
+  eyeSlash: withMetadata(function () {
     return import('./assets/eye_slash');
-  },
-  faceHappy: function faceHappy() {
+  }, {
+    synonyms: ['eye slash', 'eye', 'view', 'visible', 'show', 'preview', 'watch', 'slash']
+  }),
+  faceHappy: withMetadata(function () {
     return import('./assets/face_happy');
-  },
-  faceNeutral: function faceNeutral() {
+  }, {
+    synonyms: ['smile', 'happy', 'emoji', 'positive', 'grin', 'satisfied', 'mood']
+  }),
+  faceNeutral: withMetadata(function () {
     return import('./assets/face_neutral');
-  },
-  faceSad: function faceSad() {
+  }, {
+    synonyms: ['face neutral', 'face', 'neutral']
+  }),
+  faceSad: withMetadata(function () {
     return import('./assets/face_sad');
-  },
+  }, {
+    synonyms: ['face sad', 'face', 'sad']
+  }),
   fieldStatistics: function fieldStatistics() {
     return import('./assets/table_info');
   },
   // NOTE: To be deprecated in favor of tableInfo
-  tableInfo: function tableInfo() {
+  tableInfo: withMetadata(function () {
     return import('./assets/table_info');
-  },
-  filebeatApp: function filebeatApp() {
+  }, {
+    synonyms: ['table', 'info', 'metadata', 'details', 'schema', 'columns']
+  }),
+  filebeatApp: withMetadata(function () {
     return import('./assets/app_filebeat');
-  },
-  filter: function filter() {
+  }, {
+    category: 'app'
+  }),
+  filter: withMetadata(function () {
     return import('./assets/filter');
-  },
-  filterExclude: function filterExclude() {
+  }, {
+    synonyms: ['funnel', 'refine', 'narrow', 'sort', 'subset', 'sieve', 'criteria']
+  }),
+  filterExclude: withMetadata(function () {
     return import('./assets/filter_exclude');
-  },
-  filterIgnore: function filterIgnore() {
+  }, {
+    synonyms: ['filter', 'exclude', 'remove', 'minus', 'refine', 'narrow']
+  }),
+  filterIgnore: withMetadata(function () {
     return import('./assets/filter_ignore');
-  },
-  filterInclude: function filterInclude() {
+  }, {
+    synonyms: ['filter', 'ignore', 'skip', 'exclude', 'omit', 'hide']
+  }),
+  filterInclude: withMetadata(function () {
     return import('./assets/filter_include');
-  },
+  }, {
+    synonyms: ['filter', 'include', 'add', 'refine', 'narrow', 'select']
+  }),
   filterInCircle: function filterInCircle() {
     return import('./assets/filter_in_circle');
   },
   // NOTE: To be deprecated in favor of filter
-  flask: function flask() {
+  flask: withMetadata(function () {
     return import('./assets/flask');
-  },
-  flag: function flag() {
+  }, {
+    synonyms: ['flask', 'experiment', 'lab', 'science', 'test']
+  }),
+  flag: withMetadata(function () {
     return import('./assets/flag');
-  },
-  fleetApp: function fleetApp() {
+  }, {
+    synonyms: ['flag', 'mark', 'report', 'bookmark', 'priority']
+  }),
+  fleetApp: withMetadata(function () {
     return import('./assets/app_agent');
-  },
+  }, {
+    category: 'app'
+  }),
   fold: function fold() {
     return import('./assets/fold');
   },
@@ -824,18 +1155,22 @@ export var typeToPathMap = {
   folderClosed: function folderClosed() {
     return import('./assets/folder_close');
   },
-  folderClose: function folderClose() {
+  folderClose: withMetadata(function () {
     return import('./assets/folder_close');
-  },
+  }, {
+    synonyms: ['folder', 'closed', 'collapse', 'directory', 'archive']
+  }),
   folderCheck: function folderCheck() {
     return import('./assets/folder_check');
   },
   folderExclamation: function folderExclamation() {
     return import('./assets/folder_exclamation');
   },
-  folderOpen: function folderOpen() {
+  folderOpen: withMetadata(function () {
     return import('./assets/folder_open');
-  },
+  }, {
+    synonyms: ['folder', 'open', 'expand', 'directory', 'browse']
+  }),
   folderOpened: function folderOpened() {
     return import('./assets/folder_open');
   },
@@ -845,28 +1180,38 @@ export var typeToPathMap = {
   framePrevious: function framePrevious() {
     return import('./assets/frame_previous');
   },
-  fullScreen: function fullScreen() {
+  fullScreen: withMetadata(function () {
     return import('./assets/full_screen');
-  },
-  fullScreenExit: function fullScreenExit() {
+  }, {
+    synonyms: ['fullscreen']
+  }),
+  fullScreenExit: withMetadata(function () {
     return import('./assets/full_screen_exit');
-  },
+  }, {
+    synonyms: ['fullscreen', 'exit', 'minimize', 'window', 'restore', 'shrink']
+  }),
   function: function _function() {
     return import('./assets/function');
   },
-  gear: function gear() {
+  gear: withMetadata(function () {
     return import('./assets/gear');
-  },
-  gisApp: function gisApp() {
+  }, {
+    synonyms: ['settings', 'configure', 'configuration', 'preferences', 'options', 'cog', 'setup', 'admin', 'wrench']
+  }),
+  gisApp: withMetadata(function () {
     return import('./assets/app_gis');
-  },
+  }, {
+    category: 'app'
+  }),
   glasses: function glasses() {
     return import('./assets/read_only');
   },
   // NOTE: To be deprecated in favor of `readOnly`
-  globe: function globe() {
+  globe: withMetadata(function () {
     return import('./assets/globe');
-  },
+  }, {
+    synonyms: ['globe', 'world', 'web', 'internet', 'international']
+  }),
   grab: function grab() {
     return import('./assets/drag_vertical');
   },
@@ -879,24 +1224,36 @@ export var typeToPathMap = {
     return import('./assets/grab_omnidirectional');
   },
   // NOTE: To be deprecated in favor of drag,
-  gradient: function gradient() {
+  gradient: withMetadata(function () {
     return import('./assets/gradient');
-  },
-  graphApp: function graphApp() {
+  }, {
+    synonyms: ['gradient', 'blend', 'fade', 'color transition']
+  }),
+  graphApp: withMetadata(function () {
     return import('./assets/app_graph');
-  },
-  grid: function grid() {
+  }, {
+    category: 'app'
+  }),
+  grid: withMetadata(function () {
     return import('./assets/grid');
-  },
-  grokApp: function grokApp() {
+  }, {
+    synonyms: ['grid', 'table', 'layout', 'matrix', 'cells']
+  }),
+  grokApp: withMetadata(function () {
     return import('./assets/app_grok');
-  },
-  heart: function heart() {
+  }, {
+    category: 'app'
+  }),
+  heart: withMetadata(function () {
     return import('./assets/heart');
-  },
-  heartbeatApp: function heartbeatApp() {
+  }, {
+    synonyms: ['heart', 'favorite', 'like', 'love', 'bookmark']
+  }),
+  heartbeatApp: withMetadata(function () {
     return import('./assets/app_heartbeat');
-  },
+  }, {
+    category: 'app'
+  }),
   heatmap: function heatmap() {
     return import('./assets/chart_heatmap');
   },
@@ -905,21 +1262,31 @@ export var typeToPathMap = {
     return import('./assets/help');
   },
   // NOTE: Might be deprecated later (not recommended in Kibana)
-  home: function home() {
+  home: withMetadata(function () {
     return import('./assets/home');
-  },
-  hourglass: function hourglass() {
+  }, {
+    synonyms: ['home', 'house', 'main', 'start', 'dashboard']
+  }),
+  hourglass: withMetadata(function () {
     return import('./assets/hourglass');
-  },
-  if: function _if() {
+  }, {
+    synonyms: ['hourglass', 'waiting', 'loading', 'time', 'pending']
+  }),
+  if: withMetadata(function () {
     return import('./assets/if');
-  },
-  info: function info() {
+  }, {
+    synonyms: ['if', 'condition', 'logic', 'branch', 'rule']
+  }),
+  info: withMetadata(function () {
     return import('./assets/info');
-  },
-  image: function image() {
+  }, {
+    synonyms: ['info', 'information', 'help', 'about', 'details']
+  }),
+  image: withMetadata(function () {
     return import('./assets/image');
-  },
+  }, {
+    synonyms: ['image', 'picture', 'photo', 'media', 'graphic']
+  }),
   importAction: function importAction() {
     return import('./assets/download');
   },
@@ -927,57 +1294,83 @@ export var typeToPathMap = {
   index: function index() {
     return import('./assets/index');
   },
-  indexClose: function indexClose() {
+  indexClose: withMetadata(function () {
     return import('./assets/index_close');
-  },
-  indexEdit: function indexEdit() {
+  }, {
+    synonyms: ['index', 'close', 'elasticsearch', 'dataset', 'remove']
+  }),
+  indexEdit: withMetadata(function () {
     return import('./assets/index_edit');
-  },
+  }, {
+    synonyms: ['index', 'edit', 'elasticsearch', 'dataset', 'modify', 'settings']
+  }),
   indexFlush: function indexFlush() {
     return import('./assets/chart_threshold');
   },
   // NOTE: To be deprecated in favor of chartThreshold
-  indexManagementApp: function indexManagementApp() {
+  indexManagementApp: withMetadata(function () {
     return import('./assets/app_index_management');
-  },
+  }, {
+    category: 'app'
+  }),
   indexMapping: function indexMapping() {
     return import('./assets/mapping');
   },
   // NOTE: To be deprecated in favor of mapping
-  mapping: function mapping() {
+  mapping: withMetadata(function () {
     return import('./assets/mapping');
-  },
-  indexOpen: function indexOpen() {
+  }, {
+    synonyms: ['mapping']
+  }),
+  indexOpen: withMetadata(function () {
     return import('./assets/index_open');
-  },
-  indexPatternApp: function indexPatternApp() {
+  }, {
+    synonyms: ['index', 'open', 'elasticsearch', 'dataset', 'browse']
+  }),
+  indexPatternApp: withMetadata(function () {
     return import('./assets/app_index_pattern');
-  },
-  indexRollupApp: function indexRollupApp() {
+  }, {
+    category: 'app'
+  }),
+  indexRollupApp: withMetadata(function () {
     return import('./assets/app_index_rollup');
-  },
-  indexRuntime: function indexRuntime() {
+  }, {
+    category: 'app'
+  }),
+  indexRuntime: withMetadata(function () {
     return import('./assets/index_runtime');
-  },
-  indexSettings: function indexSettings() {
+  }, {
+    synonyms: ['index', 'runtime', 'elasticsearch', 'live', 'execution']
+  }),
+  indexSettings: withMetadata(function () {
     return import('./assets/index_settings');
-  },
+  }, {
+    synonyms: ['index', 'settings', 'elasticsearch', 'configure', 'options']
+  }),
   indexTemporary: function indexTemporary() {
     return import('./assets/table_time');
   },
   // NOTE: To be deprecated in favor of tableTime
-  tableTime: function tableTime() {
+  tableTime: withMetadata(function () {
     return import('./assets/table_time');
-  },
-  infinity: function infinity() {
+  }, {
+    synonyms: ['table', 'time', 'temporal', 'date', 'timeline', 'history']
+  }),
+  infinity: withMetadata(function () {
     return import('./assets/infinity');
-  },
-  inputOutput: function inputOutput() {
+  }, {
+    synonyms: ['infinity', 'unlimited', 'forever', 'loop', 'endless']
+  }),
+  inputOutput: withMetadata(function () {
     return import('./assets/input_output');
-  },
-  inspect: function inspect() {
+  }, {
+    synonyms: ['input', 'output', 'io', 'data flow', 'pipeline', 'stream']
+  }),
+  inspect: withMetadata(function () {
     return import('./assets/inspect');
-  },
+  }, {
+    synonyms: ['inspect', 'investigate', 'examine', 'analyze', 'look']
+  }),
   invert: function invert() {
     return import('./assets/contrast');
   },
@@ -985,19 +1378,25 @@ export var typeToPathMap = {
   ip: function ip() {
     return import('./assets/ip');
   },
-  key: function key() {
+  key: withMetadata(function () {
     return import('./assets/key');
-  },
-  keyboard: function keyboard() {
+  }, {
+    synonyms: ['key', 'password', 'credential', 'access', 'security']
+  }),
+  keyboard: withMetadata(function () {
     return import('./assets/keyboard');
-  },
+  }, {
+    synonyms: ['keyboard', 'typing', 'input', 'shortcut', 'keys']
+  }),
   kqlField: function kqlField() {
     return import('./assets/query_field');
   },
   // NOTE: To be deprecated in favor of queryField
-  queryField: function queryField() {
+  queryField: withMetadata(function () {
     return import('./assets/query_field');
-  },
+  }, {
+    synonyms: ['query', 'field', 'filter', 'column', 'attribute', 'selector']
+  }),
   kqlFunction: function kqlFunction() {
     return import('./assets/kql_function');
   },
@@ -1005,78 +1404,108 @@ export var typeToPathMap = {
     return import('./assets/query_operand');
   },
   // NOTE: To be deprecated in favor of queryOperand
-  queryOperand: function queryOperand() {
+  queryOperand: withMetadata(function () {
     return import('./assets/query_operand');
-  },
+  }, {
+    synonyms: ['query', 'operand', 'operator', 'logic', 'condition', 'rule']
+  }),
   kqlSelector: function kqlSelector() {
     return import('./assets/query_selector');
   },
   // NOTE: To be deprecated in favor of querySelector
-  querySelector: function querySelector() {
+  querySelector: withMetadata(function () {
     return import('./assets/query_selector');
-  },
+  }, {
+    synonyms: ['query', 'selector', 'pick', 'choose', 'field', 'filter']
+  }),
   kqlValue: function kqlValue() {
     return import('./assets/query_value');
   },
   // NOTE: To be deprecated in favor of queryValue
-  queryValue: function queryValue() {
+  queryValue: withMetadata(function () {
     return import('./assets/query_value');
-  },
+  }, {
+    synonyms: ['query', 'value', 'literal', 'data', 'input', 'filter']
+  }),
   kubernetesNode: function kubernetesNode() {
     return import('./assets/kubernetes_node');
   },
-  kubernetesPod: function kubernetesPod() {
+  kubernetesPod: withMetadata(function () {
     return import('./assets/kubernetes_pod');
-  },
+  }, {
+    synonyms: ['kubernetes', 'pod', 'k8s', 'container', 'cluster', 'orchestration']
+  }),
   launch: function launch() {
     return import('./assets/rocket');
   },
   // NOTE: To be deprecated in favor of rocket
-  rocket: function rocket() {
+  rocket: withMetadata(function () {
     return import('./assets/rocket');
-  },
-  layers: function layers() {
+  }, {
+    synonyms: ['rocket', 'launch', 'deploy', 'fast', 'startup']
+  }),
+  layers: withMetadata(function () {
     return import('./assets/layers');
-  },
-  lensApp: function lensApp() {
+  }, {
+    synonyms: ['layers']
+  }),
+  lensApp: withMetadata(function () {
     return import('./assets/app_lens');
-  },
+  }, {
+    category: 'app'
+  }),
   lettering: function lettering() {
     return import('./assets/text');
   },
   // NOTE: To be deprecated in favor of text
-  text: function text() {
+  text: withMetadata(function () {
     return import('./assets/text');
-  },
-  lineBreak: function lineBreak() {
+  }, {
+    synonyms: ['text']
+  }),
+  lineBreak: withMetadata(function () {
     return import('./assets/line_break');
-  },
-  lineBreakSlash: function lineBreakSlash() {
+  }, {
+    synonyms: ['line break', 'newline', 'paragraph', 'text', 'wrap', 'return']
+  }),
+  lineBreakSlash: withMetadata(function () {
     return import('./assets/line_break_slash');
-  },
-  lineDash: function lineDash() {
+  }, {
+    synonyms: ['line break', 'slash', 'text', 'separator', 'paragraph']
+  }),
+  lineDash: withMetadata(function () {
     return import('./assets/line_dash');
-  },
+  }, {
+    synonyms: ['line dash', 'line', 'dash']
+  }),
   lineDashed: function lineDashed() {
     return import('./assets/line_dash');
   },
   // NOTE: To be deprecated in favor of lineDash
-  lineDot: function lineDot() {
+  lineDot: withMetadata(function () {
     return import('./assets/line_dot');
-  },
+  }, {
+    synonyms: ['line dot', 'line', 'dot', 'point', 'bullet', 'period', 'circle']
+  }),
   lineDotted: function lineDotted() {
     return import('./assets/line_dot');
   },
   // NOTE: To be deprecated in favor of lineDot
-  lineSolid: function lineSolid() {
+  lineSolid: withMetadata(function () {
     return import('./assets/line_solid');
-  },
-  link: function link() {
+  }, {
+    synonyms: ['line solid', 'line', 'solid']
+  }),
+  link: withMetadata(function () {
     return import('./assets/link');
-  },
-  linkSlash: function linkSlash() {
+  }, {
+    synonyms: ['link', 'url', 'chain', 'connect', 'hyperlink']
+  }),
+  linkSlash: withMetadata(function () {
     return import('./assets/link_slash');
-  },
+  }, {
+    synonyms: ['unlink', 'broken link', 'remove link', 'disconnect', 'url']
+  }),
   list: function list() {
     return import('./assets/list_bullet');
   },
@@ -1085,202 +1514,328 @@ export var typeToPathMap = {
     return import('./assets/plus_circle');
   },
   // NOTE: To be deprecated in favor of `plus_circle`
-  lock: function lock() {
+  lock: withMetadata(function () {
     return import('./assets/lock');
-  },
-  lockOpen: function lockOpen() {
+  }, {
+    synonyms: ['lock', 'secure', 'private', 'protected', 'password']
+  }),
+  lockOpen: withMetadata(function () {
     return import('./assets/lock_open');
-  },
+  }, {
+    synonyms: ['lock open', 'lock', 'secure', 'private', 'protected', 'password', 'open']
+  }),
   logPatternAnalysis: function logPatternAnalysis() {
     return import('./assets/pattern');
   },
   // NOTE: To be deprecated in favor of pattern
-  pattern: function pattern() {
+  pattern: withMetadata(function () {
     return import('./assets/pattern');
-  },
+  }, {
+    synonyms: ['pattern', 'texture', 'repeat', 'design', 'fill']
+  }),
   logRateAnalysis: function logRateAnalysis() {
     return import('./assets/log_rate_analysis');
   },
-  logoAWS: function logoAWS() {
+  logoAWS: withMetadata(function () {
     return import('./assets/logo_aws');
-  },
-  logoAWSMono: function logoAWSMono() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoAWSMono: withMetadata(function () {
     return import('./assets/logo_aws_mono');
-  },
-  logoAerospike: function logoAerospike() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoAerospike: withMetadata(function () {
     return import('./assets/logo_aerospike');
-  },
-  logoApache: function logoApache() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoApache: withMetadata(function () {
     return import('./assets/logo_apache');
-  },
-  logoAppSearch: function logoAppSearch() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoAppSearch: withMetadata(function () {
     return import('./assets/logo_app_search');
-  },
-  logoAzure: function logoAzure() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoAzure: withMetadata(function () {
     return import('./assets/logo_azure');
-  },
-  logoAzureMono: function logoAzureMono() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoAzureMono: withMetadata(function () {
     return import('./assets/logo_azure_mono');
-  },
-  logoBeats: function logoBeats() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoBeats: withMetadata(function () {
     return import('./assets/logo_beats');
-  },
-  logoBusinessAnalytics: function logoBusinessAnalytics() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoBusinessAnalytics: withMetadata(function () {
     return import('./assets/logo_business_analytics');
-  },
-  logoCeph: function logoCeph() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoCeph: withMetadata(function () {
     return import('./assets/logo_ceph');
-  },
-  logoCloud: function logoCloud() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoCloud: withMetadata(function () {
     return import('./assets/logo_cloud');
-  },
-  logoCloudEnterprise: function logoCloudEnterprise() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoCloudEnterprise: withMetadata(function () {
     return import('./assets/logo_cloud_ece');
-  },
-  logoCode: function logoCode() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoCode: withMetadata(function () {
     return import('./assets/logo_code');
-  },
-  logoCodesandbox: function logoCodesandbox() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoCodesandbox: withMetadata(function () {
     return import('./assets/logo_codesandbox');
-  },
-  logoCouchbase: function logoCouchbase() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoCouchbase: withMetadata(function () {
     return import('./assets/logo_couchbase');
-  },
-  logoDocker: function logoDocker() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoDocker: withMetadata(function () {
     return import('./assets/logo_docker');
-  },
-  logoDropwizard: function logoDropwizard() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoDropwizard: withMetadata(function () {
     return import('./assets/logo_dropwizard');
-  },
-  logoElastic: function logoElastic() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoElastic: withMetadata(function () {
     return import('./assets/logo_elastic');
-  },
-  logoElasticStack: function logoElasticStack() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoElasticStack: withMetadata(function () {
     return import('./assets/logo_elastic_stack');
-  },
-  logoElasticsearch: function logoElasticsearch() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoElasticsearch: withMetadata(function () {
     return import('./assets/logo_elasticsearch');
-  },
-  logoEnterpriseSearch: function logoEnterpriseSearch() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoEnterpriseSearch: withMetadata(function () {
     return import('./assets/logo_enterprise_search');
-  },
-  logoEtcd: function logoEtcd() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoEtcd: withMetadata(function () {
     return import('./assets/logo_etcd');
-  },
-  logoGCP: function logoGCP() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoGCP: withMetadata(function () {
     return import('./assets/logo_gcp');
-  },
-  logoGCPMono: function logoGCPMono() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoGCPMono: withMetadata(function () {
     return import('./assets/logo_gcp_mono');
-  },
-  logoGithub: function logoGithub() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoGithub: withMetadata(function () {
     return import('./assets/logo_github');
-  },
-  logoGmail: function logoGmail() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoGmail: withMetadata(function () {
     return import('./assets/logo_gmail');
-  },
-  logoGolang: function logoGolang() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoGolang: withMetadata(function () {
     return import('./assets/logo_golang');
-  },
-  logoGoogleG: function logoGoogleG() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoGoogleG: withMetadata(function () {
     return import('./assets/logo_google_g');
-  },
-  logoHAproxy: function logoHAproxy() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoHAproxy: withMetadata(function () {
     return import('./assets/logo_haproxy');
-  },
-  logoIBM: function logoIBM() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoIBM: withMetadata(function () {
     return import('./assets/logo_ibm');
-  },
-  logoIBMMono: function logoIBMMono() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoIBMMono: withMetadata(function () {
     return import('./assets/logo_ibm_mono');
-  },
-  logoKafka: function logoKafka() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoKafka: withMetadata(function () {
     return import('./assets/logo_kafka');
-  },
-  logoKibana: function logoKibana() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoKibana: withMetadata(function () {
     return import('./assets/logo_kibana');
-  },
-  logoKubernetes: function logoKubernetes() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoKubernetes: withMetadata(function () {
     return import('./assets/logo_kubernetes');
-  },
-  logoLogging: function logoLogging() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoLogging: withMetadata(function () {
     return import('./assets/logo_logging');
-  },
-  logoLogstash: function logoLogstash() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoLogstash: withMetadata(function () {
     return import('./assets/logo_logstash');
-  },
-  logoMaps: function logoMaps() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoMaps: withMetadata(function () {
     return import('./assets/logo_maps');
-  },
-  logoMemcached: function logoMemcached() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoMemcached: withMetadata(function () {
     return import('./assets/logo_memcached');
-  },
-  logoMetrics: function logoMetrics() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoMetrics: withMetadata(function () {
     return import('./assets/logo_metrics');
-  },
-  logoMongodb: function logoMongodb() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoMongodb: withMetadata(function () {
     return import('./assets/logo_mongodb');
-  },
-  logoMySQL: function logoMySQL() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoMySQL: withMetadata(function () {
     return import('./assets/logo_mysql');
-  },
-  logoNginx: function logoNginx() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoNginx: withMetadata(function () {
     return import('./assets/logo_nginx');
-  },
-  logoObservability: function logoObservability() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoObservability: withMetadata(function () {
     return import('./assets/logo_observability');
-  },
-  logoOsquery: function logoOsquery() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoOsquery: withMetadata(function () {
     return import('./assets/logo_osquery');
-  },
-  logoPhp: function logoPhp() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoPhp: withMetadata(function () {
     return import('./assets/logo_php');
-  },
-  logoPostgres: function logoPostgres() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoPostgres: withMetadata(function () {
     return import('./assets/logo_postgres');
-  },
-  logoPrometheus: function logoPrometheus() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoPrometheus: withMetadata(function () {
     return import('./assets/logo_prometheus');
-  },
-  logoRabbitmq: function logoRabbitmq() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoRabbitmq: withMetadata(function () {
     return import('./assets/logo_rabbitmq');
-  },
-  logoRedis: function logoRedis() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoRedis: withMetadata(function () {
     return import('./assets/logo_redis');
-  },
-  logoSecurity: function logoSecurity() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoSecurity: withMetadata(function () {
     return import('./assets/logo_security');
-  },
-  logoSiteSearch: function logoSiteSearch() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoSiteSearch: withMetadata(function () {
     return import('./assets/logo_site_search');
-  },
-  logoSketch: function logoSketch() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoSketch: withMetadata(function () {
     return import('./assets/logo_sketch');
-  },
-  logoSlack: function logoSlack() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoSlack: withMetadata(function () {
     return import('./assets/logo_slack');
-  },
-  logoUptime: function logoUptime() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoUptime: withMetadata(function () {
     return import('./assets/logo_uptime');
-  },
-  logoVectorDB: function logoVectorDB() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoVectorDB: withMetadata(function () {
     return import('./assets/logo_vector_db');
-  },
-  logoVulnerabilityManagement: function logoVulnerabilityManagement() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoVulnerabilityManagement: withMetadata(function () {
     return import('./assets/logo_vulnerability_management');
-  },
-  logoWebhook: function logoWebhook() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logoWebhook: withMetadata(function () {
     return import('./assets/logo_webhook');
-  },
-  logoWindows: function logoWindows() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoWindows: withMetadata(function () {
     return import('./assets/logo_windows');
-  },
-  logoWorkplaceSearch: function logoWorkplaceSearch() {
+  }, {
+    category: 'thirdPartyLogo'
+  }),
+  logoWorkplaceSearch: withMetadata(function () {
     return import('./assets/logo_workplace_search');
-  },
-  logsApp: function logsApp() {
+  }, {
+    category: 'elasticLogo'
+  }),
+  logsApp: withMetadata(function () {
     return import('./assets/app_logs');
-  },
+  }, {
+    category: 'app'
+  }),
   logstashFilter: function logstashFilter() {
     return import('./assets/logstash_filter');
   },
@@ -1298,27 +1853,39 @@ export var typeToPathMap = {
     return import('./assets/queue');
   },
   // NOTE: To be deprecated in favor of queue
-  queue: function queue() {
+  queue: withMetadata(function () {
     return import('./assets/queue');
-  },
-  machineLearningApp: function machineLearningApp() {
+  }, {
+    synonyms: ['queue', 'line', 'buffer', 'waiting', 'jobs']
+  }),
+  machineLearningApp: withMetadata(function () {
     return import('./assets/app_ml');
-  },
+  }, {
+    category: 'app'
+  }),
   magnet: function magnet() {
     return import('./assets/magnet');
   },
-  magnify: function magnify() {
+  magnify: withMetadata(function () {
     return import('./assets/magnify');
-  },
-  magnifyExclamation: function magnifyExclamation() {
+  }, {
+    synonyms: ['search', 'find', 'zoom', 'lookup', 'query', 'discover', 'glass']
+  }),
+  magnifyExclamation: withMetadata(function () {
     return import('./assets/magnify_exclamation');
-  },
-  magnifyMinus: function magnifyMinus() {
+  }, {
+    synonyms: ['search', 'alert', 'warning', 'find', 'magnify', 'important']
+  }),
+  magnifyMinus: withMetadata(function () {
     return import('./assets/magnify_minus');
-  },
-  magnifyPlus: function magnifyPlus() {
+  }, {
+    synonyms: ['zoom out', 'search', 'minus', 'shrink', 'magnify']
+  }),
+  magnifyPlus: withMetadata(function () {
     return import('./assets/magnify_plus');
-  },
+  }, {
+    synonyms: ['zoom in', 'search', 'plus', 'enlarge', 'magnify']
+  }),
   magnifyWithExclamation: function magnifyWithExclamation() {
     return import('./assets/magnify_with_exclamation');
   },
@@ -1331,58 +1898,84 @@ export var typeToPathMap = {
     return import('./assets/magnify_with_plus');
   },
   // NOTE: To be deprecated in favor of magnifyPlus,
-  managementApp: function managementApp() {
+  managementApp: withMetadata(function () {
     return import('./assets/app_management');
-  },
-  map: function map() {
+  }, {
+    category: 'app'
+  }),
+  map: withMetadata(function () {
     return import('./assets/map');
-  },
+  }, {
+    synonyms: ['map', 'location', 'geo', 'geography', 'region']
+  }),
   mapMarker: function mapMarker() {
     return import('./assets/waypoint');
   },
   // NOTE: To be deprecated in favor of waypoint
-  waypoint: function waypoint() {
+  waypoint: withMetadata(function () {
     return import('./assets/waypoint');
-  },
-  megaphone: function megaphone() {
+  }, {
+    synonyms: ['waypoint', 'marker', 'step', 'node', 'path']
+  }),
+  megaphone: withMetadata(function () {
     return import('./assets/megaphone');
-  },
+  }, {
+    synonyms: ['megaphone', 'announce', 'broadcast', 'marketing', 'loud']
+  }),
   memory: function memory() {
     return import('./assets/memory');
   },
-  menu: function menu() {
+  menu: withMetadata(function () {
     return import('./assets/menu');
-  },
+  }, {
+    synonyms: ['menu', 'hamburger', 'navigation', 'options', 'bars']
+  }),
   menuDown: function menuDown() {
     return import('./assets/menu_down');
   },
-  menuLeft: function menuLeft() {
+  menuLeft: withMetadata(function () {
     return import('./assets/menu_left');
-  },
-  menuRight: function menuRight() {
+  }, {
+    synonyms: ['menu left', 'menu', 'hamburger', 'navigation', 'options', 'bars', 'left']
+  }),
+  menuRight: withMetadata(function () {
     return import('./assets/menu_right');
-  },
+  }, {
+    synonyms: ['menu right', 'menu', 'hamburger', 'navigation', 'options', 'bars', 'right']
+  }),
   menuUp: function menuUp() {
     return import('./assets/menu_up');
   },
-  merge: function merge() {
+  merge: withMetadata(function () {
     return import('./assets/merge');
-  },
-  metricbeatApp: function metricbeatApp() {
+  }, {
+    synonyms: ['merge', 'combine', 'join', 'unite', 'git']
+  }),
+  metricbeatApp: withMetadata(function () {
     return import('./assets/app_metricbeat');
-  },
-  metricsApp: function metricsApp() {
+  }, {
+    category: 'app'
+  }),
+  metricsApp: withMetadata(function () {
     return import('./assets/app_metrics');
-  },
-  minimize: function minimize() {
+  }, {
+    category: 'app'
+  }),
+  minimize: withMetadata(function () {
     return import('./assets/minimize');
-  },
-  minus: function minus() {
+  }, {
+    synonyms: ['minimize']
+  }),
+  minus: withMetadata(function () {
     return import('./assets/minus');
-  },
-  minusCircle: function minusCircle() {
+  }, {
+    synonyms: ['minus', 'remove', 'subtract', 'decrement']
+  }),
+  minusCircle: withMetadata(function () {
     return import('./assets/minus_circle');
-  },
+  }, {
+    synonyms: ['minus circle', 'minus', 'remove', 'subtract', 'decrement', 'circle']
+  }),
   minusInCircle: function minusInCircle() {
     return import('./assets/minus_circle');
   },
@@ -1395,27 +1988,37 @@ export var typeToPathMap = {
     return import('./assets/minus_square');
   },
   // NOTE: To be deprecated in favor of minusSquare
-  minusSquare: function minusSquare() {
+  minusSquare: withMetadata(function () {
     return import('./assets/minus_square');
-  },
+  }, {
+    synonyms: ['minus', 'square', 'remove', 'collapse', 'decrement']
+  }),
   mobile: function mobile() {
     return import('./assets/mobile');
   },
-  monitoringApp: function monitoringApp() {
+  monitoringApp: withMetadata(function () {
     return import('./assets/app_monitoring');
-  },
-  moon: function moon() {
+  }, {
+    category: 'app'
+  }),
+  moon: withMetadata(function () {
     return import('./assets/moon');
-  },
-  move: function move() {
+  }, {
+    synonyms: ['moon', 'dark', 'night', 'theme']
+  }),
+  move: withMetadata(function () {
     return import('./assets/move');
-  },
+  }, {
+    synonyms: ['move', 'relocate', 'drag', 'position', 'transfer']
+  }),
   namespace: function namespace() {
     return import('./assets/namespace');
   },
-  nested: function nested() {
+  nested: withMetadata(function () {
     return import('./assets/nested');
-  },
+  }, {
+    synonyms: ['nested', 'hierarchy', 'tree', 'child', 'indent']
+  }),
   newChat: function newChat() {
     return import('./assets/plus_circle');
   },
@@ -1424,71 +2027,105 @@ export var typeToPathMap = {
     return import('./assets/vector_triangle');
   },
   // NOTE: To be deprecated in favor of vectorTriangle
-  vectorTriangle: function vectorTriangle() {
+  vectorTriangle: withMetadata(function () {
     return import('./assets/vector_triangle');
-  },
-  notebookApp: function notebookApp() {
+  }, {
+    synonyms: ['vector', 'triangle', 'shape', 'geometry', 'delta']
+  }),
+  notebookApp: withMetadata(function () {
     return import('./assets/app_notebook');
-  },
-  number: function number() {
+  }, {
+    category: 'app'
+  }),
+  number: withMetadata(function () {
     return import('./assets/number');
-  },
+  }, {
+    synonyms: ['number', 'digit', 'numeric', 'count', 'hash']
+  }),
   offline: function offline() {
     return import('./assets/wifi_slash');
   },
   // NOTE: To be deprecated in favor of wifiSlash
-  wifiSlash: function wifiSlash() {
+  wifiSlash: withMetadata(function () {
     return import('./assets/wifi_slash');
-  },
+  }, {
+    synonyms: ['wifi', 'off', 'disconnected', 'network', 'wireless', 'no signal']
+  }),
   online: function online() {
     return import('./assets/wifi');
   },
   // NOTE: To be deprecated in favor of wifi
-  wifi: function wifi() {
+  wifi: withMetadata(function () {
     return import('./assets/wifi');
-  },
-  outlierDetectionJob: function outlierDetectionJob() {
+  }, {
+    synonyms: ['wifi', 'wireless', 'network', 'internet', 'connection']
+  }),
+  outlierDetectionJob: withMetadata(function () {
     return import('./assets/ml_outlier_detection_job');
-  },
-  package: function _package() {
+  }, {
+    category: 'ml'
+  }),
+  package: withMetadata(function () {
     return import('./assets/package');
-  },
-  packetbeatApp: function packetbeatApp() {
+  }, {
+    synonyms: ['package', 'box', 'bundle', 'npm', 'module']
+  }),
+  packetbeatApp: withMetadata(function () {
     return import('./assets/app_packetbeat');
-  },
+  }, {
+    category: 'app'
+  }),
   pageSelect: function pageSelect() {
     return import('./assets/page_select');
   },
-  pagesSelect: function pagesSelect() {
+  pagesSelect: withMetadata(function () {
     return import('./assets/pages_select');
-  },
-  palette: function palette() {
+  }, {
+    synonyms: ['pages', 'select', 'pagination', 'choose', 'document']
+  }),
+  palette: withMetadata(function () {
     return import('./assets/palette');
-  },
-  paperClip: function paperClip() {
+  }, {
+    synonyms: ['palette', 'colors', 'theme', 'design', 'swatch']
+  }),
+  paperClip: withMetadata(function () {
     return import('./assets/paper_clip');
-  },
-  partial: function partial() {
+  }, {
+    synonyms: ['attachment', 'clip', 'file', 'attach', 'paperclip']
+  }),
+  partial: withMetadata(function () {
     return import('./assets/partial');
-  },
-  pause: function pause() {
+  }, {
+    synonyms: ['partial', 'incomplete', 'fragment', 'section']
+  }),
+  pause: withMetadata(function () {
     return import('./assets/pause');
-  },
+  }, {
+    synonyms: ['pause', 'hold', 'stop temporary', 'wait']
+  }),
   payment: function payment() {
     return import('./assets/payment');
   },
-  pencil: function pencil() {
+  pencil: withMetadata(function () {
     return import('./assets/pencil');
-  },
-  percent: function percent() {
+  }, {
+    synonyms: ['pencil', 'edit', 'write', 'modify', 'pen']
+  }),
+  percent: withMetadata(function () {
     return import('./assets/percent');
-  },
-  pin: function pin() {
+  }, {
+    synonyms: ['percent', 'percentage', 'ratio', 'rate']
+  }),
+  pin: withMetadata(function () {
     return import('./assets/pin');
-  },
-  pinFill: function pinFill() {
+  }, {
+    synonyms: ['pin', 'anchor', 'stick', 'fixed', 'bookmark']
+  }),
+  pinFill: withMetadata(function () {
     return import('./assets/pin_fill');
-  },
+  }, {
+    synonyms: ['pin', 'filled', 'stick', 'anchor', 'fixed', 'bookmark']
+  }),
   pinFilled: function pinFilled() {
     return import('./assets/pin_fill');
   },
@@ -1497,19 +2134,25 @@ export var typeToPathMap = {
     return import('./assets/line_break');
   },
   // NOTE: To be deprecated in favor of lineBreak
-  pipelineApp: function pipelineApp() {
+  pipelineApp: withMetadata(function () {
     return import('./assets/app_pipeline');
-  },
+  }, {
+    category: 'app'
+  }),
   pipeNoBreaks: function pipeNoBreaks() {
     return import('./assets/line_break_slash');
   },
   // NOTE: To be deprecated in favor of lineBreakSlash
-  pivot: function pivot() {
+  pivot: withMetadata(function () {
     return import('./assets/pivot');
-  },
-  play: function play() {
+  }, {
+    synonyms: ['pivot', 'table', 'transform', 'rotate', 'analytics']
+  }),
+  play: withMetadata(function () {
     return import('./assets/play');
-  },
+  }, {
+    synonyms: ['play', 'start', 'run', 'media', 'video']
+  }),
   playFilled: function playFilled() {
     return import('./assets/play_filled');
   },
@@ -1517,12 +2160,16 @@ export var typeToPathMap = {
   plugs: function plugs() {
     return import('./assets/plugs');
   },
-  plus: function plus() {
+  plus: withMetadata(function () {
     return import('./assets/plus');
-  },
-  plusCircle: function plusCircle() {
+  }, {
+    synonyms: ['plus', 'add', 'new', 'create', 'increment']
+  }),
+  plusCircle: withMetadata(function () {
     return import('./assets/plus_circle');
-  },
+  }, {
+    synonyms: ['plus circle', 'plus', 'add', 'new', 'create', 'increment', 'circle']
+  }),
   plusInCircle: function plusInCircle() {
     return import('./assets/plus_circle');
   },
@@ -1535,88 +2182,132 @@ export var typeToPathMap = {
     return import('./assets/plus_square');
   },
   // NOTE: To be deprecated in favor of plusSquare
-  plusSquare: function plusSquare() {
+  plusSquare: withMetadata(function () {
     return import('./assets/plus_square');
-  },
+  }, {
+    synonyms: ['plus', 'square', 'add', 'expand', 'increment']
+  }),
   popout: function popout() {
     return import('./assets/external');
   },
   // NOTE: To be deprecated in favor of external
-  presentation: function presentation() {
+  presentation: withMetadata(function () {
     return import('./assets/presentation');
-  },
+  }, {
+    synonyms: ['presentation', 'slides', 'deck', 'display', 'show']
+  }),
   productRobot: function productRobot() {
     return import('./assets/product_agent');
   },
   // NOTE: To be deprecated in favor of productAgent
-  productAgent: function productAgent() {
+  productAgent: withMetadata(function () {
     return import('./assets/product_agent');
-  },
-  productCloudInfra: function productCloudInfra() {
+  }, {
+    synonyms: ['agent', 'product', 'elastic agent', 'fleet', 'monitoring']
+  }),
+  productCloudInfra: withMetadata(function () {
     return import('./assets/product_cloud_infra');
-  },
-  productDashboard: function productDashboard() {
+  }, {
+    synonyms: ['cloud', 'infrastructure', 'product', 'hosting', 'platform']
+  }),
+  productDashboard: withMetadata(function () {
     return import('./assets/product_dashboard');
-  },
-  productDiscover: function productDiscover() {
+  }, {
+    synonyms: ['dashboard', 'product', 'kibana', 'analytics', 'panel']
+  }),
+  productDiscover: withMetadata(function () {
     return import('./assets/product_discover');
-  },
-  productML: function productML() {
+  }, {
+    synonyms: ['discover', 'product', 'explore', 'data', 'search', 'kibana']
+  }),
+  productML: withMetadata(function () {
     return import('./assets/product_ml');
-  },
-  productStreamsClassic: function productStreamsClassic() {
+  }, {
+    synonyms: ['machine learning', 'ml', 'product', 'model', 'ai']
+  }),
+  productStreamsClassic: withMetadata(function () {
     return import('./assets/product_streams_classic');
-  },
-  productStreamsWired: function productStreamsWired() {
+  }, {
+    synonyms: ['streams', 'classic', 'product', 'data', 'pipeline']
+  }),
+  productStreamsWired: withMetadata(function () {
     return import('./assets/product_streams_wired');
-  },
+  }, {
+    synonyms: ['streams', 'wired', 'product', 'data', 'pipeline', 'connected']
+  }),
   push: function push() {
     return import('./assets/send');
   },
   // NOTE: To be deprecated in favor of send
-  send: function send() {
+  send: withMetadata(function () {
     return import('./assets/send');
-  },
-  question: function question() {
+  }, {
+    synonyms: ['send', 'submit', 'dispatch', 'arrow', 'share']
+  }),
+  question: withMetadata(function () {
     return import('./assets/question');
-  },
-  quote: function quote() {
+  }, {
+    synonyms: ['question', 'help', 'unknown', 'faq', 'ask']
+  }),
+  quote: withMetadata(function () {
     return import('./assets/quote');
-  },
-  radar: function radar() {
+  }, {
+    synonyms: ['quote', 'citation', 'blockquote', 'text']
+  }),
+  radar: withMetadata(function () {
     return import('./assets/radar');
-  },
-  readOnly: function readOnly() {
+  }, {
+    synonyms: ['radar', 'scan', 'detect', 'monitor', 'signal']
+  }),
+  readOnly: withMetadata(function () {
     return import('./assets/read_only');
-  },
-  recentlyViewedApp: function recentlyViewedApp() {
+  }, {
+    synonyms: ['read only', 'locked', 'view', 'permission', 'restrict']
+  }),
+  recentlyViewedApp: withMetadata(function () {
     return import('./assets/app_recently_viewed');
-  },
-  refresh: function refresh() {
+  }, {
+    category: 'app'
+  }),
+  refresh: withMetadata(function () {
     return import('./assets/refresh');
-  },
-  regressionJob: function regressionJob() {
+  }, {
+    synonyms: ['refresh', 'reload', 'sync', 'update', 'rotate']
+  }),
+  regressionJob: withMetadata(function () {
     return import('./assets/ml_regression_job');
-  },
-  reporter: function reporter() {
+  }, {
+    category: 'ml'
+  }),
+  reporter: withMetadata(function () {
     return import('./assets/reporter');
-  },
-  reportingApp: function reportingApp() {
+  }, {
+    synonyms: ['reporter', 'report', 'export', 'document', 'output']
+  }),
+  reportingApp: withMetadata(function () {
     return import('./assets/app_reporting');
-  },
-  return: function _return() {
+  }, {
+    category: 'app'
+  }),
+  return: withMetadata(function () {
     return import('./assets/return');
-  },
+  }, {
+    synonyms: ['return', 'enter', 'keyboard', 'submit', 'back', 'revert']
+  }),
   returnKey: function returnKey() {
     return import('./assets/return');
   },
   // NOTE: To be deprecated in favor of return
-  save: function save() {
+  save: withMetadata(function () {
     return import('./assets/save');
-  },
-  savedObjectsApp: function savedObjectsApp() {
+  }, {
+    synonyms: ['save', 'store', 'disk', 'persist', 'keep']
+  }),
+  savedObjectsApp: withMetadata(function () {
     return import('./assets/app_saved_objects');
-  },
+  }, {
+    category: 'app'
+  }),
   scale: function scale() {
     return import('./assets/scale');
   },
@@ -1624,18 +2315,26 @@ export var typeToPathMap = {
     return import('./assets/magnify');
   },
   // NOTE: To be deprecated in favor of magnify
-  searchProfilerApp: function searchProfilerApp() {
+  searchProfilerApp: withMetadata(function () {
     return import('./assets/app_search_profiler');
-  },
-  section: function section() {
+  }, {
+    category: 'app'
+  }),
+  section: withMetadata(function () {
     return import('./assets/section');
-  },
-  securityAnalyticsApp: function securityAnalyticsApp() {
+  }, {
+    synonyms: ['section', 'region', 'block', 'area', 'group']
+  }),
+  securityAnalyticsApp: withMetadata(function () {
     return import('./assets/app_security_analytics');
-  },
-  securityApp: function securityApp() {
+  }, {
+    category: 'app'
+  }),
+  securityApp: withMetadata(function () {
     return import('./assets/app_security');
-  },
+  }, {
+    category: 'app'
+  }),
   securitySignal: function securitySignal() {
     return import('./assets/security_signal');
   },
@@ -1646,63 +2345,95 @@ export var typeToPathMap = {
   securitySignalResolved: function securitySignalResolved() {
     return import('./assets/security_signal_resolved');
   },
-  server: function server() {
+  server: withMetadata(function () {
     return import('./assets/server');
-  },
+  }, {
+    synonyms: ['server', 'host', 'machine', 'infrastructure', 'backend']
+  }),
   sessionViewer: function sessionViewer() {
     return import('./assets/session_viewer');
   },
-  shard: function shard() {
+  shard: withMetadata(function () {
     return import('./assets/shard');
-  },
-  share: function share() {
+  }, {
+    synonyms: ['shard', 'partition', 'segment', 'elastic', 'index']
+  }),
+  share: withMetadata(function () {
     return import('./assets/share');
-  },
-  significantEvents: function significantEvents() {
+  }, {
+    synonyms: ['share', 'send', 'distribute', 'social', 'export']
+  }),
+  significantEvents: withMetadata(function () {
     return import('./assets/significant_events');
-  },
+  }, {
+    synonyms: ['events', 'significant', 'anomaly', 'alert', 'notable', 'timeline']
+  }),
   singleMetricViewer: function singleMetricViewer() {
     return import('./assets/single_metric_viewer');
   },
-  snowflake: function snowflake() {
+  snowflake: withMetadata(function () {
     return import('./assets/snowflake');
-  },
-  sortAscending: function sortAscending() {
+  }, {
+    synonyms: ['snowflake', 'unique', 'id', 'data warehouse']
+  }),
+  sortAscending: withMetadata(function () {
     return import('./assets/sort_ascending');
-  },
-  sortDescending: function sortDescending() {
+  }, {
+    synonyms: ['sort', 'ascending', 'up', 'order', 'rank', 'increase']
+  }),
+  sortDescending: withMetadata(function () {
     return import('./assets/sort_descending');
-  },
-  sortDown: function sortDown() {
+  }, {
+    synonyms: ['sort', 'descending', 'down', 'order', 'rank', 'decrease']
+  }),
+  sortDown: withMetadata(function () {
     return import('./assets/sort_down');
-  },
-  sortLeft: function sortLeft() {
+  }, {
+    synonyms: ['sort down', 'sort', 'order', 'rank', 'arrange', 'down']
+  }),
+  sortLeft: withMetadata(function () {
     return import('./assets/sort_left');
-  },
-  sortRight: function sortRight() {
+  }, {
+    synonyms: ['sort left', 'sort', 'order', 'rank', 'arrange', 'left']
+  }),
+  sortRight: withMetadata(function () {
     return import('./assets/sort_right');
-  },
-  sortUp: function sortUp() {
+  }, {
+    synonyms: ['sort right', 'sort', 'order', 'rank', 'arrange', 'right']
+  }),
+  sortUp: withMetadata(function () {
     return import('./assets/sort_up');
-  },
-  sortable: function sortable() {
+  }, {
+    synonyms: ['sort up', 'sort', 'order', 'rank', 'arrange', 'up']
+  }),
+  sortable: withMetadata(function () {
     return import('./assets/sortable');
-  },
+  }, {
+    synonyms: ['sortable', 'sort', 'order']
+  }),
   spaces: function spaces() {
     return import('./assets/spaces');
   },
-  spacesApp: function spacesApp() {
+  spacesApp: withMetadata(function () {
     return import('./assets/app_spaces');
-  },
-  sparkles: function sparkles() {
+  }, {
+    category: 'app'
+  }),
+  sparkles: withMetadata(function () {
     return import('./assets/sparkles');
-  },
-  sqlApp: function sqlApp() {
+  }, {
+    synonyms: ['sparkles', 'ai', 'magic', 'new', 'enhance', 'auto']
+  }),
+  sqlApp: withMetadata(function () {
     return import('./assets/app_sql');
-  },
-  star: function star() {
+  }, {
+    category: 'app'
+  }),
+  star: withMetadata(function () {
     return import('./assets/star');
-  },
+  }, {
+    synonyms: ['star', 'favorite', 'rating', 'bookmark']
+  }),
   starEmpty: function starEmpty() {
     return import('./assets/star');
   },
@@ -1710,9 +2441,11 @@ export var typeToPathMap = {
   starEmptySpace: function starEmptySpace() {
     return import('./assets/star_empty_space');
   },
-  starFill: function starFill() {
+  starFill: withMetadata(function () {
     return import('./assets/star_fill');
-  },
+  }, {
+    synonyms: ['star fill', 'star', 'favorite', 'rating', 'bookmark', 'fill', 'filled', 'solid']
+  }),
   starFilled: function starFilled() {
     return import('./assets/star_fill');
   },
@@ -1747,9 +2480,11 @@ export var typeToPathMap = {
   stats: function stats() {
     return import('./assets/stats');
   },
-  stop: function stop() {
+  stop: withMetadata(function () {
     return import('./assets/stop');
-  },
+  }, {
+    synonyms: ['stop', 'halt', 'end', 'terminate', 'square']
+  }),
   stopFill: function stopFill() {
     return import('./assets/stop_fill');
   },
@@ -1760,9 +2495,11 @@ export var typeToPathMap = {
   stopSlash: function stopSlash() {
     return import('./assets/stop_slash');
   },
-  storage: function storage() {
+  storage: withMetadata(function () {
     return import('./assets/storage');
-  },
+  }, {
+    synonyms: ['storage', 'disk', 'drive', 'save', 'data store']
+  }),
   streamsClassic: function streamsClassic() {
     return import('./assets/product_streams_classic');
   },
@@ -1778,30 +2515,38 @@ export var typeToPathMap = {
     return import('./assets/merge');
   },
   // NOTE: To be deprecated in favor of `merge`
-  sun: function sun() {
+  sun: withMetadata(function () {
     return import('./assets/sun');
-  },
+  }, {
+    synonyms: ['sun', 'light', 'day', 'theme', 'bright']
+  }),
   swatchInput: function swatchInput() {
     return import('./assets/swatch_input');
   },
   // Undocumented on purpose. Has an extra stroke for EuiColorPicker
-  symlink: function symlink() {
+  symlink: withMetadata(function () {
     return import('./assets/symlink');
-  },
+  }, {
+    synonyms: ['symlink', 'shortcut', 'alias', 'link', 'reference']
+  }),
   tableDensityCompact: function tableDensityCompact() {
     return import('./assets/table_density_high');
   },
   // NOTE: To be deprecated in favor of tableDensityHigh
-  tableDensityHigh: function tableDensityHigh() {
+  tableDensityHigh: withMetadata(function () {
     return import('./assets/table_density_high');
-  },
+  }, {
+    synonyms: ['table', 'density', 'compact', 'tight', 'rows', 'spacing']
+  }),
   tableDensityExpanded: function tableDensityExpanded() {
     return import('./assets/table_density_low');
   },
   // NOTE: To be deprecated in favor of tableDensityLow
-  tableDensityLow: function tableDensityLow() {
+  tableDensityLow: withMetadata(function () {
     return import('./assets/table_density_low');
-  },
+  }, {
+    synonyms: ['table', 'density', 'spacious', 'loose', 'rows', 'spacing']
+  }),
   tableDensityNormal: function tableDensityNormal() {
     return import('./assets/table');
   },
@@ -1809,9 +2554,11 @@ export var typeToPathMap = {
   tableOfContents: function tableOfContents() {
     return import('./assets/table_of_contents');
   },
-  tag: function tag() {
+  tag: withMetadata(function () {
     return import('./assets/tag');
-  },
+  }, {
+    synonyms: ['tag', 'label', 'category', 'keyword', 'badge']
+  }),
   tear: function tear() {
     return import('./assets/tear');
   },
@@ -1819,31 +2566,45 @@ export var typeToPathMap = {
     return import('./assets/thermometer');
   },
   // NOTE: To be deprecated in favor of thermometer
-  thermometer: function thermometer() {
+  thermometer: withMetadata(function () {
     return import('./assets/thermometer');
-  },
-  thumbDown: function thumbDown() {
+  }, {
+    synonyms: ['thermometer', 'temperature', 'heat', 'metric', 'gauge']
+  }),
+  thumbDown: withMetadata(function () {
     return import('./assets/thumb_down');
-  },
-  thumbUp: function thumbUp() {
+  }, {
+    synonyms: ['thumbs down', 'dislike', 'negative', 'vote', 'feedback', 'bad']
+  }),
+  thumbUp: withMetadata(function () {
     return import('./assets/thumb_up');
-  },
-  timeline: function timeline() {
+  }, {
+    synonyms: ['thumbs up', 'like', 'positive', 'vote', 'feedback', 'good']
+  }),
+  timeline: withMetadata(function () {
     return import('./assets/timeline');
-  },
-  timelineWithArrow: function timelineWithArrow() {
+  }, {
+    synonyms: ['timeline', 'history', 'events', 'chronological', 'sequence']
+  }),
+  timelineWithArrow: withMetadata(function () {
     return import('./assets/timeline_with_arrow');
-  },
-  timelionApp: function timelionApp() {
+  }, {
+    synonyms: ['timeline', 'arrow', 'history', 'sequence', 'flow', 'events']
+  }),
+  timelionApp: withMetadata(function () {
     return import('./assets/app_timelion');
-  },
+  }, {
+    category: 'app'
+  }),
   timeRefresh: function timeRefresh() {
     return import('./assets/refresh_time');
   },
   // NOTE: To be deprecated in favor of refreshTime
-  refreshTime: function refreshTime() {
+  refreshTime: withMetadata(function () {
     return import('./assets/refresh_time');
-  },
+  }, {
+    synonyms: ['refresh', 'time', 'reload', 'schedule', 'sync', 'clock']
+  }),
   timeslider: function timeslider() {
     return import('./assets/clock_control');
   },
@@ -1852,27 +2613,41 @@ export var typeToPathMap = {
     return import('./assets/presentation');
   },
   // NOTE: To be deprecated in favor of presentation,
-  transitionBottomIn: function transitionBottomIn() {
+  transitionBottomIn: withMetadata(function () {
     return import('./assets/transition_bottom_in');
-  },
-  transitionBottomOut: function transitionBottomOut() {
+  }, {
+    synonyms: ['transition', 'bottom', 'in', 'animate', 'enter', 'motion']
+  }),
+  transitionBottomOut: withMetadata(function () {
     return import('./assets/transition_bottom_out');
-  },
-  transitionLeftIn: function transitionLeftIn() {
+  }, {
+    synonyms: ['transition', 'bottom', 'out', 'animate', 'exit', 'motion']
+  }),
+  transitionLeftIn: withMetadata(function () {
     return import('./assets/transition_left_in');
-  },
-  transitionLeftOut: function transitionLeftOut() {
+  }, {
+    synonyms: ['transition', 'left', 'in', 'animate', 'enter', 'motion']
+  }),
+  transitionLeftOut: withMetadata(function () {
     return import('./assets/transition_left_out');
-  },
-  transitionTopIn: function transitionTopIn() {
+  }, {
+    synonyms: ['transition', 'left', 'out', 'animate', 'exit', 'motion']
+  }),
+  transitionTopIn: withMetadata(function () {
     return import('./assets/transition_top_in');
-  },
-  transitionTopOut: function transitionTopOut() {
+  }, {
+    synonyms: ['transition', 'top', 'in', 'animate', 'enter', 'motion']
+  }),
+  transitionTopOut: withMetadata(function () {
     return import('./assets/transition_top_out');
-  },
-  trash: function trash() {
+  }, {
+    synonyms: ['transition', 'top', 'out', 'animate', 'exit', 'motion']
+  }),
+  trash: withMetadata(function () {
     return import('./assets/trash');
-  },
+  }, {
+    synonyms: ['trash', 'delete', 'remove', 'bin', 'garbage', 'discard']
+  }),
   unfold: function unfold() {
     return import('./assets/unfold');
   },
@@ -1880,38 +2655,54 @@ export var typeToPathMap = {
     return import('./assets/link_slash');
   },
   // NOTE: To be deprecated in favor of linkSlash
-  upgradeAssistantApp: function upgradeAssistantApp() {
+  upgradeAssistantApp: withMetadata(function () {
     return import('./assets/app_upgrade_assistant');
-  },
-  uptimeApp: function uptimeApp() {
+  }, {
+    category: 'app'
+  }),
+  uptimeApp: withMetadata(function () {
     return import('./assets/app_uptime');
-  },
-  user: function user() {
+  }, {
+    category: 'app'
+  }),
+  user: withMetadata(function () {
     return import('./assets/user');
-  },
+  }, {
+    synonyms: ['user', 'person', 'account', 'profile', 'avatar']
+  }),
   userAvatar: function userAvatar() {
     return import('./assets/user');
   },
   // NOTE: To be deprecated in favor of `user`
-  users: function users() {
+  users: withMetadata(function () {
     return import('./assets/users');
-  },
-  usersRolesApp: function usersRolesApp() {
+  }, {
+    synonyms: ['users', 'people', 'team', 'group', 'accounts']
+  }),
+  usersRolesApp: withMetadata(function () {
     return import('./assets/app_users_roles');
-  },
-  unarchive: function unarchive() {
+  }, {
+    category: 'app'
+  }),
+  unarchive: withMetadata(function () {
     return import('./assets/unarchive');
-  },
+  }, {
+    synonyms: ['unarchive', 'restore', 'extract', 'retrieve', 'unpack']
+  }),
   vector: function vector() {
     return import('./assets/vector_square');
   },
   // NOTE: To be deprecated in favor of vectorSquare
-  vectorSquare: function vectorSquare() {
+  vectorSquare: withMetadata(function () {
     return import('./assets/vector_square');
-  },
-  videoPlayer: function videoPlayer() {
+  }, {
+    synonyms: ['vector', 'square', 'shape', 'geometry', 'box', 'region']
+  }),
+  videoPlayer: withMetadata(function () {
     return import('./assets/video_player');
-  },
+  }, {
+    synonyms: ['video', 'player', 'play', 'media', 'film', 'watch']
+  }),
   visArea: function visArea() {
     return import('./assets/chart_area');
   },
@@ -1959,9 +2750,11 @@ export var typeToPathMap = {
     return import('./assets/chart_metric');
   },
   // NOTE: To be deprecated in favor of chartMetric
-  chartMetric: function chartMetric() {
+  chartMetric: withMetadata(function () {
     return import('./assets/chart_metric');
-  },
+  }, {
+    synonyms: ['metric', 'chart', 'kpi', 'measurement', 'stat', 'indicator']
+  }),
   visPie: function visPie() {
     return import('./assets/chart_pie');
   },
@@ -1988,25 +2781,35 @@ export var typeToPathMap = {
   visVisualBuilder: function visVisualBuilder() {
     return import('./assets/vis_visual_builder');
   },
-  visualizeApp: function visualizeApp() {
+  visualizeApp: withMetadata(function () {
     return import('./assets/app_visualize');
-  },
-  vulnerabilityManagementApp: function vulnerabilityManagementApp() {
+  }, {
+    category: 'app'
+  }),
+  vulnerabilityManagementApp: withMetadata(function () {
     return import('./assets/app_vulnerability_management');
-  },
-  warning: function warning() {
+  }, {
+    category: 'app'
+  }),
+  warning: withMetadata(function () {
     return import('./assets/warning');
-  },
+  }, {
+    synonyms: ['warning', 'alert', 'caution', 'danger', 'issue']
+  }),
   warningFilled: function warningFilled() {
     return import('./assets/warning_fill');
   },
   // NOTE: To be deprecated in favor of warningFill
-  warningFill: function warningFill() {
+  warningFill: withMetadata(function () {
     return import('./assets/warning_fill');
-  },
-  watchesApp: function watchesApp() {
+  }, {
+    synonyms: ['warning fill', 'warning', 'alert', 'caution', 'danger', 'issue', 'fill', 'filled']
+  }),
+  watchesApp: withMetadata(function () {
     return import('./assets/app_watches');
-  },
+  }, {
+    category: 'app'
+  }),
   web: function web() {
     return import('./assets/web');
   },
@@ -2016,189 +2819,357 @@ export var typeToPathMap = {
   wordWrapDisabled: function wordWrapDisabled() {
     return import('./assets/word_wrap_disabled');
   },
-  workflowsApp: function workflowsApp() {
+  workflowsApp: withMetadata(function () {
     return import('./assets/app_workflows');
-  },
-  workflow: function workflow() {
+  }, {
+    category: 'app'
+  }),
+  workflow: withMetadata(function () {
     return import('./assets/workflow');
-  },
-  workplaceSearchApp: function workplaceSearchApp() {
+  }, {
+    synonyms: ['workflow', 'automation', 'pipeline', 'process', 'flow']
+  }),
+  workplaceSearchApp: withMetadata(function () {
     return import('./assets/app_workplace_search');
-  },
-  wrench: function wrench() {
+  }, {
+    category: 'app'
+  }),
+  wrench: withMetadata(function () {
     return import('./assets/wrench');
-  },
+  }, {
+    synonyms: ['wrench', 'tool', 'fix', 'settings', 'repair']
+  }),
   // Token Icon Imports
-  tokenAlias: function tokenAlias() {
+  tokenAlias: withMetadata(function () {
     return import('./assets/token_alias');
-  },
-  tokenAnnotation: function tokenAnnotation() {
+  }, {
+    category: 'token'
+  }),
+  tokenAnnotation: withMetadata(function () {
     return import('./assets/token_annotation');
-  },
-  tokenArray: function tokenArray() {
+  }, {
+    category: 'token'
+  }),
+  tokenArray: withMetadata(function () {
     return import('./assets/token_array');
-  },
-  tokenBinary: function tokenBinary() {
+  }, {
+    category: 'token'
+  }),
+  tokenBinary: withMetadata(function () {
     return import('./assets/token_binary');
-  },
-  tokenBoolean: function tokenBoolean() {
+  }, {
+    category: 'token'
+  }),
+  tokenBoolean: withMetadata(function () {
     return import('./assets/token_boolean');
-  },
-  tokenClass: function tokenClass() {
+  }, {
+    category: 'token'
+  }),
+  tokenClass: withMetadata(function () {
     return import('./assets/token_class');
-  },
-  tokenCompletionSuggester: function tokenCompletionSuggester() {
+  }, {
+    category: 'token'
+  }),
+  tokenCompletionSuggester: withMetadata(function () {
     return import('./assets/token_completion_suggester');
-  },
-  tokenConstant: function tokenConstant() {
+  }, {
+    category: 'token'
+  }),
+  tokenConstant: withMetadata(function () {
     return import('./assets/token_constant');
-  },
-  tokenDate: function tokenDate() {
+  }, {
+    category: 'token'
+  }),
+  tokenDate: withMetadata(function () {
     return import('./assets/token_date');
-  },
-  tokenDimension: function tokenDimension() {
+  }, {
+    category: 'token'
+  }),
+  tokenDimension: withMetadata(function () {
     return import('./assets/token_dimension');
-  },
-  tokenElement: function tokenElement() {
+  }, {
+    category: 'token'
+  }),
+  tokenElement: withMetadata(function () {
     return import('./assets/token_element');
-  },
-  tokenEnum: function tokenEnum() {
+  }, {
+    category: 'token'
+  }),
+  tokenEnum: withMetadata(function () {
     return import('./assets/token_enum');
-  },
-  tokenEnumMember: function tokenEnumMember() {
+  }, {
+    category: 'token'
+  }),
+  tokenEnumMember: withMetadata(function () {
     return import('./assets/token_enum_member');
-  },
-  tokenEvent: function tokenEvent() {
+  }, {
+    category: 'token'
+  }),
+  tokenEvent: withMetadata(function () {
     return import('./assets/token_event');
-  },
-  tokenException: function tokenException() {
+  }, {
+    category: 'token'
+  }),
+  tokenException: withMetadata(function () {
     return import('./assets/token_exception');
-  },
-  tokenField: function tokenField() {
+  }, {
+    category: 'token'
+  }),
+  tokenField: withMetadata(function () {
     return import('./assets/token_field');
-  },
-  tokenFile: function tokenFile() {
+  }, {
+    category: 'token'
+  }),
+  tokenFile: withMetadata(function () {
     return import('./assets/token_file');
-  },
-  tokenFlattened: function tokenFlattened() {
+  }, {
+    category: 'token'
+  }),
+  tokenFlattened: withMetadata(function () {
     return import('./assets/token_flattened');
-  },
-  tokenFunction: function tokenFunction() {
+  }, {
+    category: 'token'
+  }),
+  tokenFunction: withMetadata(function () {
     return import('./assets/token_function');
-  },
-  tokenGeo: function tokenGeo() {
+  }, {
+    category: 'token'
+  }),
+  tokenGeo: withMetadata(function () {
     return import('./assets/token_geo');
-  },
-  tokenHistogram: function tokenHistogram() {
+  }, {
+    category: 'token'
+  }),
+  tokenHistogram: withMetadata(function () {
     return import('./assets/token_histogram');
-  },
-  tokenInterface: function tokenInterface() {
+  }, {
+    category: 'token'
+  }),
+  tokenInterface: withMetadata(function () {
     return import('./assets/token_interface');
-  },
-  tokenIP: function tokenIP() {
+  }, {
+    category: 'token'
+  }),
+  tokenIP: withMetadata(function () {
     return import('./assets/token_ip');
-  },
-  tokenJoin: function tokenJoin() {
+  }, {
+    category: 'token'
+  }),
+  tokenJoin: withMetadata(function () {
     return import('./assets/token_join');
-  },
-  tokenKey: function tokenKey() {
+  }, {
+    category: 'token'
+  }),
+  tokenKey: withMetadata(function () {
     return import('./assets/token_key');
-  },
-  tokenKeyword: function tokenKeyword() {
+  }, {
+    category: 'token'
+  }),
+  tokenKeyword: withMetadata(function () {
     return import('./assets/token_keyword');
-  },
-  tokenMethod: function tokenMethod() {
+  }, {
+    category: 'token'
+  }),
+  tokenMethod: withMetadata(function () {
     return import('./assets/token_method');
-  },
-  tokenMetricCounter: function tokenMetricCounter() {
+  }, {
+    category: 'token'
+  }),
+  tokenMetricCounter: withMetadata(function () {
     return import('./assets/token_metric_counter');
-  },
-  tokenMetricGauge: function tokenMetricGauge() {
+  }, {
+    category: 'token'
+  }),
+  tokenMetricGauge: withMetadata(function () {
     return import('./assets/token_metric_gauge');
-  },
-  tokenModule: function tokenModule() {
+  }, {
+    category: 'token'
+  }),
+  tokenModule: withMetadata(function () {
     return import('./assets/token_module');
-  },
-  tokenNamespace: function tokenNamespace() {
+  }, {
+    category: 'token'
+  }),
+  tokenNamespace: withMetadata(function () {
     return import('./assets/token_namespace');
-  },
-  tokenNested: function tokenNested() {
+  }, {
+    category: 'token'
+  }),
+  tokenNested: withMetadata(function () {
     return import('./assets/token_nested');
-  },
-  tokenNull: function tokenNull() {
+  }, {
+    category: 'token'
+  }),
+  tokenNull: withMetadata(function () {
     return import('./assets/token_null');
-  },
-  tokenNumber: function tokenNumber() {
+  }, {
+    category: 'token'
+  }),
+  tokenNumber: withMetadata(function () {
     return import('./assets/token_number');
-  },
-  tokenObject: function tokenObject() {
+  }, {
+    category: 'token'
+  }),
+  tokenObject: withMetadata(function () {
     return import('./assets/token_object');
-  },
-  tokenOperator: function tokenOperator() {
+  }, {
+    category: 'token'
+  }),
+  tokenOperator: withMetadata(function () {
     return import('./assets/token_operator');
-  },
-  tokenPackage: function tokenPackage() {
+  }, {
+    category: 'token'
+  }),
+  tokenPackage: withMetadata(function () {
     return import('./assets/token_package');
-  },
-  tokenParameter: function tokenParameter() {
+  }, {
+    category: 'token'
+  }),
+  tokenParameter: withMetadata(function () {
     return import('./assets/token_parameter');
-  },
-  tokenPercolator: function tokenPercolator() {
+  }, {
+    category: 'token'
+  }),
+  tokenPercolator: withMetadata(function () {
     return import('./assets/token_percolator');
-  },
-  tokenProperty: function tokenProperty() {
+  }, {
+    category: 'token'
+  }),
+  tokenProperty: withMetadata(function () {
     return import('./assets/token_property');
-  },
-  tokenRange: function tokenRange() {
+  }, {
+    category: 'token'
+  }),
+  tokenRange: withMetadata(function () {
     return import('./assets/token_range');
-  },
-  tokenRankFeature: function tokenRankFeature() {
+  }, {
+    category: 'token'
+  }),
+  tokenRankFeature: withMetadata(function () {
     return import('./assets/token_rank_feature');
-  },
-  tokenRankFeatures: function tokenRankFeatures() {
+  }, {
+    category: 'token'
+  }),
+  tokenRankFeatures: withMetadata(function () {
     return import('./assets/token_rank_features');
-  },
-  tokenRepo: function tokenRepo() {
+  }, {
+    category: 'token'
+  }),
+  tokenRepo: withMetadata(function () {
     return import('./assets/token_repo');
-  },
-  tokenSearchType: function tokenSearchType() {
+  }, {
+    category: 'token'
+  }),
+  tokenSearchType: withMetadata(function () {
     return import('./assets/token_search_type');
-  },
-  tokenSemanticText: function tokenSemanticText() {
+  }, {
+    category: 'token'
+  }),
+  tokenSemanticText: withMetadata(function () {
     return import('./assets/token_semantic_text');
-  },
-  tokenShape: function tokenShape() {
+  }, {
+    category: 'token'
+  }),
+  tokenShape: withMetadata(function () {
     return import('./assets/token_shape');
-  },
-  tokenString: function tokenString() {
+  }, {
+    category: 'token'
+  }),
+  tokenString: withMetadata(function () {
     return import('./assets/token_string');
-  },
-  tokenStruct: function tokenStruct() {
+  }, {
+    category: 'token'
+  }),
+  tokenStruct: withMetadata(function () {
     return import('./assets/token_struct');
-  },
-  tokenSymbol: function tokenSymbol() {
+  }, {
+    category: 'token'
+  }),
+  tokenSymbol: withMetadata(function () {
     return import('./assets/token_symbol');
-  },
-  tokenTag: function tokenTag() {
+  }, {
+    category: 'token'
+  }),
+  tokenTag: withMetadata(function () {
     return import('./assets/token_tag');
-  },
-  tokenText: function tokenText() {
+  }, {
+    category: 'token'
+  }),
+  tokenText: withMetadata(function () {
     return import('./assets/token_text');
-  },
-  tokenTokenCount: function tokenTokenCount() {
+  }, {
+    category: 'token'
+  }),
+  tokenTokenCount: withMetadata(function () {
     return import('./assets/token_token_count');
-  },
-  tokenVariable: function tokenVariable() {
+  }, {
+    category: 'token'
+  }),
+  tokenVariable: withMetadata(function () {
     return import('./assets/token_variable');
-  },
-  tokenVectorDense: function tokenVectorDense() {
+  }, {
+    category: 'token'
+  }),
+  tokenVectorDense: withMetadata(function () {
     return import('./assets/token_vector_dense');
-  },
-  tokenDenseVector: function tokenDenseVector() {
+  }, {
+    category: 'token'
+  }),
+  tokenDenseVector: withMetadata(function () {
     return import('./assets/token_vector_dense');
-  },
-  // NOTE: This is an undocumented alias for `tokenVectorDense`, added for legacy compatability
-  tokenVectorSparse: function tokenVectorSparse() {
+  }, {
+    category: 'token'
+  }),
+  // NOTE: This is an undocumented alias for `tokenVectorDense`, added for legacy compatibility
+  tokenVectorSparse: withMetadata(function () {
     return import('./assets/token_vector_sparse');
-  }
-};
+  }, {
+    category: 'token'
+  })
+};
+var getTypeToPathMapMetadata = function getTypeToPathMapMetadata(loader) {
+  var _metadata$category;
+  var metadata = loader.metadata;
+  return {
+    category: (_metadata$category = metadata === null || metadata === void 0 ? void 0 : metadata.category) !== null && _metadata$category !== void 0 ? _metadata$category : 'glyph',
+    synonyms: metadata === null || metadata === void 0 ? void 0 : metadata.synonyms
+  };
+};
+/* List of icon types that are deprecated and should not be used in new code. 
+These icons will be removed in a future release. But we need to keep them to
+maintain backward compatibility. */
+export var typeToPathMapDeprecatedIconTypes = ['alert', 'anomalyChart', 'apmTrace', 'arrowDown', 'arrowLeft', 'arrowRight', 'arrowUp', 'arrowStart', 'arrowEnd', 'beaker', 'boxesHorizontal', 'changePointDetection', 'checkInCircleFilled', 'cheer', 'color', 'compute', 'console', 'contrastHigh', 'controlsHorizontal', 'controlsVertical', 'copyClipboard', 'crossInCircle', 'crosshairs', 'currency', 'cut', 'desktop', 'diff', 'discuss', 'documentEdit', 'doubleArrowLeft', 'doubleArrowRight', 'editorAlignCenter', 'editorAlignLeft', 'editorAlignRight', 'editorBold', 'editorChecklist', 'editorCodeBlock', 'editorComment', 'editorDistributeHorizontal', 'editorDistributeVertical', 'editorHeading', 'editorItalic', 'editorItemAlignBottom', 'editorItemAlignCenter', 'editorItemAlignLeft', 'editorItemAlignMiddle', 'editorItemAlignRight', 'editorItemAlignTop', 'editorLink', 'editorOrderedList', 'editorPositionBottomLeft', 'editorPositionBottomRight', 'editorPositionTopLeft', 'editorPositionTopRight', 'editorRedo', 'editorStrike', 'editorTable', 'editorUnderline', 'editorUndo', 'editorUnorderedList', 'email', 'eql', 'errorFilled', 'exit', 'expand', 'expandMini', 'exportAction', 'eyeClosed', 'fieldStatistics', 'filterInCircle', 'glasses', 'grab', 'grabHorizontal', 'grabOmnidirectional', 'heatmap', 'importAction', 'indexFlush', 'indexMapping', 'indexTemporary', 'invert', 'kqlField', 'kqlOperand', 'kqlSelector', 'kqlValue', 'launch', 'lettering', 'lineDashed', 'lineDotted', 'list', 'listAdd', 'logPatternAnalysis', 'logstashIf', 'logstashQueue', 'magnifyWithExclamation', 'magnifyWithMinus', 'magnifyWithPlus', 'mapMarker', 'minusInCircle', 'minusInCircleFilled', 'minusInSquare', 'newChat', 'node', 'offline', 'online', 'pinFilled', 'pipeBreaks', 'pipeNoBreaks', 'playFilled', 'plusInCircle', 'plusInCircleFilled', 'plusInSquare', 'popout', 'productRobot', 'push', 'returnKey', 'search', 'securitySignal', 'starEmpty', 'starFilled', 'starFilledSpace', 'starMinusFilled', 'starPlusFilled', 'stopFilled', 'streamsClassic', 'streamsWired', 'submodule', 'tableDensityCompact', 'tableDensityExpanded', 'tableDensityNormal', 'temperature', 'timeRefresh', 'timeslider', 'training', 'unlink', 'userAvatar', 'vector', 'visArea', 'visAreaStacked', 'visBarHorizontal', 'visBarHorizontalStacked', 'visBarVertical', 'visBarVerticalStacked', 'visGauge', 'visLine', 'visMapCoordinate', 'visMapRegion', 'visMetric', 'visPie', 'visTable', 'visTagCloud', 'visText', 'visVega', 'warningFilled'];
+var typeToPathMapDeprecatedIconTypesSet = new Set(typeToPathMapDeprecatedIconTypes);
+var getTypeToPathMapNonDeprecatedIconTypes = function getTypeToPathMapNonDeprecatedIconTypes(iconTypes) {
+  return iconTypes.filter(function (iconType) {
+    return !typeToPathMapDeprecatedIconTypesSet.has(iconType);
+  });
+};
+var getTypeToPathMapCategoryIconTypes = function getTypeToPathMapCategoryIconTypes(category) {
+  return Object.entries(typeToPathMap).filter(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      loader = _ref2[1];
+    return getTypeToPathMapMetadata(loader).category === category;
+  }).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 1),
+      iconType = _ref4[0];
+    return iconType;
+  });
+};
+export var typeToPathMapAppIconTypes = getTypeToPathMapCategoryIconTypes('app');
+export var typeToPathMapGlyphIconTypes = getTypeToPathMapCategoryIconTypes('glyph');
+export var typeToPathMapLogoIconTypes = getTypeToPathMapCategoryIconTypes('elasticLogo');
+export var typeToPathMapMlIconTypes = getTypeToPathMapCategoryIconTypes('ml');
+export var typeToPathMapTokenIconTypes = getTypeToPathMapCategoryIconTypes('token');
+export var typeToPathMapDocsAppIconTypes = getTypeToPathMapNonDeprecatedIconTypes(typeToPathMapAppIconTypes);
+export var typeToPathMapDocsGlyphIconTypes = getTypeToPathMapNonDeprecatedIconTypes(typeToPathMapGlyphIconTypes);
+export var typeToPathMapDocsLogoIconTypes = getTypeToPathMapNonDeprecatedIconTypes(typeToPathMapLogoIconTypes);
+export var typeToPathMapDocsMlIconTypes = getTypeToPathMapNonDeprecatedIconTypes(typeToPathMapMlIconTypes);
+export var typeToPathMapDocsTokenIconTypes = getTypeToPathMapNonDeprecatedIconTypes(typeToPathMapTokenIconTypes);
+export var typeToPathMapSynonyms = Object.fromEntries(Object.entries(typeToPathMap).flatMap(function (_ref5) {
+  var _ref6 = _slicedToArray(_ref5, 2),
+    iconType = _ref6[0],
+    loader = _ref6[1];
+  var synonyms = getTypeToPathMapMetadata(loader).synonyms;
+  return synonyms ? [[iconType, synonyms]] : [];
+}));