@elastic/eui 117.0.0-snapshot.1783954480414 → 117.0.0

package/es/components/icon/icon_map.js

@@ -1,9 +1,3 @@
-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
@@ -12,96 +6,58 @@ function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
  * 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: withMetadata(function () {
+  accessibility: function accessibility() {
     return import('./assets/accessibility');
-  }, {
-    synonyms: ['a11y', 'inclusive', 'disability', 'wcag', 'assistive', 'screen reader', 'universal design']
-  }),
-  addDataApp: withMetadata(function () {
+  },
+  addDataApp: function addDataApp() {
     return import('./assets/app_add_data');
-  }, {
-    category: 'app'
-  }),
+  },
   addToChat: function addToChat() {
     return import('./assets/add_to_chat');
   },
-  addToDashboard: withMetadata(function () {
+  addToDashboard: function addToDashboard() {
     return import('./assets/add_to_dashboard');
-  }, {
-    synonyms: ['dashboard', 'add', 'pin', 'widget', 'panel', 'insert', 'save view']
-  }),
-  advancedSettingsApp: withMetadata(function () {
+  },
+  advancedSettingsApp: function advancedSettingsApp() {
     return import('./assets/app_advanced_settings');
-  }, {
-    category: 'app'
-  }),
-  agentApp: withMetadata(function () {
+  },
+  agentApp: function agentApp() {
     return import('./assets/app_fleet');
-  }, {
-    category: 'app'
-  }),
-  aggregate: withMetadata(function () {
+  },
+  aggregate: function aggregate() {
     return import('./assets/aggregate');
-  }, {
-    synonyms: ['combine', 'sum', 'group', 'collection', 'merge', 'total', 'rollup']
-  }),
-  alignBottom: withMetadata(function () {
+  },
+  alignBottom: function alignBottom() {
     return import('./assets/align_bottom');
-  }, {
-    synonyms: ['align', 'bottom', 'vertical', 'position', 'layout', 'dock']
-  }),
-  alignBottomLeft: withMetadata(function () {
+  },
+  alignBottomLeft: function alignBottomLeft() {
     return import('./assets/align_bottom_left');
-  }, {
-    synonyms: ['align', 'bottom', 'left', 'corner', 'position', 'layout']
-  }),
-  alignBottomRight: withMetadata(function () {
+  },
+  alignBottomRight: function alignBottomRight() {
     return import('./assets/align_bottom_right');
-  }, {
-    synonyms: ['align', 'bottom', 'right', 'corner', 'position', 'layout']
-  }),
-  alignCenterHorizontal: withMetadata(function () {
+  },
+  alignCenterHorizontal: function alignCenterHorizontal() {
     return import('./assets/align_center_horizontal');
-  }, {
-    synonyms: ['align', 'center', 'horizontal', 'middle', 'position', 'layout']
-  }),
-  alignCenterVertical: withMetadata(function () {
+  },
+  alignCenterVertical: function alignCenterVertical() {
     return import('./assets/align_center_vertical');
-  }, {
-    synonyms: ['align', 'center', 'vertical', 'middle', 'position', 'layout']
-  }),
-  alignLeft: withMetadata(function () {
+  },
+  alignLeft: function alignLeft() {
     return import('./assets/align_left');
-  }, {
-    synonyms: ['align', 'left', 'horizontal', 'position', 'layout', 'flush']
-  }),
-  alignRight: withMetadata(function () {
+  },
+  alignRight: function alignRight() {
     return import('./assets/align_right');
-  }, {
-    synonyms: ['align', 'right', 'horizontal', 'position', 'layout', 'flush']
-  }),
-  alignTop: withMetadata(function () {
+  },
+  alignTop: function alignTop() {
     return import('./assets/align_top');
-  }, {
-    synonyms: ['align', 'top', 'vertical', 'position', 'layout', 'dock']
-  }),
-  alignTopLeft: withMetadata(function () {
+  },
+  alignTopLeft: function alignTopLeft() {
     return import('./assets/align_top_left');
-  }, {
-    synonyms: ['align', 'top', 'left', 'corner', 'position', 'layout']
-  }),
-  alignTopRight: withMetadata(function () {
+  },
+  alignTopRight: function alignTopRight() {
     return import('./assets/align_top_right');
-  }, {
-    synonyms: ['align', 'top', 'right', 'corner', 'position', 'layout']
-  }),
+  },
   alert: function alert() {
     return import('./assets/warning');
   },
@@ -116,33 +72,25 @@ export var typeToPathMap = {
     return import('./assets/chart_anomaly');
   },
   // NOTE: To be deprecated in favor of chartAnomaly
-  chartAnomaly: withMetadata(function () {
+  chartAnomaly: function chartAnomaly() {
     return import('./assets/chart_anomaly');
-  }, {
-    synonyms: ['anomaly', 'chart', 'outlier', 'detection', 'spike', 'unusual']
-  }),
+  },
   anomalySwimLane: function anomalySwimLane() {
     return import('./assets/anomaly_swim_lane');
   },
-  apmApp: withMetadata(function () {
+  apmApp: function apmApp() {
     return import('./assets/app_apm');
-  }, {
-    category: 'app'
-  }),
+  },
   apmTrace: function apmTrace() {
     return import('./assets/chart_waterfall');
   },
   // NOTE: To be deprecated in favor of chartWaterfall
-  chartWaterfall: withMetadata(function () {
+  chartWaterfall: function chartWaterfall() {
     return import('./assets/chart_waterfall');
-  }, {
-    synonyms: ['waterfall chart', 'cascade', 'steps', 'bridge', 'cumulative', 'breakdown']
-  }),
-  appSearchApp: withMetadata(function () {
+  },
+  appSearchApp: function appSearchApp() {
     return import('./assets/app_app_search');
-  }, {
-    category: 'app'
-  }),
+  },
   apps: function apps() {
     return import('./assets/apps');
   },
@@ -150,123 +98,87 @@ export var typeToPathMap = {
     return import('./assets/chevron_single_down');
   },
   // NOTE: To be deprecated in favor of chevronSingleDown
-  chevronSingleDown: withMetadata(function () {
+  chevronSingleDown: function chevronSingleDown() {
     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: withMetadata(function () {
+  chevronSingleLeft: function chevronSingleLeft() {
     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 chevronSingleRight
-  chevronSingleRight: withMetadata(function () {
+  // NOTE: To be deprecated in favor of chevronSinglRight
+  chevronSingleRight: function chevronSingleRight() {
     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: withMetadata(function () {
+  chevronSingleUp: function chevronSingleUp() {
     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: withMetadata(function () {
+  chevronLimitLeft: function chevronLimitLeft() {
     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: withMetadata(function () {
+  chevronLimitRight: function chevronLimitRight() {
     return import('./assets/chevron_limit_right');
-  }, {
-    synonyms: ['chevron', 'limit', 'last', 'end', 'final', 'jump', 'skip']
-  }),
+  },
   article: function article() {
     return import('./assets/article');
   },
-  asterisk: withMetadata(function () {
+  asterisk: function asterisk() {
     return import('./assets/asterisk');
-  }, {
-    synonyms: ['star', 'wildcard', 'required', 'multiply', 'reference', 'footnote']
-  }),
-  at: withMetadata(function () {
+  },
+  at: function at() {
     return import('./assets/at');
-  }, {
-    synonyms: ['email', 'mention', 'address', 'symbol', 'contact', 'handle']
-  }),
-  archive: withMetadata(function () {
+  },
+  archive: function archive() {
     return import('./assets/archive');
-  }, {
-    synonyms: ['storage', 'box', 'store', 'backup', 'file away', 'saved', 'repository']
-  }),
-  axisX: withMetadata(function () {
+  },
+  axisX: function axisX() {
     return import('./assets/axis_x');
-  }, {
-    synonyms: ['x axis', 'horizontal axis', 'chart', 'graph', 'dimension', 'abscissa']
-  }),
-  axisYLeft: withMetadata(function () {
+  },
+  axisYLeft: function axisYLeft() {
     return import('./assets/axis_y_left');
-  }, {
-    synonyms: ['y axis', 'left', 'vertical axis', 'chart', 'graph', 'ordinate']
-  }),
-  axisYRight: withMetadata(function () {
+  },
+  axisYRight: function axisYRight() {
     return import('./assets/axis_y_right');
-  }, {
-    synonyms: ['y axis', 'right', 'vertical axis', 'chart', 'graph', 'ordinate']
-  }),
-  auditbeatApp: withMetadata(function () {
+  },
+  auditbeatApp: function auditbeatApp() {
     return import('./assets/app_auditbeat');
-  }, {
-    category: 'app'
-  }),
-  backgroundTask: withMetadata(function () {
+  },
+  backgroundTask: function backgroundTask() {
     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: withMetadata(function () {
+  bell: function bell() {
     return import('./assets/bell');
-  }, {
-    synonyms: ['notification', 'alert', 'alarm', 'notify', 'ring', 'reminder', 'announcements']
-  }),
-  bellSlash: withMetadata(function () {
+  },
+  bellSlash: function bellSlash() {
     return import('./assets/bell_slash');
-  }, {
-    synonyms: ['mute', 'notification off', 'silence', 'bell disabled', 'alerts off', 'quiet']
-  }),
-  beta: withMetadata(function () {
+  },
+  beta: function beta() {
     return import('./assets/beta');
-  }, {
-    synonyms: ['greek', 'test', 'experimental', 'preview', 'version', 'letter']
-  }),
-  bolt: withMetadata(function () {
+  },
+  bolt: function bolt() {
     return import('./assets/bolt');
-  }, {
-    synonyms: ['lightning', 'fast', 'power', 'electric', 'speed', 'energy']
-  }),
+  },
   boxesHorizontal: function boxesHorizontal() {
     return import('./assets/boxes_vertical');
   },
@@ -274,191 +186,123 @@ export var typeToPathMap = {
   boxesVertical: function boxesVertical() {
     return import('./assets/boxes_vertical');
   },
-  branch: withMetadata(function () {
+  branch: function branch() {
     return import('./assets/branch');
-  }, {
-    synonyms: ['git', 'version control', 'fork', 'tree', 'split', 'divergence']
-  }),
-  briefcase: withMetadata(function () {
+  },
+  briefcase: function briefcase() {
     return import('./assets/briefcase');
-  }, {
-    synonyms: ['work', 'business', 'job', 'portfolio', 'office', 'career']
-  }),
+  },
   branchUser: function branchUser() {
     return import('./assets/branch_user');
   },
-  broom: withMetadata(function () {
+  broom: function broom() {
     return import('./assets/broom');
-  }, {
-    synonyms: ['clean', 'sweep', 'clear', 'tidy', 'wipe', 'brush off']
-  }),
-  brush: withMetadata(function () {
+  },
+  brush: function brush() {
     return import('./assets/brush');
-  }, {
-    synonyms: ['paint', 'draw', 'art', 'design', 'stroke', 'brush tool']
-  }),
-  bug: withMetadata(function () {
+  },
+  bug: function bug() {
     return import('./assets/bug');
-  }, {
-    synonyms: ['insect', 'defect', 'issue', 'error', 'debug', 'glitch']
-  }),
-  bulb: withMetadata(function () {
+  },
+  bulb: function bulb() {
     return import('./assets/bulb');
-  }, {
-    synonyms: ['light', 'idea', 'lamp', 'insight', 'bright', 'hint']
-  }),
-  bullseye: withMetadata(function () {
+  },
+  bullseye: function bullseye() {
     return import('./assets/bullseye');
-  }, {
-    synonyms: ['findings', 'target', 'aim', 'goal', 'focus', 'dartboard', 'precision', 'center']
-  }),
-  calendar: withMetadata(function () {
+  },
+  calendar: function calendar() {
     return import('./assets/calendar');
-  }, {
-    synonyms: ['date', 'schedule', 'event', 'day', 'month', 'time']
-  }),
-  canvasApp: withMetadata(function () {
+  },
+  canvasApp: function canvasApp() {
     return import('./assets/app_canvas');
-  }, {
-    category: 'app'
-  }),
-  casesApp: withMetadata(function () {
+  },
+  casesApp: function casesApp() {
     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: withMetadata(function () {
+  chartChangePoint: function chartChangePoint() {
     return import('./assets/chart_change_point');
-  }, {
-    synonyms: ['change point', 'chart', 'breakpoint', 'shift', 'detection', 'regime']
-  }),
-  chartArea: withMetadata(function () {
+  },
+  chartArea: function chartArea() {
     return import('./assets/chart_area');
-  }, {
-    synonyms: ['area chart', 'graph', 'visualization', 'filled', 'trend', 'plot']
-  }),
-  chartAreaStack: withMetadata(function () {
+  },
+  chartAreaStack: function chartAreaStack() {
     return import('./assets/chart_area_stack');
-  }, {
-    synonyms: ['stacked area', 'chart', 'graph', 'layers', 'visualization', 'plot']
-  }),
-  chartBarHorizontal: withMetadata(function () {
+  },
+  chartBarHorizontal: function chartBarHorizontal() {
     return import('./assets/chart_bar_horizontal');
-  }, {
-    synonyms: ['bar chart', 'horizontal', 'graph', 'bars', 'visualization', 'plot']
-  }),
-  chartBarHorizontalStack: withMetadata(function () {
+  },
+  chartBarHorizontalStack: function chartBarHorizontalStack() {
     return import('./assets/chart_bar_horizontal_stack');
-  }, {
-    synonyms: ['stacked bar', 'horizontal', 'chart', 'graph', 'grouped', 'plot']
-  }),
-  chartBarVertical: withMetadata(function () {
+  },
+  chartBarVertical: function chartBarVertical() {
     return import('./assets/chart_bar_vertical');
-  }, {
-    synonyms: ['bar chart', 'vertical', 'graph', 'columns', 'visualization', 'plot']
-  }),
-  chartBarVerticalStack: withMetadata(function () {
+  },
+  chartBarVerticalStack: function chartBarVerticalStack() {
     return import('./assets/chart_bar_vertical_stack');
-  }, {
-    synonyms: ['stacked bar', 'vertical', 'chart', 'graph', 'grouped', 'plot']
-  }),
-  chartGauge: withMetadata(function () {
+  },
+  chartGauge: function chartGauge() {
     return import('./assets/chart_gauge');
-  }, {
-    synonyms: ['gauge', 'meter', 'dial', 'chart', 'metric', 'speedometer']
-  }),
-  chartHeatmap: withMetadata(function () {
+  },
+  chartHeatmap: function chartHeatmap() {
     return import('./assets/chart_heatmap');
-  }, {
-    synonyms: ['heatmap', 'matrix', 'density', 'chart', 'grid', 'correlation']
-  }),
-  chartLine: withMetadata(function () {
+  },
+  chartLine: function chartLine() {
     return import('./assets/chart_line');
-  }, {
-    synonyms: ['line chart', 'graph', 'trend', 'visualization', 'plot', 'time series']
-  }),
-  chartPie: withMetadata(function () {
+  },
+  chartPie: function chartPie() {
     return import('./assets/chart_pie');
-  }, {
-    synonyms: ['pie chart', 'donut', 'proportion', 'circle', 'segments', 'share']
-  }),
-  chartTagCloud: withMetadata(function () {
+  },
+  chartTagCloud: function chartTagCloud() {
     return import('./assets/chart_tag_cloud');
-  }, {
-    synonyms: ['tag cloud', 'word cloud', 'text', 'chart', 'keywords', 'frequency']
-  }),
-  chartThreshold: withMetadata(function () {
+  },
+  chartThreshold: function chartThreshold() {
     return import('./assets/chart_threshold');
-  }, {
-    synonyms: ['threshold', 'limit', 'chart', 'boundary', 'alert line', 'cutoff']
-  }),
-  check: withMetadata(function () {
+  },
+  check: function check() {
     return import('./assets/check');
-  }, {
-    synonyms: ['tick', 'confirm', 'done', 'yes', 'approve', 'mark']
-  }),
-  checkCircle: withMetadata(function () {
+  },
+  checkCircle: function checkCircle() {
     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: withMetadata(function () {
+  checkCircleFill: function checkCircleFill() {
     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: withMetadata(function () {
+  popper: function popper() {
     return import('./assets/popper');
-  }, {
-    synonyms: ['popper', 'tooltip', 'overlay', 'popup', 'floating']
-  }),
-  classificationJob: withMetadata(function () {
+  },
+  classificationJob: function classificationJob() {
     return import('./assets/ml_classification_job');
-  }, {
-    category: 'ml'
-  }),
-  clickLeft: withMetadata(function () {
+  },
+  clickLeft: function clickLeft() {
     return import('./assets/click_left');
-  }, {
-    synonyms: ['click', 'left', 'mouse', 'pointer', 'button', 'tap']
-  }),
-  clickRight: withMetadata(function () {
+  },
+  clickRight: function clickRight() {
     return import('./assets/click_right');
-  }, {
-    synonyms: ['click', 'right', 'mouse', 'context', 'button', 'tap']
-  }),
-  clock: withMetadata(function () {
+  },
+  clock: function clock() {
     return import('./assets/clock');
-  }, {
-    synonyms: ['clock']
-  }),
-  clockCounter: withMetadata(function () {
+  },
+  clockCounter: function clockCounter() {
     return import('./assets/clock_counter');
-  }, {
-    synonyms: ['clock', 'counter', 'countdown', 'timer', 'time', 'elapsed']
-  }),
-  clockControl: withMetadata(function () {
+  },
+  clockControl: function clockControl() {
     return import('./assets/clock_control');
-  }, {
-    synonyms: ['clock', 'control', 'time', 'schedule', 'timer', 'settings']
-  }),
-  cloud: withMetadata(function () {
+  },
+  cloud: function cloud() {
     return import('./assets/cloud');
-  }, {
-    synonyms: ['cloud', 'online', 'hosting', 'saas', 'remote']
-  }),
+  },
   cloudDrizzle: function cloudDrizzle() {
     return import('./assets/cloud_drizzle');
   },
@@ -468,63 +312,45 @@ export var typeToPathMap = {
   cloudSunny: function cloudSunny() {
     return import('./assets/cloud_sunny');
   },
-  cluster: withMetadata(function () {
+  cluster: function cluster() {
     return import('./assets/cluster');
-  }, {
-    synonyms: ['cluster', 'nodes', 'group', 'collection', 'distributed']
-  }),
-  code: withMetadata(function () {
+  },
+  code: function code() {
     return import('./assets/code');
-  }, {
-    synonyms: ['code', 'developer', 'programming', 'script', 'source']
-  }),
-  codeApp: withMetadata(function () {
+  },
+  codeApp: function codeApp() {
     return import('./assets/app_code');
-  }, {
-    category: 'app'
-  }),
+  },
   color: function color() {
     return import('./assets/paint_bucket');
   },
   // NOTE: To be deprecated in favor of paintBucket
-  paintBucket: withMetadata(function () {
+  paintBucket: function paintBucket() {
     return import('./assets/paint_bucket');
-  }, {
-    synonyms: ['paint', 'fill', 'bucket', 'color', 'flood fill']
-  }),
-  commandLine: withMetadata(function () {
+  },
+  commandLine: function commandLine() {
     return import('./assets/command_line');
-  }, {
-    synonyms: ['terminal', 'cli', 'console', 'shell', 'command', 'prompt']
-  }),
-  comment: withMetadata(function () {
+  },
+  comment: function comment() {
     return import('./assets/comment');
-  }, {
-    synonyms: ['comment', 'chat', 'message', 'feedback', 'discussion']
-  }),
-  compare: withMetadata(function () {
+  },
+  compare: function compare() {
     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: withMetadata(function () {
+  processor: function processor() {
     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: withMetadata(function () {
+  consoleApp: function consoleApp() {
     return import('./assets/app_console');
-  }, {
-    category: 'app'
-  }),
+  },
   container: function container() {
     return import('./assets/container');
   },
@@ -540,25 +366,19 @@ export var typeToPathMap = {
   continuityWithin: function continuityWithin() {
     return import('./assets/continuity_within');
   },
-  contrast: withMetadata(function () {
+  contrast: function contrast() {
     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: withMetadata(function () {
+  contrastFill: function contrastFill() {
     return import('./assets/contrast_fill');
-  }, {
-    synonyms: ['contrast', 'filled', 'accessibility', 'visibility', 'a11y', 'display']
-  }),
-  controls: withMetadata(function () {
+  },
+  controls: function controls() {
     return import('./assets/controls');
-  }, {
-    synonyms: ['controls', 'sliders', 'settings', 'adjust', 'panel']
-  }),
+  },
   controlsHorizontal: function controlsHorizontal() {
     return import('./assets/controls');
   },
@@ -567,74 +387,50 @@ export var typeToPathMap = {
     return import('./assets/controls');
   },
   // NOTE: To be deprecated in favor of `controls`
-  copy: withMetadata(function () {
+  copy: function copy() {
     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: withMetadata(function () {
+  crossProjectSearch: function crossProjectSearch() {
     return import('./assets/cross_project_search');
-  }, {
-    synonyms: ['search', 'cross project', 'global', 'find', 'lookup', 'explore']
-  }),
-  createAdvancedJob: withMetadata(function () {
+  },
+  createAdvancedJob: function createAdvancedJob() {
     return import('./assets/ml_create_advanced_job');
-  }, {
-    category: 'ml'
-  }),
-  createGenericJob: withMetadata(function () {
+  },
+  createGenericJob: function createGenericJob() {
     return import('./assets/ml_create_generic_job');
-  }, {
-    category: 'ml'
-  }),
-  createGeoJob: withMetadata(function () {
+  },
+  createGeoJob: function createGeoJob() {
     return import('./assets/ml_create_geo_job');
-  }, {
-    category: 'ml'
-  }),
-  createMultiMetricJob: withMetadata(function () {
+  },
+  createMultiMetricJob: function createMultiMetricJob() {
     return import('./assets/ml_create_multi_metric_job');
-  }, {
-    category: 'ml'
-  }),
-  createPopulationJob: withMetadata(function () {
+  },
+  createPopulationJob: function createPopulationJob() {
     return import('./assets/ml_create_population_job');
-  }, {
-    category: 'ml'
-  }),
-  createSingleMetricJob: withMetadata(function () {
+  },
+  createSingleMetricJob: function createSingleMetricJob() {
     return import('./assets/ml_create_single_metric_job');
-  }, {
-    category: 'ml'
-  }),
-  cross: withMetadata(function () {
+  },
+  cross: function cross() {
     return import('./assets/cross');
-  }, {
-    synonyms: ['cross', 'close', 'cancel', 'delete']
-  }),
-  crossClusterReplicationApp: withMetadata(function () {
+  },
+  crossClusterReplicationApp: function crossClusterReplicationApp() {
     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: withMetadata(function () {
+  crossCircle: function crossCircle() {
     return import('./assets/cross_circle');
-  }, {
-    synonyms: ['cross circle', 'cross', 'close', 'cancel', 'delete', 'circle']
-  }),
-  crosshair: withMetadata(function () {
+  },
+  crosshair: function crosshair() {
     return import('./assets/crosshair');
-  }, {
-    synonyms: ['crosshair']
-  }),
+  },
   crosshairs: function crosshairs() {
     return import('./assets/crosshair');
   },
@@ -643,121 +439,83 @@ export var typeToPathMap = {
     return import('./assets/money');
   },
   // NOTE: To be deprecated in favor of money
-  money: withMetadata(function () {
+  money: function money() {
     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: withMetadata(function () {
+  scissors: function scissors() {
     return import('./assets/scissors');
-  }, {
-    synonyms: ['scissors']
-  }),
-  dashboardApp: withMetadata(function () {
+  },
+  dashboardApp: function dashboardApp() {
     return import('./assets/app_dashboard');
-  }, {
-    category: 'app'
-  }),
-  dashedCircle: withMetadata(function () {
+  },
+  dashedCircle: function dashedCircle() {
     return import('./assets/dashed_circle');
-  }, {
-    synonyms: ['dashed', 'circle', 'pending', 'incomplete', 'outline', 'status']
-  }),
-  dataVisualizer: withMetadata(function () {
+  },
+  dataVisualizer: function dataVisualizer() {
     return import('./assets/ml_data_visualizer');
-  }, {
-    category: 'ml'
-  }),
-  database: withMetadata(function () {
+  },
+  database: function database() {
     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: withMetadata(function () {
+  display: function display() {
     return import('./assets/display');
-  }, {
-    synonyms: ['display']
-  }),
-  devToolsApp: withMetadata(function () {
+  },
+  devToolsApp: function devToolsApp() {
     return import('./assets/app_devtools');
-  }, {
-    category: 'app'
-  }),
+  },
   diff: function diff() {
     return import('./assets/compare');
   },
   // NOTE: To be deprecated in favor of compare
-  discoverApp: withMetadata(function () {
+  discoverApp: function discoverApp() {
     return import('./assets/app_discover');
-  }, {
-    category: 'app'
-  }),
-  distributeHorizontal: withMetadata(function () {
+  },
+  distributeHorizontal: function distributeHorizontal() {
     return import('./assets/distribute_horizontal');
-  }, {
-    synonyms: ['distribute horizontal', 'distribute', 'horizontal']
-  }),
-  distributeVertical: withMetadata(function () {
+  },
+  distributeVertical: function distributeVertical() {
     return import('./assets/distribute_vertical');
-  }, {
-    synonyms: ['distribute vertical', 'distribute', 'vertical']
-  }),
-  download: withMetadata(function () {
+  },
+  download: function download() {
     return import('./assets/download');
-  }, {
-    synonyms: ['save', 'export', 'retrieve', 'get file', 'arrow down', 'pull']
-  }),
-  drag: withMetadata(function () {
+  },
+  drag: function drag() {
     return import('./assets/drag');
-  }, {
-    synonyms: ['drag', 'move', 'grab', 'reorder', 'handle']
-  }),
-  dragHorizontal: withMetadata(function () {
+  },
+  dragHorizontal: function dragHorizontal() {
     return import('./assets/drag_horizontal');
-  }, {
-    synonyms: ['drag horizontal', 'drag', 'move', 'grab', 'reorder', 'handle', 'horizontal']
-  }),
-  dragVertical: withMetadata(function () {
+  },
+  dragVertical: function dragVertical() {
     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: withMetadata(function () {
+  document: function document() {
     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: withMetadata(function () {
+  documentation: function documentation() {
     return import('./assets/documentation');
-  }, {
-    synonyms: ['documentation', 'docs', 'help', 'guide', 'manual']
-  }),
-  documents: withMetadata(function () {
+  },
+  documents: function documents() {
     return import('./assets/documents');
-  }, {
-    synonyms: ['documents', 'files', 'pages', 'papers', 'library']
-  }),
-  dot: withMetadata(function () {
+  },
+  dot: function dot() {
     return import('./assets/dot');
-  }, {
-    synonyms: ['dot', 'point', 'bullet', 'period', 'circle']
-  }),
+  },
   dotInCircle: function dotInCircle() {
     return import('./assets/dot_in_circle');
   },
@@ -765,70 +523,54 @@ export var typeToPathMap = {
     return import('./assets/chevron_double_left');
   },
   // NOTE: To be deprecated in favor of chevronDoubleLeft
-  chevronDoubleLeft: withMetadata(function () {
+  chevronDoubleLeft: function chevronDoubleLeft() {
     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: withMetadata(function () {
+  chevronDoubleRight: function chevronDoubleRight() {
     return import('./assets/chevron_double_right');
-  }, {
-    synonyms: ['chevron', 'double', 'right', 'forward', 'skip', 'next']
-  }),
-  ellipsis: withMetadata(function () {
+  },
+  ellipsis: function ellipsis() {
     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: withMetadata(function () {
+  textAlignCenter: function textAlignCenter() {
     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: withMetadata(function () {
+  textAlignLeft: function textAlignLeft() {
     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: withMetadata(function () {
+  textAlignRight: function textAlignRight() {
     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: withMetadata(function () {
+  textBold: function textBold() {
     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: withMetadata(function () {
+  listCheck: function listCheck() {
     return import('./assets/list_check');
-  }, {
-    synonyms: ['list check', 'list', 'bullet', 'items', 'rows', 'check', 'tick', 'confirm']
-  }),
+  },
   editorCodeBlock: function editorCodeBlock() {
     return import('./assets/code');
   },
@@ -849,20 +591,16 @@ export var typeToPathMap = {
     return import('./assets/text_heading');
   },
   // NOTE: To be deprecated in favor of textHeading
-  textHeading: withMetadata(function () {
+  textHeading: function textHeading() {
     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: withMetadata(function () {
+  textItalic: function textItalic() {
     return import('./assets/text_italic');
-  }, {
-    synonyms: ['text italic', 'text', 'italic', 'typography', 'formatting']
-  }),
+  },
   editorItemAlignBottom: function editorItemAlignBottom() {
     return import('./assets/editor_item_align_bottom');
   },
@@ -895,11 +633,9 @@ export var typeToPathMap = {
     return import('./assets/list_number');
   },
   // NOTE: To be deprecated in favor of listNumber
-  listNumber: withMetadata(function () {
+  listNumber: function listNumber() {
     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');
   },
@@ -920,108 +656,80 @@ export var typeToPathMap = {
     return import('./assets/redo');
   },
   // NOTE: To be deprecated in favor of redo
-  redo: withMetadata(function () {
+  redo: function redo() {
     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: withMetadata(function () {
+  textStrike: function textStrike() {
     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: withMetadata(function () {
+  table: function table() {
     return import('./assets/table');
-  }, {
-    synonyms: ['table']
-  }),
+  },
   editorUnderline: function editorUnderline() {
     return import('./assets/text_underline');
   },
   // NOTE: To be deprecated in favor of textUnderline
-  textUnderline: withMetadata(function () {
+  textUnderline: function textUnderline() {
     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: withMetadata(function () {
+  undo: function undo() {
     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: withMetadata(function () {
+  listBullet: function listBullet() {
     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: withMetadata(function () {
+  mail: function mail() {
     return import('./assets/mail');
-  }, {
-    synonyms: ['mail', 'email', 'envelope', 'message', 'inbox']
-  }),
-  empty: withMetadata(function () {
+  },
+  empty: function empty() {
     return import('./assets/empty');
-  }, {
-    synonyms: ['empty', 'blank', 'none', 'placeholder', 'void']
-  }),
-  emsApp: withMetadata(function () {
+  },
+  emsApp: function emsApp() {
     return import('./assets/app_ems');
-  }, {
-    category: 'app'
-  }),
-  endpoint: withMetadata(function () {
+  },
+  endpoint: function endpoint() {
     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: withMetadata(function () {
+  query: function query() {
     return import('./assets/query');
-  }, {
-    synonyms: ['query', 'search', 'sql', 'lucene', 'filter']
-  }),
-  eraser: withMetadata(function () {
+  },
+  eraser: function eraser() {
     return import('./assets/eraser');
-  }, {
-    synonyms: ['eraser', 'clear', 'remove', 'delete', 'rubber']
-  }),
-  error: withMetadata(function () {
+  },
+  error: function error() {
     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: withMetadata(function () {
+  errorFill: function errorFill() {
     return import('./assets/error_fill');
-  }, {
-    synonyms: ['error fill', 'error', 'failure', 'problem', 'invalid', 'cross', 'fill', 'filled']
-  }),
+  },
   esqlVis: function esqlVis() {
     return import('./assets/esql_vis');
   },
@@ -1029,20 +737,16 @@ export var typeToPathMap = {
     return import('./assets/log_out');
   },
   // NOTE: To be deprecated in favor of logOut
-  logOut: withMetadata(function () {
+  logOut: function logOut() {
     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: withMetadata(function () {
+  maximize: function maximize() {
     return import('./assets/maximize');
-  }, {
-    synonyms: ['maximize']
-  }),
+  },
   expandMini: function expandMini() {
     return import('./assets/maximize');
   },
@@ -1054,98 +758,66 @@ export var typeToPathMap = {
     return import('./assets/upload');
   },
   // NOTE: To be deprecated in favor of upload
-  upload: withMetadata(function () {
+  upload: function upload() {
     return import('./assets/upload');
-  }, {
-    synonyms: ['upload', 'import', 'send', 'cloud', 'arrow up']
-  }),
-  external: withMetadata(function () {
+  },
+  external: function external() {
     return import('./assets/external');
-  }, {
-    synonyms: ['external', 'open new', 'link out', 'outside']
-  }),
-  eye: withMetadata(function () {
+  },
+  eye: function eye() {
     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: withMetadata(function () {
+  eyeSlash: function eyeSlash() {
     return import('./assets/eye_slash');
-  }, {
-    synonyms: ['eye slash', 'eye', 'view', 'visible', 'show', 'preview', 'watch', 'slash']
-  }),
-  faceHappy: withMetadata(function () {
+  },
+  faceHappy: function faceHappy() {
     return import('./assets/face_happy');
-  }, {
-    synonyms: ['smile', 'happy', 'emoji', 'positive', 'grin', 'satisfied', 'mood']
-  }),
-  faceNeutral: withMetadata(function () {
+  },
+  faceNeutral: function faceNeutral() {
     return import('./assets/face_neutral');
-  }, {
-    synonyms: ['face neutral', 'face', 'neutral']
-  }),
-  faceSad: withMetadata(function () {
+  },
+  faceSad: function faceSad() {
     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: withMetadata(function () {
+  tableInfo: function tableInfo() {
     return import('./assets/table_info');
-  }, {
-    synonyms: ['table', 'info', 'metadata', 'details', 'schema', 'columns']
-  }),
-  filebeatApp: withMetadata(function () {
+  },
+  filebeatApp: function filebeatApp() {
     return import('./assets/app_filebeat');
-  }, {
-    category: 'app'
-  }),
-  filter: withMetadata(function () {
+  },
+  filter: function filter() {
     return import('./assets/filter');
-  }, {
-    synonyms: ['funnel', 'refine', 'narrow', 'sort', 'subset', 'sieve', 'criteria']
-  }),
-  filterExclude: withMetadata(function () {
+  },
+  filterExclude: function filterExclude() {
     return import('./assets/filter_exclude');
-  }, {
-    synonyms: ['filter', 'exclude', 'remove', 'minus', 'refine', 'narrow']
-  }),
-  filterIgnore: withMetadata(function () {
+  },
+  filterIgnore: function filterIgnore() {
     return import('./assets/filter_ignore');
-  }, {
-    synonyms: ['filter', 'ignore', 'skip', 'exclude', 'omit', 'hide']
-  }),
-  filterInclude: withMetadata(function () {
+  },
+  filterInclude: function filterInclude() {
     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: withMetadata(function () {
+  flask: function flask() {
     return import('./assets/flask');
-  }, {
-    synonyms: ['flask', 'experiment', 'lab', 'science', 'test']
-  }),
-  flag: withMetadata(function () {
+  },
+  flag: function flag() {
     return import('./assets/flag');
-  }, {
-    synonyms: ['flag', 'mark', 'report', 'bookmark', 'priority']
-  }),
-  fleetApp: withMetadata(function () {
+  },
+  fleetApp: function fleetApp() {
     return import('./assets/app_agent');
-  }, {
-    category: 'app'
-  }),
+  },
   fold: function fold() {
     return import('./assets/fold');
   },
@@ -1155,22 +827,18 @@ export var typeToPathMap = {
   folderClosed: function folderClosed() {
     return import('./assets/folder_close');
   },
-  folderClose: withMetadata(function () {
+  folderClose: function folderClose() {
     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: withMetadata(function () {
+  folderOpen: function folderOpen() {
     return import('./assets/folder_open');
-  }, {
-    synonyms: ['folder', 'open', 'expand', 'directory', 'browse']
-  }),
+  },
   folderOpened: function folderOpened() {
     return import('./assets/folder_open');
   },
@@ -1180,38 +848,28 @@ export var typeToPathMap = {
   framePrevious: function framePrevious() {
     return import('./assets/frame_previous');
   },
-  fullScreen: withMetadata(function () {
+  fullScreen: function fullScreen() {
     return import('./assets/full_screen');
-  }, {
-    synonyms: ['fullscreen']
-  }),
-  fullScreenExit: withMetadata(function () {
+  },
+  fullScreenExit: function fullScreenExit() {
     return import('./assets/full_screen_exit');
-  }, {
-    synonyms: ['fullscreen', 'exit', 'minimize', 'window', 'restore', 'shrink']
-  }),
+  },
   function: function _function() {
     return import('./assets/function');
   },
-  gear: withMetadata(function () {
+  gear: function gear() {
     return import('./assets/gear');
-  }, {
-    synonyms: ['settings', 'configure', 'configuration', 'preferences', 'options', 'cog', 'setup', 'admin', 'wrench']
-  }),
-  gisApp: withMetadata(function () {
+  },
+  gisApp: function gisApp() {
     return import('./assets/app_gis');
-  }, {
-    category: 'app'
-  }),
+  },
   glasses: function glasses() {
     return import('./assets/read_only');
   },
   // NOTE: To be deprecated in favor of `readOnly`
-  globe: withMetadata(function () {
+  globe: function globe() {
     return import('./assets/globe');
-  }, {
-    synonyms: ['globe', 'world', 'web', 'internet', 'international']
-  }),
+  },
   grab: function grab() {
     return import('./assets/drag_vertical');
   },
@@ -1224,36 +882,24 @@ export var typeToPathMap = {
     return import('./assets/grab_omnidirectional');
   },
   // NOTE: To be deprecated in favor of drag,
-  gradient: withMetadata(function () {
+  gradient: function gradient() {
     return import('./assets/gradient');
-  }, {
-    synonyms: ['gradient', 'blend', 'fade', 'color transition']
-  }),
-  graphApp: withMetadata(function () {
+  },
+  graphApp: function graphApp() {
     return import('./assets/app_graph');
-  }, {
-    category: 'app'
-  }),
-  grid: withMetadata(function () {
+  },
+  grid: function grid() {
     return import('./assets/grid');
-  }, {
-    synonyms: ['grid', 'table', 'layout', 'matrix', 'cells']
-  }),
-  grokApp: withMetadata(function () {
+  },
+  grokApp: function grokApp() {
     return import('./assets/app_grok');
-  }, {
-    category: 'app'
-  }),
-  heart: withMetadata(function () {
+  },
+  heart: function heart() {
     return import('./assets/heart');
-  }, {
-    synonyms: ['heart', 'favorite', 'like', 'love', 'bookmark']
-  }),
-  heartbeatApp: withMetadata(function () {
+  },
+  heartbeatApp: function heartbeatApp() {
     return import('./assets/app_heartbeat');
-  }, {
-    category: 'app'
-  }),
+  },
   heatmap: function heatmap() {
     return import('./assets/chart_heatmap');
   },
@@ -1262,31 +908,21 @@ export var typeToPathMap = {
     return import('./assets/help');
   },
   // NOTE: Might be deprecated later (not recommended in Kibana)
-  home: withMetadata(function () {
+  home: function home() {
     return import('./assets/home');
-  }, {
-    synonyms: ['home', 'house', 'main', 'start', 'dashboard']
-  }),
-  hourglass: withMetadata(function () {
+  },
+  hourglass: function hourglass() {
     return import('./assets/hourglass');
-  }, {
-    synonyms: ['hourglass', 'waiting', 'loading', 'time', 'pending']
-  }),
-  if: withMetadata(function () {
+  },
+  if: function _if() {
     return import('./assets/if');
-  }, {
-    synonyms: ['if', 'condition', 'logic', 'branch', 'rule']
-  }),
-  info: withMetadata(function () {
+  },
+  info: function info() {
     return import('./assets/info');
-  }, {
-    synonyms: ['info', 'information', 'help', 'about', 'details']
-  }),
-  image: withMetadata(function () {
+  },
+  image: function image() {
     return import('./assets/image');
-  }, {
-    synonyms: ['image', 'picture', 'photo', 'media', 'graphic']
-  }),
+  },
   importAction: function importAction() {
     return import('./assets/download');
   },
@@ -1294,83 +930,57 @@ export var typeToPathMap = {
   index: function index() {
     return import('./assets/index');
   },
-  indexClose: withMetadata(function () {
+  indexClose: function indexClose() {
     return import('./assets/index_close');
-  }, {
-    synonyms: ['index', 'close', 'elasticsearch', 'dataset', 'remove']
-  }),
-  indexEdit: withMetadata(function () {
+  },
+  indexEdit: function indexEdit() {
     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: withMetadata(function () {
+  indexManagementApp: function indexManagementApp() {
     return import('./assets/app_index_management');
-  }, {
-    category: 'app'
-  }),
+  },
   indexMapping: function indexMapping() {
     return import('./assets/mapping');
   },
   // NOTE: To be deprecated in favor of mapping
-  mapping: withMetadata(function () {
+  mapping: function mapping() {
     return import('./assets/mapping');
-  }, {
-    synonyms: ['mapping']
-  }),
-  indexOpen: withMetadata(function () {
+  },
+  indexOpen: function indexOpen() {
     return import('./assets/index_open');
-  }, {
-    synonyms: ['index', 'open', 'elasticsearch', 'dataset', 'browse']
-  }),
-  indexPatternApp: withMetadata(function () {
+  },
+  indexPatternApp: function indexPatternApp() {
     return import('./assets/app_index_pattern');
-  }, {
-    category: 'app'
-  }),
-  indexRollupApp: withMetadata(function () {
+  },
+  indexRollupApp: function indexRollupApp() {
     return import('./assets/app_index_rollup');
-  }, {
-    category: 'app'
-  }),
-  indexRuntime: withMetadata(function () {
+  },
+  indexRuntime: function indexRuntime() {
     return import('./assets/index_runtime');
-  }, {
-    synonyms: ['index', 'runtime', 'elasticsearch', 'live', 'execution']
-  }),
-  indexSettings: withMetadata(function () {
+  },
+  indexSettings: function indexSettings() {
     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: withMetadata(function () {
+  tableTime: function tableTime() {
     return import('./assets/table_time');
-  }, {
-    synonyms: ['table', 'time', 'temporal', 'date', 'timeline', 'history']
-  }),
-  infinity: withMetadata(function () {
+  },
+  infinity: function infinity() {
     return import('./assets/infinity');
-  }, {
-    synonyms: ['infinity', 'unlimited', 'forever', 'loop', 'endless']
-  }),
-  inputOutput: withMetadata(function () {
+  },
+  inputOutput: function inputOutput() {
     return import('./assets/input_output');
-  }, {
-    synonyms: ['input', 'output', 'io', 'data flow', 'pipeline', 'stream']
-  }),
-  inspect: withMetadata(function () {
+  },
+  inspect: function inspect() {
     return import('./assets/inspect');
-  }, {
-    synonyms: ['inspect', 'investigate', 'examine', 'analyze', 'look']
-  }),
+  },
   invert: function invert() {
     return import('./assets/contrast');
   },
@@ -1378,25 +988,19 @@ export var typeToPathMap = {
   ip: function ip() {
     return import('./assets/ip');
   },
-  key: withMetadata(function () {
+  key: function key() {
     return import('./assets/key');
-  }, {
-    synonyms: ['key', 'password', 'credential', 'access', 'security']
-  }),
-  keyboard: withMetadata(function () {
+  },
+  keyboard: function keyboard() {
     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: withMetadata(function () {
+  queryField: function queryField() {
     return import('./assets/query_field');
-  }, {
-    synonyms: ['query', 'field', 'filter', 'column', 'attribute', 'selector']
-  }),
+  },
   kqlFunction: function kqlFunction() {
     return import('./assets/kql_function');
   },
@@ -1404,108 +1008,78 @@ export var typeToPathMap = {
     return import('./assets/query_operand');
   },
   // NOTE: To be deprecated in favor of queryOperand
-  queryOperand: withMetadata(function () {
+  queryOperand: function queryOperand() {
     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: withMetadata(function () {
+  querySelector: function querySelector() {
     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: withMetadata(function () {
+  queryValue: function queryValue() {
     return import('./assets/query_value');
-  }, {
-    synonyms: ['query', 'value', 'literal', 'data', 'input', 'filter']
-  }),
+  },
   kubernetesNode: function kubernetesNode() {
     return import('./assets/kubernetes_node');
   },
-  kubernetesPod: withMetadata(function () {
+  kubernetesPod: function kubernetesPod() {
     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: withMetadata(function () {
+  rocket: function rocket() {
     return import('./assets/rocket');
-  }, {
-    synonyms: ['rocket', 'launch', 'deploy', 'fast', 'startup']
-  }),
-  layers: withMetadata(function () {
+  },
+  layers: function layers() {
     return import('./assets/layers');
-  }, {
-    synonyms: ['layers']
-  }),
-  lensApp: withMetadata(function () {
+  },
+  lensApp: function lensApp() {
     return import('./assets/app_lens');
-  }, {
-    category: 'app'
-  }),
+  },
   lettering: function lettering() {
     return import('./assets/text');
   },
   // NOTE: To be deprecated in favor of text
-  text: withMetadata(function () {
+  text: function text() {
     return import('./assets/text');
-  }, {
-    synonyms: ['text']
-  }),
-  lineBreak: withMetadata(function () {
+  },
+  lineBreak: function lineBreak() {
     return import('./assets/line_break');
-  }, {
-    synonyms: ['line break', 'newline', 'paragraph', 'text', 'wrap', 'return']
-  }),
-  lineBreakSlash: withMetadata(function () {
+  },
+  lineBreakSlash: function lineBreakSlash() {
     return import('./assets/line_break_slash');
-  }, {
-    synonyms: ['line break', 'slash', 'text', 'separator', 'paragraph']
-  }),
-  lineDash: withMetadata(function () {
+  },
+  lineDash: function lineDash() {
     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: withMetadata(function () {
+  lineDot: function lineDot() {
     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: withMetadata(function () {
+  lineSolid: function lineSolid() {
     return import('./assets/line_solid');
-  }, {
-    synonyms: ['line solid', 'line', 'solid']
-  }),
-  link: withMetadata(function () {
+  },
+  link: function link() {
     return import('./assets/link');
-  }, {
-    synonyms: ['link', 'url', 'chain', 'connect', 'hyperlink']
-  }),
-  linkSlash: withMetadata(function () {
+  },
+  linkSlash: function linkSlash() {
     return import('./assets/link_slash');
-  }, {
-    synonyms: ['unlink', 'broken link', 'remove link', 'disconnect', 'url']
-  }),
+  },
   list: function list() {
     return import('./assets/list_bullet');
   },
@@ -1514,328 +1088,202 @@ export var typeToPathMap = {
     return import('./assets/plus_circle');
   },
   // NOTE: To be deprecated in favor of `plus_circle`
-  lock: withMetadata(function () {
+  lock: function lock() {
     return import('./assets/lock');
-  }, {
-    synonyms: ['lock', 'secure', 'private', 'protected', 'password']
-  }),
-  lockOpen: withMetadata(function () {
+  },
+  lockOpen: function lockOpen() {
     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: withMetadata(function () {
+  pattern: function pattern() {
     return import('./assets/pattern');
-  }, {
-    synonyms: ['pattern', 'texture', 'repeat', 'design', 'fill']
-  }),
+  },
   logRateAnalysis: function logRateAnalysis() {
     return import('./assets/log_rate_analysis');
   },
-  logoAWS: withMetadata(function () {
+  logoAWS: function logoAWS() {
     return import('./assets/logo_aws');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoAWSMono: withMetadata(function () {
+  },
+  logoAWSMono: function logoAWSMono() {
     return import('./assets/logo_aws_mono');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoAerospike: withMetadata(function () {
+  },
+  logoAerospike: function logoAerospike() {
     return import('./assets/logo_aerospike');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoApache: withMetadata(function () {
+  },
+  logoApache: function logoApache() {
     return import('./assets/logo_apache');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoAppSearch: withMetadata(function () {
+  },
+  logoAppSearch: function logoAppSearch() {
     return import('./assets/logo_app_search');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoAzure: withMetadata(function () {
+  },
+  logoAzure: function logoAzure() {
     return import('./assets/logo_azure');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoAzureMono: withMetadata(function () {
+  },
+  logoAzureMono: function logoAzureMono() {
     return import('./assets/logo_azure_mono');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoBeats: withMetadata(function () {
+  },
+  logoBeats: function logoBeats() {
     return import('./assets/logo_beats');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoBusinessAnalytics: withMetadata(function () {
+  },
+  logoBusinessAnalytics: function logoBusinessAnalytics() {
     return import('./assets/logo_business_analytics');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoCeph: withMetadata(function () {
+  },
+  logoCeph: function logoCeph() {
     return import('./assets/logo_ceph');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoCloud: withMetadata(function () {
+  },
+  logoCloud: function logoCloud() {
     return import('./assets/logo_cloud');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoCloudEnterprise: withMetadata(function () {
+  },
+  logoCloudEnterprise: function logoCloudEnterprise() {
     return import('./assets/logo_cloud_ece');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoCode: withMetadata(function () {
+  },
+  logoCode: function logoCode() {
     return import('./assets/logo_code');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoCodesandbox: withMetadata(function () {
+  },
+  logoCodesandbox: function logoCodesandbox() {
     return import('./assets/logo_codesandbox');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoCouchbase: withMetadata(function () {
+  },
+  logoCouchbase: function logoCouchbase() {
     return import('./assets/logo_couchbase');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoDocker: withMetadata(function () {
+  },
+  logoDocker: function logoDocker() {
     return import('./assets/logo_docker');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoDropwizard: withMetadata(function () {
+  },
+  logoDropwizard: function logoDropwizard() {
     return import('./assets/logo_dropwizard');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoElastic: withMetadata(function () {
+  },
+  logoElastic: function logoElastic() {
     return import('./assets/logo_elastic');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoElasticStack: withMetadata(function () {
+  },
+  logoElasticStack: function logoElasticStack() {
     return import('./assets/logo_elastic_stack');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoElasticsearch: withMetadata(function () {
+  },
+  logoElasticsearch: function logoElasticsearch() {
     return import('./assets/logo_elasticsearch');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoEnterpriseSearch: withMetadata(function () {
+  },
+  logoEnterpriseSearch: function logoEnterpriseSearch() {
     return import('./assets/logo_enterprise_search');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoEtcd: withMetadata(function () {
+  },
+  logoEtcd: function logoEtcd() {
     return import('./assets/logo_etcd');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoGCP: withMetadata(function () {
+  },
+  logoGCP: function logoGCP() {
     return import('./assets/logo_gcp');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoGCPMono: withMetadata(function () {
+  },
+  logoGCPMono: function logoGCPMono() {
     return import('./assets/logo_gcp_mono');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoGithub: withMetadata(function () {
+  },
+  logoGithub: function logoGithub() {
     return import('./assets/logo_github');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoGmail: withMetadata(function () {
+  },
+  logoGmail: function logoGmail() {
     return import('./assets/logo_gmail');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoGolang: withMetadata(function () {
+  },
+  logoGolang: function logoGolang() {
     return import('./assets/logo_golang');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoGoogleG: withMetadata(function () {
+  },
+  logoGoogleG: function logoGoogleG() {
     return import('./assets/logo_google_g');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoHAproxy: withMetadata(function () {
+  },
+  logoHAproxy: function logoHAproxy() {
     return import('./assets/logo_haproxy');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoIBM: withMetadata(function () {
+  },
+  logoIBM: function logoIBM() {
     return import('./assets/logo_ibm');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoIBMMono: withMetadata(function () {
+  },
+  logoIBMMono: function logoIBMMono() {
     return import('./assets/logo_ibm_mono');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoKafka: withMetadata(function () {
+  },
+  logoKafka: function logoKafka() {
     return import('./assets/logo_kafka');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoKibana: withMetadata(function () {
+  },
+  logoKibana: function logoKibana() {
     return import('./assets/logo_kibana');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoKubernetes: withMetadata(function () {
+  },
+  logoKubernetes: function logoKubernetes() {
     return import('./assets/logo_kubernetes');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoLogging: withMetadata(function () {
+  },
+  logoLogging: function logoLogging() {
     return import('./assets/logo_logging');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoLogstash: withMetadata(function () {
+  },
+  logoLogstash: function logoLogstash() {
     return import('./assets/logo_logstash');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoMaps: withMetadata(function () {
+  },
+  logoMaps: function logoMaps() {
     return import('./assets/logo_maps');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoMemcached: withMetadata(function () {
+  },
+  logoMemcached: function logoMemcached() {
     return import('./assets/logo_memcached');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoMetrics: withMetadata(function () {
+  },
+  logoMetrics: function logoMetrics() {
     return import('./assets/logo_metrics');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoMongodb: withMetadata(function () {
+  },
+  logoMongodb: function logoMongodb() {
     return import('./assets/logo_mongodb');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoMySQL: withMetadata(function () {
+  },
+  logoMySQL: function logoMySQL() {
     return import('./assets/logo_mysql');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoNginx: withMetadata(function () {
+  },
+  logoNginx: function logoNginx() {
     return import('./assets/logo_nginx');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoObservability: withMetadata(function () {
+  },
+  logoObservability: function logoObservability() {
     return import('./assets/logo_observability');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoOsquery: withMetadata(function () {
+  },
+  logoOsquery: function logoOsquery() {
     return import('./assets/logo_osquery');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoPhp: withMetadata(function () {
+  },
+  logoPhp: function logoPhp() {
     return import('./assets/logo_php');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoPostgres: withMetadata(function () {
+  },
+  logoPostgres: function logoPostgres() {
     return import('./assets/logo_postgres');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoPrometheus: withMetadata(function () {
+  },
+  logoPrometheus: function logoPrometheus() {
     return import('./assets/logo_prometheus');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoRabbitmq: withMetadata(function () {
+  },
+  logoRabbitmq: function logoRabbitmq() {
     return import('./assets/logo_rabbitmq');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoRedis: withMetadata(function () {
+  },
+  logoRedis: function logoRedis() {
     return import('./assets/logo_redis');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoSecurity: withMetadata(function () {
+  },
+  logoSecurity: function logoSecurity() {
     return import('./assets/logo_security');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoSiteSearch: withMetadata(function () {
+  },
+  logoSiteSearch: function logoSiteSearch() {
     return import('./assets/logo_site_search');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoSketch: withMetadata(function () {
+  },
+  logoSketch: function logoSketch() {
     return import('./assets/logo_sketch');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoSlack: withMetadata(function () {
+  },
+  logoSlack: function logoSlack() {
     return import('./assets/logo_slack');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoUptime: withMetadata(function () {
+  },
+  logoUptime: function logoUptime() {
     return import('./assets/logo_uptime');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoVectorDB: withMetadata(function () {
+  },
+  logoVectorDB: function logoVectorDB() {
     return import('./assets/logo_vector_db');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoVulnerabilityManagement: withMetadata(function () {
+  },
+  logoVulnerabilityManagement: function logoVulnerabilityManagement() {
     return import('./assets/logo_vulnerability_management');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logoWebhook: withMetadata(function () {
+  },
+  logoWebhook: function logoWebhook() {
     return import('./assets/logo_webhook');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoWindows: withMetadata(function () {
+  },
+  logoWindows: function logoWindows() {
     return import('./assets/logo_windows');
-  }, {
-    category: 'thirdPartyLogo'
-  }),
-  logoWorkplaceSearch: withMetadata(function () {
+  },
+  logoWorkplaceSearch: function logoWorkplaceSearch() {
     return import('./assets/logo_workplace_search');
-  }, {
-    category: 'elasticLogo'
-  }),
-  logsApp: withMetadata(function () {
+  },
+  logsApp: function logsApp() {
     return import('./assets/app_logs');
-  }, {
-    category: 'app'
-  }),
+  },
   logstashFilter: function logstashFilter() {
     return import('./assets/logstash_filter');
   },
@@ -1853,39 +1301,27 @@ export var typeToPathMap = {
     return import('./assets/queue');
   },
   // NOTE: To be deprecated in favor of queue
-  queue: withMetadata(function () {
+  queue: function queue() {
     return import('./assets/queue');
-  }, {
-    synonyms: ['queue', 'line', 'buffer', 'waiting', 'jobs']
-  }),
-  machineLearningApp: withMetadata(function () {
+  },
+  machineLearningApp: function machineLearningApp() {
     return import('./assets/app_ml');
-  }, {
-    category: 'app'
-  }),
+  },
   magnet: function magnet() {
     return import('./assets/magnet');
   },
-  magnify: withMetadata(function () {
+  magnify: function magnify() {
     return import('./assets/magnify');
-  }, {
-    synonyms: ['search', 'find', 'zoom', 'lookup', 'query', 'discover', 'glass']
-  }),
-  magnifyExclamation: withMetadata(function () {
+  },
+  magnifyExclamation: function magnifyExclamation() {
     return import('./assets/magnify_exclamation');
-  }, {
-    synonyms: ['search', 'alert', 'warning', 'find', 'magnify', 'important']
-  }),
-  magnifyMinus: withMetadata(function () {
+  },
+  magnifyMinus: function magnifyMinus() {
     return import('./assets/magnify_minus');
-  }, {
-    synonyms: ['zoom out', 'search', 'minus', 'shrink', 'magnify']
-  }),
-  magnifyPlus: withMetadata(function () {
+  },
+  magnifyPlus: function magnifyPlus() {
     return import('./assets/magnify_plus');
-  }, {
-    synonyms: ['zoom in', 'search', 'plus', 'enlarge', 'magnify']
-  }),
+  },
   magnifyWithExclamation: function magnifyWithExclamation() {
     return import('./assets/magnify_with_exclamation');
   },
@@ -1898,84 +1334,58 @@ export var typeToPathMap = {
     return import('./assets/magnify_with_plus');
   },
   // NOTE: To be deprecated in favor of magnifyPlus,
-  managementApp: withMetadata(function () {
+  managementApp: function managementApp() {
     return import('./assets/app_management');
-  }, {
-    category: 'app'
-  }),
-  map: withMetadata(function () {
+  },
+  map: function map() {
     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: withMetadata(function () {
+  waypoint: function waypoint() {
     return import('./assets/waypoint');
-  }, {
-    synonyms: ['waypoint', 'marker', 'step', 'node', 'path']
-  }),
-  megaphone: withMetadata(function () {
+  },
+  megaphone: function megaphone() {
     return import('./assets/megaphone');
-  }, {
-    synonyms: ['megaphone', 'announce', 'broadcast', 'marketing', 'loud']
-  }),
+  },
   memory: function memory() {
     return import('./assets/memory');
   },
-  menu: withMetadata(function () {
+  menu: function menu() {
     return import('./assets/menu');
-  }, {
-    synonyms: ['menu', 'hamburger', 'navigation', 'options', 'bars']
-  }),
+  },
   menuDown: function menuDown() {
     return import('./assets/menu_down');
   },
-  menuLeft: withMetadata(function () {
+  menuLeft: function menuLeft() {
     return import('./assets/menu_left');
-  }, {
-    synonyms: ['menu left', 'menu', 'hamburger', 'navigation', 'options', 'bars', 'left']
-  }),
-  menuRight: withMetadata(function () {
+  },
+  menuRight: function menuRight() {
     return import('./assets/menu_right');
-  }, {
-    synonyms: ['menu right', 'menu', 'hamburger', 'navigation', 'options', 'bars', 'right']
-  }),
+  },
   menuUp: function menuUp() {
     return import('./assets/menu_up');
   },
-  merge: withMetadata(function () {
+  merge: function merge() {
     return import('./assets/merge');
-  }, {
-    synonyms: ['merge', 'combine', 'join', 'unite', 'git']
-  }),
-  metricbeatApp: withMetadata(function () {
+  },
+  metricbeatApp: function metricbeatApp() {
     return import('./assets/app_metricbeat');
-  }, {
-    category: 'app'
-  }),
-  metricsApp: withMetadata(function () {
+  },
+  metricsApp: function metricsApp() {
     return import('./assets/app_metrics');
-  }, {
-    category: 'app'
-  }),
-  minimize: withMetadata(function () {
+  },
+  minimize: function minimize() {
     return import('./assets/minimize');
-  }, {
-    synonyms: ['minimize']
-  }),
-  minus: withMetadata(function () {
+  },
+  minus: function minus() {
     return import('./assets/minus');
-  }, {
-    synonyms: ['minus', 'remove', 'subtract', 'decrement']
-  }),
-  minusCircle: withMetadata(function () {
+  },
+  minusCircle: function minusCircle() {
     return import('./assets/minus_circle');
-  }, {
-    synonyms: ['minus circle', 'minus', 'remove', 'subtract', 'decrement', 'circle']
-  }),
+  },
   minusInCircle: function minusInCircle() {
     return import('./assets/minus_circle');
   },
@@ -1988,37 +1398,27 @@ export var typeToPathMap = {
     return import('./assets/minus_square');
   },
   // NOTE: To be deprecated in favor of minusSquare
-  minusSquare: withMetadata(function () {
+  minusSquare: function minusSquare() {
     return import('./assets/minus_square');
-  }, {
-    synonyms: ['minus', 'square', 'remove', 'collapse', 'decrement']
-  }),
+  },
   mobile: function mobile() {
     return import('./assets/mobile');
   },
-  monitoringApp: withMetadata(function () {
+  monitoringApp: function monitoringApp() {
     return import('./assets/app_monitoring');
-  }, {
-    category: 'app'
-  }),
-  moon: withMetadata(function () {
+  },
+  moon: function moon() {
     return import('./assets/moon');
-  }, {
-    synonyms: ['moon', 'dark', 'night', 'theme']
-  }),
-  move: withMetadata(function () {
+  },
+  move: function move() {
     return import('./assets/move');
-  }, {
-    synonyms: ['move', 'relocate', 'drag', 'position', 'transfer']
-  }),
+  },
   namespace: function namespace() {
     return import('./assets/namespace');
   },
-  nested: withMetadata(function () {
+  nested: function nested() {
     return import('./assets/nested');
-  }, {
-    synonyms: ['nested', 'hierarchy', 'tree', 'child', 'indent']
-  }),
+  },
   newChat: function newChat() {
     return import('./assets/plus_circle');
   },
@@ -2027,105 +1427,71 @@ export var typeToPathMap = {
     return import('./assets/vector_triangle');
   },
   // NOTE: To be deprecated in favor of vectorTriangle
-  vectorTriangle: withMetadata(function () {
+  vectorTriangle: function vectorTriangle() {
     return import('./assets/vector_triangle');
-  }, {
-    synonyms: ['vector', 'triangle', 'shape', 'geometry', 'delta']
-  }),
-  notebookApp: withMetadata(function () {
+  },
+  notebookApp: function notebookApp() {
     return import('./assets/app_notebook');
-  }, {
-    category: 'app'
-  }),
-  number: withMetadata(function () {
+  },
+  number: function number() {
     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: withMetadata(function () {
+  wifiSlash: function wifiSlash() {
     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: withMetadata(function () {
+  wifi: function wifi() {
     return import('./assets/wifi');
-  }, {
-    synonyms: ['wifi', 'wireless', 'network', 'internet', 'connection']
-  }),
-  outlierDetectionJob: withMetadata(function () {
+  },
+  outlierDetectionJob: function outlierDetectionJob() {
     return import('./assets/ml_outlier_detection_job');
-  }, {
-    category: 'ml'
-  }),
-  package: withMetadata(function () {
+  },
+  package: function _package() {
     return import('./assets/package');
-  }, {
-    synonyms: ['package', 'box', 'bundle', 'npm', 'module']
-  }),
-  packetbeatApp: withMetadata(function () {
+  },
+  packetbeatApp: function packetbeatApp() {
     return import('./assets/app_packetbeat');
-  }, {
-    category: 'app'
-  }),
+  },
   pageSelect: function pageSelect() {
     return import('./assets/page_select');
   },
-  pagesSelect: withMetadata(function () {
+  pagesSelect: function pagesSelect() {
     return import('./assets/pages_select');
-  }, {
-    synonyms: ['pages', 'select', 'pagination', 'choose', 'document']
-  }),
-  palette: withMetadata(function () {
+  },
+  palette: function palette() {
     return import('./assets/palette');
-  }, {
-    synonyms: ['palette', 'colors', 'theme', 'design', 'swatch']
-  }),
-  paperClip: withMetadata(function () {
+  },
+  paperClip: function paperClip() {
     return import('./assets/paper_clip');
-  }, {
-    synonyms: ['attachment', 'clip', 'file', 'attach', 'paperclip']
-  }),
-  partial: withMetadata(function () {
+  },
+  partial: function partial() {
     return import('./assets/partial');
-  }, {
-    synonyms: ['partial', 'incomplete', 'fragment', 'section']
-  }),
-  pause: withMetadata(function () {
+  },
+  pause: function pause() {
     return import('./assets/pause');
-  }, {
-    synonyms: ['pause', 'hold', 'stop temporary', 'wait']
-  }),
+  },
   payment: function payment() {
     return import('./assets/payment');
   },
-  pencil: withMetadata(function () {
+  pencil: function pencil() {
     return import('./assets/pencil');
-  }, {
-    synonyms: ['pencil', 'edit', 'write', 'modify', 'pen']
-  }),
-  percent: withMetadata(function () {
+  },
+  percent: function percent() {
     return import('./assets/percent');
-  }, {
-    synonyms: ['percent', 'percentage', 'ratio', 'rate']
-  }),
-  pin: withMetadata(function () {
+  },
+  pin: function pin() {
     return import('./assets/pin');
-  }, {
-    synonyms: ['pin', 'anchor', 'stick', 'fixed', 'bookmark']
-  }),
-  pinFill: withMetadata(function () {
+  },
+  pinFill: function pinFill() {
     return import('./assets/pin_fill');
-  }, {
-    synonyms: ['pin', 'filled', 'stick', 'anchor', 'fixed', 'bookmark']
-  }),
+  },
   pinFilled: function pinFilled() {
     return import('./assets/pin_fill');
   },
@@ -2134,25 +1500,19 @@ export var typeToPathMap = {
     return import('./assets/line_break');
   },
   // NOTE: To be deprecated in favor of lineBreak
-  pipelineApp: withMetadata(function () {
+  pipelineApp: function pipelineApp() {
     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: withMetadata(function () {
+  pivot: function pivot() {
     return import('./assets/pivot');
-  }, {
-    synonyms: ['pivot', 'table', 'transform', 'rotate', 'analytics']
-  }),
-  play: withMetadata(function () {
+  },
+  play: function play() {
     return import('./assets/play');
-  }, {
-    synonyms: ['play', 'start', 'run', 'media', 'video']
-  }),
+  },
   playFilled: function playFilled() {
     return import('./assets/play_filled');
   },
@@ -2160,16 +1520,12 @@ export var typeToPathMap = {
   plugs: function plugs() {
     return import('./assets/plugs');
   },
-  plus: withMetadata(function () {
+  plus: function plus() {
     return import('./assets/plus');
-  }, {
-    synonyms: ['plus', 'add', 'new', 'create', 'increment']
-  }),
-  plusCircle: withMetadata(function () {
+  },
+  plusCircle: function plusCircle() {
     return import('./assets/plus_circle');
-  }, {
-    synonyms: ['plus circle', 'plus', 'add', 'new', 'create', 'increment', 'circle']
-  }),
+  },
   plusInCircle: function plusInCircle() {
     return import('./assets/plus_circle');
   },
@@ -2182,132 +1538,88 @@ export var typeToPathMap = {
     return import('./assets/plus_square');
   },
   // NOTE: To be deprecated in favor of plusSquare
-  plusSquare: withMetadata(function () {
+  plusSquare: function plusSquare() {
     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: withMetadata(function () {
+  presentation: function presentation() {
     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: withMetadata(function () {
+  productAgent: function productAgent() {
     return import('./assets/product_agent');
-  }, {
-    synonyms: ['agent', 'product', 'elastic agent', 'fleet', 'monitoring']
-  }),
-  productCloudInfra: withMetadata(function () {
+  },
+  productCloudInfra: function productCloudInfra() {
     return import('./assets/product_cloud_infra');
-  }, {
-    synonyms: ['cloud', 'infrastructure', 'product', 'hosting', 'platform']
-  }),
-  productDashboard: withMetadata(function () {
+  },
+  productDashboard: function productDashboard() {
     return import('./assets/product_dashboard');
-  }, {
-    synonyms: ['dashboard', 'product', 'kibana', 'analytics', 'panel']
-  }),
-  productDiscover: withMetadata(function () {
+  },
+  productDiscover: function productDiscover() {
     return import('./assets/product_discover');
-  }, {
-    synonyms: ['discover', 'product', 'explore', 'data', 'search', 'kibana']
-  }),
-  productML: withMetadata(function () {
+  },
+  productML: function productML() {
     return import('./assets/product_ml');
-  }, {
-    synonyms: ['machine learning', 'ml', 'product', 'model', 'ai']
-  }),
-  productStreamsClassic: withMetadata(function () {
+  },
+  productStreamsClassic: function productStreamsClassic() {
     return import('./assets/product_streams_classic');
-  }, {
-    synonyms: ['streams', 'classic', 'product', 'data', 'pipeline']
-  }),
-  productStreamsWired: withMetadata(function () {
+  },
+  productStreamsWired: function productStreamsWired() {
     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: withMetadata(function () {
+  send: function send() {
     return import('./assets/send');
-  }, {
-    synonyms: ['send', 'submit', 'dispatch', 'arrow', 'share']
-  }),
-  question: withMetadata(function () {
+  },
+  question: function question() {
     return import('./assets/question');
-  }, {
-    synonyms: ['question', 'help', 'unknown', 'faq', 'ask']
-  }),
-  quote: withMetadata(function () {
+  },
+  quote: function quote() {
     return import('./assets/quote');
-  }, {
-    synonyms: ['quote', 'citation', 'blockquote', 'text']
-  }),
-  radar: withMetadata(function () {
+  },
+  radar: function radar() {
     return import('./assets/radar');
-  }, {
-    synonyms: ['radar', 'scan', 'detect', 'monitor', 'signal']
-  }),
-  readOnly: withMetadata(function () {
+  },
+  readOnly: function readOnly() {
     return import('./assets/read_only');
-  }, {
-    synonyms: ['read only', 'locked', 'view', 'permission', 'restrict']
-  }),
-  recentlyViewedApp: withMetadata(function () {
+  },
+  recentlyViewedApp: function recentlyViewedApp() {
     return import('./assets/app_recently_viewed');
-  }, {
-    category: 'app'
-  }),
-  refresh: withMetadata(function () {
+  },
+  refresh: function refresh() {
     return import('./assets/refresh');
-  }, {
-    synonyms: ['refresh', 'reload', 'sync', 'update', 'rotate']
-  }),
-  regressionJob: withMetadata(function () {
+  },
+  regressionJob: function regressionJob() {
     return import('./assets/ml_regression_job');
-  }, {
-    category: 'ml'
-  }),
-  reporter: withMetadata(function () {
+  },
+  reporter: function reporter() {
     return import('./assets/reporter');
-  }, {
-    synonyms: ['reporter', 'report', 'export', 'document', 'output']
-  }),
-  reportingApp: withMetadata(function () {
+  },
+  reportingApp: function reportingApp() {
     return import('./assets/app_reporting');
-  }, {
-    category: 'app'
-  }),
-  return: withMetadata(function () {
+  },
+  return: function _return() {
     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: withMetadata(function () {
+  save: function save() {
     return import('./assets/save');
-  }, {
-    synonyms: ['save', 'store', 'disk', 'persist', 'keep']
-  }),
-  savedObjectsApp: withMetadata(function () {
+  },
+  savedObjectsApp: function savedObjectsApp() {
     return import('./assets/app_saved_objects');
-  }, {
-    category: 'app'
-  }),
+  },
   scale: function scale() {
     return import('./assets/scale');
   },
@@ -2315,26 +1627,18 @@ export var typeToPathMap = {
     return import('./assets/magnify');
   },
   // NOTE: To be deprecated in favor of magnify
-  searchProfilerApp: withMetadata(function () {
+  searchProfilerApp: function searchProfilerApp() {
     return import('./assets/app_search_profiler');
-  }, {
-    category: 'app'
-  }),
-  section: withMetadata(function () {
+  },
+  section: function section() {
     return import('./assets/section');
-  }, {
-    synonyms: ['section', 'region', 'block', 'area', 'group']
-  }),
-  securityAnalyticsApp: withMetadata(function () {
+  },
+  securityAnalyticsApp: function securityAnalyticsApp() {
     return import('./assets/app_security_analytics');
-  }, {
-    category: 'app'
-  }),
-  securityApp: withMetadata(function () {
+  },
+  securityApp: function securityApp() {
     return import('./assets/app_security');
-  }, {
-    category: 'app'
-  }),
+  },
   securitySignal: function securitySignal() {
     return import('./assets/security_signal');
   },
@@ -2345,95 +1649,63 @@ export var typeToPathMap = {
   securitySignalResolved: function securitySignalResolved() {
     return import('./assets/security_signal_resolved');
   },
-  server: withMetadata(function () {
+  server: function server() {
     return import('./assets/server');
-  }, {
-    synonyms: ['server', 'host', 'machine', 'infrastructure', 'backend']
-  }),
+  },
   sessionViewer: function sessionViewer() {
     return import('./assets/session_viewer');
   },
-  shard: withMetadata(function () {
+  shard: function shard() {
     return import('./assets/shard');
-  }, {
-    synonyms: ['shard', 'partition', 'segment', 'elastic', 'index']
-  }),
-  share: withMetadata(function () {
+  },
+  share: function share() {
     return import('./assets/share');
-  }, {
-    synonyms: ['share', 'send', 'distribute', 'social', 'export']
-  }),
-  significantEvents: withMetadata(function () {
+  },
+  significantEvents: function significantEvents() {
     return import('./assets/significant_events');
-  }, {
-    synonyms: ['events', 'significant', 'anomaly', 'alert', 'notable', 'timeline']
-  }),
+  },
   singleMetricViewer: function singleMetricViewer() {
     return import('./assets/single_metric_viewer');
   },
-  snowflake: withMetadata(function () {
+  snowflake: function snowflake() {
     return import('./assets/snowflake');
-  }, {
-    synonyms: ['snowflake', 'unique', 'id', 'data warehouse']
-  }),
-  sortAscending: withMetadata(function () {
+  },
+  sortAscending: function sortAscending() {
     return import('./assets/sort_ascending');
-  }, {
-    synonyms: ['sort', 'ascending', 'up', 'order', 'rank', 'increase']
-  }),
-  sortDescending: withMetadata(function () {
+  },
+  sortDescending: function sortDescending() {
     return import('./assets/sort_descending');
-  }, {
-    synonyms: ['sort', 'descending', 'down', 'order', 'rank', 'decrease']
-  }),
-  sortDown: withMetadata(function () {
+  },
+  sortDown: function sortDown() {
     return import('./assets/sort_down');
-  }, {
-    synonyms: ['sort down', 'sort', 'order', 'rank', 'arrange', 'down']
-  }),
-  sortLeft: withMetadata(function () {
+  },
+  sortLeft: function sortLeft() {
     return import('./assets/sort_left');
-  }, {
-    synonyms: ['sort left', 'sort', 'order', 'rank', 'arrange', 'left']
-  }),
-  sortRight: withMetadata(function () {
+  },
+  sortRight: function sortRight() {
     return import('./assets/sort_right');
-  }, {
-    synonyms: ['sort right', 'sort', 'order', 'rank', 'arrange', 'right']
-  }),
-  sortUp: withMetadata(function () {
+  },
+  sortUp: function sortUp() {
     return import('./assets/sort_up');
-  }, {
-    synonyms: ['sort up', 'sort', 'order', 'rank', 'arrange', 'up']
-  }),
-  sortable: withMetadata(function () {
+  },
+  sortable: function sortable() {
     return import('./assets/sortable');
-  }, {
-    synonyms: ['sortable', 'sort', 'order']
-  }),
+  },
   spaces: function spaces() {
     return import('./assets/spaces');
   },
-  spacesApp: withMetadata(function () {
+  spacesApp: function spacesApp() {
     return import('./assets/app_spaces');
-  }, {
-    category: 'app'
-  }),
-  sparkles: withMetadata(function () {
+  },
+  sparkles: function sparkles() {
     return import('./assets/sparkles');
-  }, {
-    synonyms: ['sparkles', 'ai', 'magic', 'new', 'enhance', 'auto']
-  }),
-  sqlApp: withMetadata(function () {
+  },
+  sqlApp: function sqlApp() {
     return import('./assets/app_sql');
-  }, {
-    category: 'app'
-  }),
-  star: withMetadata(function () {
+  },
+  star: function star() {
     return import('./assets/star');
-  }, {
-    synonyms: ['star', 'favorite', 'rating', 'bookmark']
-  }),
+  },
   starEmpty: function starEmpty() {
     return import('./assets/star');
   },
@@ -2441,11 +1713,9 @@ export var typeToPathMap = {
   starEmptySpace: function starEmptySpace() {
     return import('./assets/star_empty_space');
   },
-  starFill: withMetadata(function () {
+  starFill: function starFill() {
     return import('./assets/star_fill');
-  }, {
-    synonyms: ['star fill', 'star', 'favorite', 'rating', 'bookmark', 'fill', 'filled', 'solid']
-  }),
+  },
   starFilled: function starFilled() {
     return import('./assets/star_fill');
   },
@@ -2480,11 +1750,9 @@ export var typeToPathMap = {
   stats: function stats() {
     return import('./assets/stats');
   },
-  stop: withMetadata(function () {
+  stop: function stop() {
     return import('./assets/stop');
-  }, {
-    synonyms: ['stop', 'halt', 'end', 'terminate', 'square']
-  }),
+  },
   stopFill: function stopFill() {
     return import('./assets/stop_fill');
   },
@@ -2495,11 +1763,9 @@ export var typeToPathMap = {
   stopSlash: function stopSlash() {
     return import('./assets/stop_slash');
   },
-  storage: withMetadata(function () {
+  storage: function storage() {
     return import('./assets/storage');
-  }, {
-    synonyms: ['storage', 'disk', 'drive', 'save', 'data store']
-  }),
+  },
   streamsClassic: function streamsClassic() {
     return import('./assets/product_streams_classic');
   },
@@ -2515,38 +1781,30 @@ export var typeToPathMap = {
     return import('./assets/merge');
   },
   // NOTE: To be deprecated in favor of `merge`
-  sun: withMetadata(function () {
+  sun: function sun() {
     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: withMetadata(function () {
+  symlink: function symlink() {
     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: withMetadata(function () {
+  tableDensityHigh: function tableDensityHigh() {
     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: withMetadata(function () {
+  tableDensityLow: function tableDensityLow() {
     return import('./assets/table_density_low');
-  }, {
-    synonyms: ['table', 'density', 'spacious', 'loose', 'rows', 'spacing']
-  }),
+  },
   tableDensityNormal: function tableDensityNormal() {
     return import('./assets/table');
   },
@@ -2554,11 +1812,9 @@ export var typeToPathMap = {
   tableOfContents: function tableOfContents() {
     return import('./assets/table_of_contents');
   },
-  tag: withMetadata(function () {
+  tag: function tag() {
     return import('./assets/tag');
-  }, {
-    synonyms: ['tag', 'label', 'category', 'keyword', 'badge']
-  }),
+  },
   tear: function tear() {
     return import('./assets/tear');
   },
@@ -2566,45 +1822,31 @@ export var typeToPathMap = {
     return import('./assets/thermometer');
   },
   // NOTE: To be deprecated in favor of thermometer
-  thermometer: withMetadata(function () {
+  thermometer: function thermometer() {
     return import('./assets/thermometer');
-  }, {
-    synonyms: ['thermometer', 'temperature', 'heat', 'metric', 'gauge']
-  }),
-  thumbDown: withMetadata(function () {
+  },
+  thumbDown: function thumbDown() {
     return import('./assets/thumb_down');
-  }, {
-    synonyms: ['thumbs down', 'dislike', 'negative', 'vote', 'feedback', 'bad']
-  }),
-  thumbUp: withMetadata(function () {
+  },
+  thumbUp: function thumbUp() {
     return import('./assets/thumb_up');
-  }, {
-    synonyms: ['thumbs up', 'like', 'positive', 'vote', 'feedback', 'good']
-  }),
-  timeline: withMetadata(function () {
+  },
+  timeline: function timeline() {
     return import('./assets/timeline');
-  }, {
-    synonyms: ['timeline', 'history', 'events', 'chronological', 'sequence']
-  }),
-  timelineWithArrow: withMetadata(function () {
+  },
+  timelineWithArrow: function timelineWithArrow() {
     return import('./assets/timeline_with_arrow');
-  }, {
-    synonyms: ['timeline', 'arrow', 'history', 'sequence', 'flow', 'events']
-  }),
-  timelionApp: withMetadata(function () {
+  },
+  timelionApp: function timelionApp() {
     return import('./assets/app_timelion');
-  }, {
-    category: 'app'
-  }),
+  },
   timeRefresh: function timeRefresh() {
     return import('./assets/refresh_time');
   },
   // NOTE: To be deprecated in favor of refreshTime
-  refreshTime: withMetadata(function () {
+  refreshTime: function refreshTime() {
     return import('./assets/refresh_time');
-  }, {
-    synonyms: ['refresh', 'time', 'reload', 'schedule', 'sync', 'clock']
-  }),
+  },
   timeslider: function timeslider() {
     return import('./assets/clock_control');
   },
@@ -2613,41 +1855,27 @@ export var typeToPathMap = {
     return import('./assets/presentation');
   },
   // NOTE: To be deprecated in favor of presentation,
-  transitionBottomIn: withMetadata(function () {
+  transitionBottomIn: function transitionBottomIn() {
     return import('./assets/transition_bottom_in');
-  }, {
-    synonyms: ['transition', 'bottom', 'in', 'animate', 'enter', 'motion']
-  }),
-  transitionBottomOut: withMetadata(function () {
+  },
+  transitionBottomOut: function transitionBottomOut() {
     return import('./assets/transition_bottom_out');
-  }, {
-    synonyms: ['transition', 'bottom', 'out', 'animate', 'exit', 'motion']
-  }),
-  transitionLeftIn: withMetadata(function () {
+  },
+  transitionLeftIn: function transitionLeftIn() {
     return import('./assets/transition_left_in');
-  }, {
-    synonyms: ['transition', 'left', 'in', 'animate', 'enter', 'motion']
-  }),
-  transitionLeftOut: withMetadata(function () {
+  },
+  transitionLeftOut: function transitionLeftOut() {
     return import('./assets/transition_left_out');
-  }, {
-    synonyms: ['transition', 'left', 'out', 'animate', 'exit', 'motion']
-  }),
-  transitionTopIn: withMetadata(function () {
+  },
+  transitionTopIn: function transitionTopIn() {
     return import('./assets/transition_top_in');
-  }, {
-    synonyms: ['transition', 'top', 'in', 'animate', 'enter', 'motion']
-  }),
-  transitionTopOut: withMetadata(function () {
+  },
+  transitionTopOut: function transitionTopOut() {
     return import('./assets/transition_top_out');
-  }, {
-    synonyms: ['transition', 'top', 'out', 'animate', 'exit', 'motion']
-  }),
-  trash: withMetadata(function () {
+  },
+  trash: function trash() {
     return import('./assets/trash');
-  }, {
-    synonyms: ['trash', 'delete', 'remove', 'bin', 'garbage', 'discard']
-  }),
+  },
   unfold: function unfold() {
     return import('./assets/unfold');
   },
@@ -2655,54 +1883,38 @@ export var typeToPathMap = {
     return import('./assets/link_slash');
   },
   // NOTE: To be deprecated in favor of linkSlash
-  upgradeAssistantApp: withMetadata(function () {
+  upgradeAssistantApp: function upgradeAssistantApp() {
     return import('./assets/app_upgrade_assistant');
-  }, {
-    category: 'app'
-  }),
-  uptimeApp: withMetadata(function () {
+  },
+  uptimeApp: function uptimeApp() {
     return import('./assets/app_uptime');
-  }, {
-    category: 'app'
-  }),
-  user: withMetadata(function () {
+  },
+  user: function user() {
     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: withMetadata(function () {
+  users: function users() {
     return import('./assets/users');
-  }, {
-    synonyms: ['users', 'people', 'team', 'group', 'accounts']
-  }),
-  usersRolesApp: withMetadata(function () {
+  },
+  usersRolesApp: function usersRolesApp() {
     return import('./assets/app_users_roles');
-  }, {
-    category: 'app'
-  }),
-  unarchive: withMetadata(function () {
+  },
+  unarchive: function unarchive() {
     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: withMetadata(function () {
+  vectorSquare: function vectorSquare() {
     return import('./assets/vector_square');
-  }, {
-    synonyms: ['vector', 'square', 'shape', 'geometry', 'box', 'region']
-  }),
-  videoPlayer: withMetadata(function () {
+  },
+  videoPlayer: function videoPlayer() {
     return import('./assets/video_player');
-  }, {
-    synonyms: ['video', 'player', 'play', 'media', 'film', 'watch']
-  }),
+  },
   visArea: function visArea() {
     return import('./assets/chart_area');
   },
@@ -2750,11 +1962,9 @@ export var typeToPathMap = {
     return import('./assets/chart_metric');
   },
   // NOTE: To be deprecated in favor of chartMetric
-  chartMetric: withMetadata(function () {
+  chartMetric: function chartMetric() {
     return import('./assets/chart_metric');
-  }, {
-    synonyms: ['metric', 'chart', 'kpi', 'measurement', 'stat', 'indicator']
-  }),
+  },
   visPie: function visPie() {
     return import('./assets/chart_pie');
   },
@@ -2781,35 +1991,25 @@ export var typeToPathMap = {
   visVisualBuilder: function visVisualBuilder() {
     return import('./assets/vis_visual_builder');
   },
-  visualizeApp: withMetadata(function () {
+  visualizeApp: function visualizeApp() {
     return import('./assets/app_visualize');
-  }, {
-    category: 'app'
-  }),
-  vulnerabilityManagementApp: withMetadata(function () {
+  },
+  vulnerabilityManagementApp: function vulnerabilityManagementApp() {
     return import('./assets/app_vulnerability_management');
-  }, {
-    category: 'app'
-  }),
-  warning: withMetadata(function () {
+  },
+  warning: function warning() {
     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: withMetadata(function () {
+  warningFill: function warningFill() {
     return import('./assets/warning_fill');
-  }, {
-    synonyms: ['warning fill', 'warning', 'alert', 'caution', 'danger', 'issue', 'fill', 'filled']
-  }),
-  watchesApp: withMetadata(function () {
+  },
+  watchesApp: function watchesApp() {
     return import('./assets/app_watches');
-  }, {
-    category: 'app'
-  }),
+  },
   web: function web() {
     return import('./assets/web');
   },
@@ -2819,357 +2019,189 @@ export var typeToPathMap = {
   wordWrapDisabled: function wordWrapDisabled() {
     return import('./assets/word_wrap_disabled');
   },
-  workflowsApp: withMetadata(function () {
+  workflowsApp: function workflowsApp() {
     return import('./assets/app_workflows');
-  }, {
-    category: 'app'
-  }),
-  workflow: withMetadata(function () {
+  },
+  workflow: function workflow() {
     return import('./assets/workflow');
-  }, {
-    synonyms: ['workflow', 'automation', 'pipeline', 'process', 'flow']
-  }),
-  workplaceSearchApp: withMetadata(function () {
+  },
+  workplaceSearchApp: function workplaceSearchApp() {
     return import('./assets/app_workplace_search');
-  }, {
-    category: 'app'
-  }),
-  wrench: withMetadata(function () {
+  },
+  wrench: function wrench() {
     return import('./assets/wrench');
-  }, {
-    synonyms: ['wrench', 'tool', 'fix', 'settings', 'repair']
-  }),
+  },
   // Token Icon Imports
-  tokenAlias: withMetadata(function () {
+  tokenAlias: function tokenAlias() {
     return import('./assets/token_alias');
-  }, {
-    category: 'token'
-  }),
-  tokenAnnotation: withMetadata(function () {
+  },
+  tokenAnnotation: function tokenAnnotation() {
     return import('./assets/token_annotation');
-  }, {
-    category: 'token'
-  }),
-  tokenArray: withMetadata(function () {
+  },
+  tokenArray: function tokenArray() {
     return import('./assets/token_array');
-  }, {
-    category: 'token'
-  }),
-  tokenBinary: withMetadata(function () {
+  },
+  tokenBinary: function tokenBinary() {
     return import('./assets/token_binary');
-  }, {
-    category: 'token'
-  }),
-  tokenBoolean: withMetadata(function () {
+  },
+  tokenBoolean: function tokenBoolean() {
     return import('./assets/token_boolean');
-  }, {
-    category: 'token'
-  }),
-  tokenClass: withMetadata(function () {
+  },
+  tokenClass: function tokenClass() {
     return import('./assets/token_class');
-  }, {
-    category: 'token'
-  }),
-  tokenCompletionSuggester: withMetadata(function () {
+  },
+  tokenCompletionSuggester: function tokenCompletionSuggester() {
     return import('./assets/token_completion_suggester');
-  }, {
-    category: 'token'
-  }),
-  tokenConstant: withMetadata(function () {
+  },
+  tokenConstant: function tokenConstant() {
     return import('./assets/token_constant');
-  }, {
-    category: 'token'
-  }),
-  tokenDate: withMetadata(function () {
+  },
+  tokenDate: function tokenDate() {
     return import('./assets/token_date');
-  }, {
-    category: 'token'
-  }),
-  tokenDimension: withMetadata(function () {
+  },
+  tokenDimension: function tokenDimension() {
     return import('./assets/token_dimension');
-  }, {
-    category: 'token'
-  }),
-  tokenElement: withMetadata(function () {
+  },
+  tokenElement: function tokenElement() {
     return import('./assets/token_element');
-  }, {
-    category: 'token'
-  }),
-  tokenEnum: withMetadata(function () {
+  },
+  tokenEnum: function tokenEnum() {
     return import('./assets/token_enum');
-  }, {
-    category: 'token'
-  }),
-  tokenEnumMember: withMetadata(function () {
+  },
+  tokenEnumMember: function tokenEnumMember() {
     return import('./assets/token_enum_member');
-  }, {
-    category: 'token'
-  }),
-  tokenEvent: withMetadata(function () {
+  },
+  tokenEvent: function tokenEvent() {
     return import('./assets/token_event');
-  }, {
-    category: 'token'
-  }),
-  tokenException: withMetadata(function () {
+  },
+  tokenException: function tokenException() {
     return import('./assets/token_exception');
-  }, {
-    category: 'token'
-  }),
-  tokenField: withMetadata(function () {
+  },
+  tokenField: function tokenField() {
     return import('./assets/token_field');
-  }, {
-    category: 'token'
-  }),
-  tokenFile: withMetadata(function () {
+  },
+  tokenFile: function tokenFile() {
     return import('./assets/token_file');
-  }, {
-    category: 'token'
-  }),
-  tokenFlattened: withMetadata(function () {
+  },
+  tokenFlattened: function tokenFlattened() {
     return import('./assets/token_flattened');
-  }, {
-    category: 'token'
-  }),
-  tokenFunction: withMetadata(function () {
+  },
+  tokenFunction: function tokenFunction() {
     return import('./assets/token_function');
-  }, {
-    category: 'token'
-  }),
-  tokenGeo: withMetadata(function () {
+  },
+  tokenGeo: function tokenGeo() {
     return import('./assets/token_geo');
-  }, {
-    category: 'token'
-  }),
-  tokenHistogram: withMetadata(function () {
+  },
+  tokenHistogram: function tokenHistogram() {
     return import('./assets/token_histogram');
-  }, {
-    category: 'token'
-  }),
-  tokenInterface: withMetadata(function () {
+  },
+  tokenInterface: function tokenInterface() {
     return import('./assets/token_interface');
-  }, {
-    category: 'token'
-  }),
-  tokenIP: withMetadata(function () {
+  },
+  tokenIP: function tokenIP() {
     return import('./assets/token_ip');
-  }, {
-    category: 'token'
-  }),
-  tokenJoin: withMetadata(function () {
+  },
+  tokenJoin: function tokenJoin() {
     return import('./assets/token_join');
-  }, {
-    category: 'token'
-  }),
-  tokenKey: withMetadata(function () {
+  },
+  tokenKey: function tokenKey() {
     return import('./assets/token_key');
-  }, {
-    category: 'token'
-  }),
-  tokenKeyword: withMetadata(function () {
+  },
+  tokenKeyword: function tokenKeyword() {
     return import('./assets/token_keyword');
-  }, {
-    category: 'token'
-  }),
-  tokenMethod: withMetadata(function () {
+  },
+  tokenMethod: function tokenMethod() {
     return import('./assets/token_method');
-  }, {
-    category: 'token'
-  }),
-  tokenMetricCounter: withMetadata(function () {
+  },
+  tokenMetricCounter: function tokenMetricCounter() {
     return import('./assets/token_metric_counter');
-  }, {
-    category: 'token'
-  }),
-  tokenMetricGauge: withMetadata(function () {
+  },
+  tokenMetricGauge: function tokenMetricGauge() {
     return import('./assets/token_metric_gauge');
-  }, {
-    category: 'token'
-  }),
-  tokenModule: withMetadata(function () {
+  },
+  tokenModule: function tokenModule() {
     return import('./assets/token_module');
-  }, {
-    category: 'token'
-  }),
-  tokenNamespace: withMetadata(function () {
+  },
+  tokenNamespace: function tokenNamespace() {
     return import('./assets/token_namespace');
-  }, {
-    category: 'token'
-  }),
-  tokenNested: withMetadata(function () {
+  },
+  tokenNested: function tokenNested() {
     return import('./assets/token_nested');
-  }, {
-    category: 'token'
-  }),
-  tokenNull: withMetadata(function () {
+  },
+  tokenNull: function tokenNull() {
     return import('./assets/token_null');
-  }, {
-    category: 'token'
-  }),
-  tokenNumber: withMetadata(function () {
+  },
+  tokenNumber: function tokenNumber() {
     return import('./assets/token_number');
-  }, {
-    category: 'token'
-  }),
-  tokenObject: withMetadata(function () {
+  },
+  tokenObject: function tokenObject() {
     return import('./assets/token_object');
-  }, {
-    category: 'token'
-  }),
-  tokenOperator: withMetadata(function () {
+  },
+  tokenOperator: function tokenOperator() {
     return import('./assets/token_operator');
-  }, {
-    category: 'token'
-  }),
-  tokenPackage: withMetadata(function () {
+  },
+  tokenPackage: function tokenPackage() {
     return import('./assets/token_package');
-  }, {
-    category: 'token'
-  }),
-  tokenParameter: withMetadata(function () {
+  },
+  tokenParameter: function tokenParameter() {
     return import('./assets/token_parameter');
-  }, {
-    category: 'token'
-  }),
-  tokenPercolator: withMetadata(function () {
+  },
+  tokenPercolator: function tokenPercolator() {
     return import('./assets/token_percolator');
-  }, {
-    category: 'token'
-  }),
-  tokenProperty: withMetadata(function () {
+  },
+  tokenProperty: function tokenProperty() {
     return import('./assets/token_property');
-  }, {
-    category: 'token'
-  }),
-  tokenRange: withMetadata(function () {
+  },
+  tokenRange: function tokenRange() {
     return import('./assets/token_range');
-  }, {
-    category: 'token'
-  }),
-  tokenRankFeature: withMetadata(function () {
+  },
+  tokenRankFeature: function tokenRankFeature() {
     return import('./assets/token_rank_feature');
-  }, {
-    category: 'token'
-  }),
-  tokenRankFeatures: withMetadata(function () {
+  },
+  tokenRankFeatures: function tokenRankFeatures() {
     return import('./assets/token_rank_features');
-  }, {
-    category: 'token'
-  }),
-  tokenRepo: withMetadata(function () {
+  },
+  tokenRepo: function tokenRepo() {
     return import('./assets/token_repo');
-  }, {
-    category: 'token'
-  }),
-  tokenSearchType: withMetadata(function () {
+  },
+  tokenSearchType: function tokenSearchType() {
     return import('./assets/token_search_type');
-  }, {
-    category: 'token'
-  }),
-  tokenSemanticText: withMetadata(function () {
+  },
+  tokenSemanticText: function tokenSemanticText() {
     return import('./assets/token_semantic_text');
-  }, {
-    category: 'token'
-  }),
-  tokenShape: withMetadata(function () {
+  },
+  tokenShape: function tokenShape() {
     return import('./assets/token_shape');
-  }, {
-    category: 'token'
-  }),
-  tokenString: withMetadata(function () {
+  },
+  tokenString: function tokenString() {
     return import('./assets/token_string');
-  }, {
-    category: 'token'
-  }),
-  tokenStruct: withMetadata(function () {
+  },
+  tokenStruct: function tokenStruct() {
     return import('./assets/token_struct');
-  }, {
-    category: 'token'
-  }),
-  tokenSymbol: withMetadata(function () {
+  },
+  tokenSymbol: function tokenSymbol() {
     return import('./assets/token_symbol');
-  }, {
-    category: 'token'
-  }),
-  tokenTag: withMetadata(function () {
+  },
+  tokenTag: function tokenTag() {
     return import('./assets/token_tag');
-  }, {
-    category: 'token'
-  }),
-  tokenText: withMetadata(function () {
+  },
+  tokenText: function tokenText() {
     return import('./assets/token_text');
-  }, {
-    category: 'token'
-  }),
-  tokenTokenCount: withMetadata(function () {
+  },
+  tokenTokenCount: function tokenTokenCount() {
     return import('./assets/token_token_count');
-  }, {
-    category: 'token'
-  }),
-  tokenVariable: withMetadata(function () {
+  },
+  tokenVariable: function tokenVariable() {
     return import('./assets/token_variable');
-  }, {
-    category: 'token'
-  }),
-  tokenVectorDense: withMetadata(function () {
+  },
+  tokenVectorDense: function tokenVectorDense() {
     return import('./assets/token_vector_dense');
-  }, {
-    category: 'token'
-  }),
-  tokenDenseVector: withMetadata(function () {
+  },
+  tokenDenseVector: function tokenDenseVector() {
     return import('./assets/token_vector_dense');
-  }, {
-    category: 'token'
-  }),
-  // NOTE: This is an undocumented alias for `tokenVectorDense`, added for legacy compatibility
-  tokenVectorSparse: withMetadata(function () {
+  },
+  // NOTE: This is an undocumented alias for `tokenVectorDense`, added for legacy compatability
+  tokenVectorSparse: function tokenVectorSparse() {
     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]] : [];
-}));
+  }
+};