@blueprintjs/icons

  • Version 4.2.6
  • Published
  • 6.46 MB
  • 3 dependencies
  • Apache-2.0 license

Install

npm i @blueprintjs/icons
yarn add @blueprintjs/icons
pnpm add @blueprintjs/icons

Overview

Components, fonts, icons, and css files for creating and displaying icons.

Index

Variables

Functions

Type Aliases

Namespaces

Variables

variable IconCodepoints

const IconCodepoints: {
'add-clip': string;
'add-column-left': string;
'add-column-right': string;
'add-location': string;
'add-row-bottom': string;
'add-row-top': string;
'add-to-artifact': string;
'add-to-folder': string;
add: string;
airplane: string;
'align-center': string;
'align-justify': string;
'align-left': string;
'align-right': string;
'alignment-bottom': string;
'alignment-horizontal-center': string;
'alignment-left': string;
'alignment-right': string;
'alignment-top': string;
'alignment-vertical-center': string;
annotation: string;
antenna: string;
'app-header': string;
application: string;
applications: string;
archive: string;
'area-of-interest': string;
'array-boolean': string;
'array-date': string;
'array-numeric': string;
'array-string': string;
'array-timestamp': string;
array: string;
'arrow-bottom-left': string;
'arrow-bottom-right': string;
'arrow-down': string;
'arrow-left': string;
'arrow-right': string;
'arrow-top-left': string;
'arrow-top-right': string;
'arrow-up': string;
'arrows-horizontal': string;
'arrows-vertical': string;
asterisk: string;
'automatic-updates': string;
backlink: string;
badge: string;
'ban-circle': string;
'bank-account': string;
barcode: string;
blank: string;
'blocked-person': string;
bold: string;
book: string;
bookmark: string;
box: string;
briefcase: string;
'bring-data': string;
buggy: string;
build: string;
calculator: string;
calendar: string;
camera: string;
'caret-down': string;
'caret-left': string;
'caret-right': string;
'caret-up': string;
'cargo-ship': string;
'cell-tower': string;
changes: string;
chart: string;
chat: string;
'chevron-backward': string;
'chevron-down': string;
'chevron-forward': string;
'chevron-left': string;
'chevron-right': string;
'chevron-up': string;
'circle-arrow-down': string;
'circle-arrow-left': string;
'circle-arrow-right': string;
'circle-arrow-up': string;
circle: string;
citation: string;
clean: string;
clip: string;
clipboard: string;
'cloud-download': string;
'cloud-upload': string;
cloud: string;
'code-block': string;
code: string;
cog: string;
'collapse-all': string;
'color-fill': string;
'column-layout': string;
comment: string;
comparison: string;
compass: string;
compressed: string;
confirm: string;
console: string;
contrast: string;
control: string;
'credit-card': string;
cross: string;
crown: string;
'cube-add': string;
'cube-remove': string;
cube: string;
'curved-range-chart': string;
cut: string;
cycle: string;
dashboard: string;
'data-connection': string;
'data-lineage': string;
database: string;
delete: string;
delta: string;
'derive-column': string;
desktop: string;
diagnosis: string;
'diagram-tree': string;
'direction-left': string;
'direction-right': string;
disable: string;
divide: string;
'document-open': string;
'document-share': string;
document: string;
dollar: string;
dot: string;
'double-caret-horizontal': string;
'double-caret-vertical': string;
'double-chevron-down': string;
'double-chevron-left': string;
'double-chevron-right': string;
'double-chevron-up': string;
'doughnut-chart': string;
download: string;
'drag-handle-horizontal': string;
'drag-handle-vertical': string;
draw: string;
'drawer-left-filled': string;
'drawer-left': string;
'drawer-right-filled': string;
'drawer-right': string;
'drive-time': string;
duplicate: string;
edit: string;
eject: string;
emoji: string;
endorsed: string;
envelope: string;
equals: string;
eraser: string;
error: string;
euro: string;
exchange: string;
'exclude-row': string;
'expand-all': string;
export: string;
'eye-off': string;
'eye-on': string;
'eye-open': string;
'fast-backward': string;
'fast-forward': string;
'feed-subscribed': string;
feed: string;
film: string;
'filter-keep': string;
'filter-list': string;
'filter-open': string;
'filter-remove': string;
filter: string;
flag: string;
flame: string;
flash: string;
'floppy-disk': string;
'flow-branch': string;
'flow-end': string;
'flow-linear': string;
'flow-review-branch': string;
'flow-review': string;
flows: string;
'folder-close': string;
'folder-new': string;
'folder-open': string;
'folder-shared-open': string;
'folder-shared': string;
follower: string;
following: string;
font: string;
fork: string;
form: string;
fuel: string;
'full-circle': string;
'full-stacked-chart': string;
fullscreen: string;
function: string;
'gantt-chart': string;
geofence: string;
geolocation: string;
geosearch: string;
'git-branch': string;
'git-commit': string;
'git-merge': string;
'git-new-branch': string;
'git-pull': string;
'git-push': string;
'git-repo': string;
glass: string;
'globe-network': string;
globe: string;
'graph-remove': string;
graph: string;
'greater-than-or-equal-to': string;
'greater-than': string;
'grid-view': string;
grid: string;
'group-objects': string;
'grouped-bar-chart': string;
'hand-down': string;
'hand-left': string;
'hand-right': string;
'hand-up': string;
hand: string;
hat: string;
'header-one': string;
'header-three': string;
'header-two': string;
header: string;
headset: string;
'heart-broken': string;
heart: string;
'heat-grid': string;
heatmap: string;
helicopter: string;
help: string;
'helper-management': string;
'high-priority': string;
highlight: string;
history: string;
home: string;
'horizontal-bar-chart-asc': string;
'horizontal-bar-chart-desc': string;
'horizontal-bar-chart': string;
'horizontal-distribution': string;
'horizontal-inbetween': string;
hurricane: string;
'id-number': string;
'image-rotate-left': string;
'image-rotate-right': string;
import: string;
'inbox-filtered': string;
'inbox-geo': string;
'inbox-search': string;
'inbox-update': string;
inbox: string;
'info-sign': string;
inheritance: string;
'inherited-group': string;
'inner-join': string;
insert: string;
intersection: string;
'ip-address': string;
'issue-closed': string;
'issue-new': string;
issue: string;
italic: string;
'join-table': string;
'key-backspace': string;
'key-command': string;
'key-control': string;
'key-delete': string;
'key-enter': string;
'key-escape': string;
'key-option': string;
'key-shift': string;
'key-tab': string;
key: string;
'known-vehicle': string;
'lab-test': string;
label: string;
'layer-outline': string;
layer: string;
layers: string;
'layout-auto': string;
'layout-balloon': string;
'layout-circle': string;
'layout-grid': string;
'layout-group-by': string;
'layout-hierarchy': string;
'layout-linear': string;
'layout-skew-grid': string;
'layout-sorted-clusters': string;
layout: string;
learning: string;
'left-join': string;
'less-than-or-equal-to': string;
'less-than': string;
lifesaver: string;
lightbulb: string;
lightning: string;
link: string;
'list-columns': string;
'list-detail-view': string;
list: string;
locate: string;
lock: string;
'log-in': string;
'log-out': string;
manual: string;
'manually-entered-data': string;
'many-to-many': string;
'many-to-one': string;
'map-create': string;
'map-marker': string;
map: string;
maximize: string;
media: string;
'menu-closed': string;
'menu-open': string;
menu: string;
'merge-columns': string;
'merge-links': string;
minimize: string;
minus: string;
'mobile-phone': string;
'mobile-video': string;
'modal-filled': string;
modal: string;
moon: string;
more: string;
mountain: string;
move: string;
mugshot: string;
'multi-select': string;
music: string;
nest: string;
'new-drawing': string;
'new-grid-item': string;
'new-layer': string;
'new-layers': string;
'new-link': string;
'new-object': string;
'new-person': string;
'new-prescription': string;
'new-text-box': string;
ninja: string;
'not-equal-to': string;
'notifications-snooze': string;
'notifications-updated': string;
notifications: string;
'numbered-list': string;
numerical: string;
office: string;
offline: string;
'oil-field': string;
'one-column': string;
'one-to-many': string;
'one-to-one': string;
'open-application': string;
outdated: string;
'page-layout': string;
'panel-stats': string;
'panel-table': string;
paperclip: string;
paragraph: string;
'path-search': string;
path: string;
pause: string;
people: string;
percentage: string;
person: string;
phone: string;
'pie-chart': string;
pin: string;
'pivot-table': string;
pivot: string;
play: string;
playbook: string;
plus: string;
'polygon-filter': string;
power: string;
'predictive-analysis': string;
prescription: string;
presentation: string;
print: string;
projects: string;
properties: string;
property: string;
'publish-function': string;
pulse: string;
rain: string;
random: string;
record: string;
'rect-height': string;
'rect-width': string;
rectangle: string;
redo: string;
refresh: string;
'regression-chart': string;
'remove-column-left': string;
'remove-column-right': string;
'remove-column': string;
'remove-row-bottom': string;
'remove-row-top': string;
remove: string;
repeat: string;
reset: string;
resolve: string;
rig: string;
'right-join': string;
ring: string;
'rocket-slant': string;
rocket: string;
'rotate-document': string;
'rotate-page': string;
route: string;
satellite: string;
saved: string;
'scatter-plot': string;
'search-around': string;
'search-template': string;
'search-text': string;
search: string;
'segmented-control': string;
select: string;
selection: string;
'send-message': string;
'send-to-graph': string;
'send-to-map': string;
'send-to': string;
'series-add': string;
'series-configuration': string;
'series-derived': string;
'series-filtered': string;
'series-search': string;
settings: string;
shapes: string;
share: string;
'shared-filter': string;
shield: string;
ship: string;
shop: string;
'shopping-cart': string;
'signal-search': string;
'sim-card': string;
slash: string;
'small-cross': string;
'small-minus': string;
'small-plus': string;
'small-square': string;
'small-tick': string;
snowflake: string;
'social-media': string;
'sort-alphabetical-desc': string;
'sort-alphabetical': string;
'sort-asc': string;
'sort-desc': string;
'sort-numerical-desc': string;
'sort-numerical': string;
sort: string;
'split-columns': string;
square: string;
'stacked-chart': string;
'stadium-geometry': string;
'star-empty': string;
star: string;
'step-backward': string;
'step-chart': string;
'step-forward': string;
stop: string;
stopwatch: string;
strikethrough: string;
style: string;
'swap-horizontal': string;
'swap-vertical': string;
switch: string;
'symbol-circle': string;
'symbol-cross': string;
'symbol-diamond': string;
'symbol-rectangle': string;
'symbol-square': string;
'symbol-triangle-down': string;
'symbol-triangle-up': string;
syringe: string;
tag: string;
'take-action': string;
tank: string;
target: string;
taxi: string;
temperature: string;
'text-highlight': string;
'th-derived': string;
'th-disconnect': string;
'th-filtered': string;
'th-list': string;
th: string;
'third-party': string;
'thumbs-down': string;
'thumbs-up': string;
'tick-circle': string;
tick: string;
time: string;
'timeline-area-chart': string;
'timeline-bar-chart': string;
'timeline-events': string;
'timeline-line-chart': string;
tint: string;
torch: string;
tractor: string;
train: string;
translate: string;
trash: string;
tree: string;
'trending-down': string;
'trending-up': string;
truck: string;
'two-columns': string;
unarchive: string;
underline: string;
undo: string;
'ungroup-objects': string;
'unknown-vehicle': string;
unlock: string;
unpin: string;
unresolve: string;
updated: string;
upload: string;
user: string;
variable: string;
'vertical-bar-chart-asc': string;
'vertical-bar-chart-desc': string;
'vertical-distribution': string;
'vertical-inbetween': string;
video: string;
virus: string;
'volume-down': string;
'volume-off': string;
'volume-up': string;
walk: string;
'warning-sign': string;
'waterfall-chart': string;
waves: string;
'widget-button': string;
'widget-footer': string;
'widget-header': string;
widget: string;
wind: string;
wrench: string;
'zoom-in': string;
'zoom-out': string;
'zoom-to-fit': string;
};
  • Icon codepoints as base 10 number strings. If you need to render these strings into an SVG document or as ::before pseudo content, consider using getIconContentString() instead.

variable IconNames

const IconNames: {
FUNCTION: IconName;
SEARCH: IconName;
REPEAT: IconName;
BOLD: IconName;
LINK: IconName;
MAP: IconName;
FILTER: IconName;
SORT: IconName;
CODE: IconName;
ADD: IconName;
ERROR: IconName;
KEY: IconName;
RECORD: IconName;
MEDIA: IconName;
PAUSE: IconName;
PLAY: IconName;
STOP: IconName;
SQUARE: IconName;
GEOLOCATION: IconName;
NOTIFICATIONS: IconName;
MANUAL: IconName;
REMOVE: IconName;
CLIP: IconName;
FONT: IconName;
GRID: IconName;
TRANSLATE: IconName;
MOVE: IconName;
FORM: IconName;
HEADER: IconName;
LABEL: IconName;
MENU: IconName;
SELECT: IconName;
STYLE: IconName;
TH: IconName;
TIME: IconName;
VIDEO: IconName;
CIRCLE: IconName;
PATH: IconName;
SWITCH: IconName;
CUT: IconName;
RESET: IconName;
OFFLINE: IconName;
TARGET: IconName;
REFRESH: IconName;
DOCUMENT: IconName;
HISTORY: IconName;
CONFIRM: IconName;
PRINT: IconName;
APPLICATION: IconName;
USER: IconName;
MAXIMIZE: IconName;
MINIMIZE: IconName;
AIRPLANE: IconName;
ANNOTATION: IconName;
ANTENNA: IconName;
APPLICATIONS: IconName;
ARCHIVE: IconName;
ARRAY: IconName;
ASTERISK: IconName;
BACKLINK: IconName;
BADGE: IconName;
BARCODE: IconName;
BLANK: IconName;
BOOK: IconName;
BOOKMARK: IconName;
BOX: IconName;
BRIEFCASE: IconName;
BUGGY: IconName;
BUILD: IconName;
CALCULATOR: IconName;
CALENDAR: IconName;
CAMERA: IconName;
CHANGES: IconName;
CHART: IconName;
CHAT: IconName;
CITATION: IconName;
CLEAN: IconName;
CLIPBOARD: IconName;
CLOUD: IconName;
COG: IconName;
COMMENT: IconName;
COMPARISON: IconName;
COMPASS: IconName;
COMPRESSED: IconName;
CONSOLE: IconName;
CONTRAST: IconName;
CONTROL: IconName;
CROSS: IconName;
CROWN: IconName;
CUBE: IconName;
CYCLE: IconName;
DASHBOARD: IconName;
DATABASE: IconName;
DELETE: IconName;
DELTA: IconName;
DESKTOP: IconName;
DIAGNOSIS: IconName;
DISABLE: IconName;
DIVIDE: IconName;
DOLLAR: IconName;
DOT: IconName;
DOWNLOAD: IconName;
DRAW: IconName;
DUPLICATE: IconName;
EDIT: IconName;
EJECT: IconName;
EMOJI: IconName;
ENDORSED: IconName;
ENVELOPE: IconName;
EQUALS: IconName;
ERASER: IconName;
EURO: IconName;
EXCHANGE: IconName;
EXPORT: IconName;
FEED: IconName;
FILM: IconName;
FLAG: IconName;
FLAME: IconName;
FLASH: IconName;
FLOWS: IconName;
FOLLOWER: IconName;
FOLLOWING: IconName;
FORK: IconName;
FUEL: IconName;
FULLSCREEN: IconName;
GEOFENCE: IconName;
GEOSEARCH: IconName;
GLASS: IconName;
GLOBE: IconName;
GRAPH: IconName;
HAND: IconName;
HAT: IconName;
HEADSET: IconName;
HEART: IconName;
HEATMAP: IconName;
HELICOPTER: IconName;
HELP: IconName;
HIGHLIGHT: IconName;
HOME: IconName;
HURRICANE: IconName;
IMPORT: IconName;
INBOX: IconName;
INHERITANCE: IconName;
INSERT: IconName;
INTERSECTION: IconName;
ISSUE: IconName;
ITALIC: IconName;
LAYER: IconName;
LAYERS: IconName;
LAYOUT: IconName;
LEARNING: IconName;
LIFESAVER: IconName;
LIGHTBULB: IconName;
LIGHTNING: IconName;
LIST: IconName;
LOCATE: IconName;
LOCK: IconName;
MINUS: IconName;
MODAL: IconName;
MOON: IconName;
MORE: IconName;
MOUNTAIN: IconName;
MUGSHOT: IconName;
MUSIC: IconName;
NEST: IconName;
NINJA: IconName;
NUMERICAL: IconName;
OFFICE: IconName;
OUTDATED: IconName;
PAPERCLIP: IconName;
PARAGRAPH: IconName;
PEOPLE: IconName;
PERCENTAGE: IconName;
PERSON: IconName;
PHONE: IconName;
PIN: IconName;
PIVOT: IconName;
PLAYBOOK: IconName;
PLUS: IconName;
POWER: IconName;
PRESCRIPTION: IconName;
PRESENTATION: IconName;
PROJECTS: IconName;
PROPERTIES: IconName;
PROPERTY: IconName;
PULSE: IconName;
RAIN: IconName;
RANDOM: IconName;
RECTANGLE: IconName;
REDO: IconName;
RESOLVE: IconName;
RIG: IconName;
RING: IconName;
ROCKET: IconName;
ROUTE: IconName;
SATELLITE: IconName;
SAVED: IconName;
SELECTION: IconName;
SETTINGS: IconName;
SHAPES: IconName;
SHARE: IconName;
SHIELD: IconName;
SHIP: IconName;
SHOP: IconName;
SLASH: IconName;
SNOWFLAKE: IconName;
STAR: IconName;
STOPWATCH: IconName;
STRIKETHROUGH: IconName;
SYRINGE: IconName;
TAG: IconName;
TANK: IconName;
TAXI: IconName;
TEMPERATURE: IconName;
TICK: IconName;
TINT: IconName;
TORCH: IconName;
TRACTOR: IconName;
TRAIN: IconName;
TRASH: IconName;
TREE: IconName;
TRUCK: IconName;
UNARCHIVE: IconName;
UNDERLINE: IconName;
UNDO: IconName;
UNLOCK: IconName;
UNPIN: IconName;
UNRESOLVE: IconName;
UPDATED: IconName;
UPLOAD: IconName;
VARIABLE: IconName;
VIRUS: IconName;
WALK: IconName;
WAVES: IconName;
WIDGET: IconName;
WIND: IconName;
WRENCH: IconName;
ADD_CLIP: IconName;
ADD_COLUMN_LEFT: IconName;
ADD_COLUMN_RIGHT: IconName;
ADD_LOCATION: IconName;
ADD_ROW_BOTTOM: IconName;
ADD_ROW_TOP: IconName;
ADD_TO_ARTIFACT: IconName;
ADD_TO_FOLDER: IconName;
ALIGN_CENTER: IconName;
ALIGN_JUSTIFY: IconName;
ALIGN_LEFT: IconName;
ALIGN_RIGHT: IconName;
ALIGNMENT_BOTTOM: IconName;
ALIGNMENT_HORIZONTAL_CENTER: IconName;
ALIGNMENT_LEFT: IconName;
ALIGNMENT_RIGHT: IconName;
ALIGNMENT_TOP: IconName;
ALIGNMENT_VERTICAL_CENTER: IconName;
APP_HEADER: IconName;
AREA_OF_INTEREST: IconName;
ARRAY_BOOLEAN: IconName;
ARRAY_DATE: IconName;
ARRAY_NUMERIC: IconName;
ARRAY_STRING: IconName;
ARRAY_TIMESTAMP: IconName;
ARROW_BOTTOM_LEFT: IconName;
ARROW_BOTTOM_RIGHT: IconName;
ARROW_DOWN: IconName;
ARROW_LEFT: IconName;
ARROW_RIGHT: IconName;
ARROW_TOP_LEFT: IconName;
ARROW_TOP_RIGHT: IconName;
ARROW_UP: IconName;
ARROWS_HORIZONTAL: IconName;
ARROWS_VERTICAL: IconName;
AUTOMATIC_UPDATES: IconName;
BAN_CIRCLE: IconName;
BANK_ACCOUNT: IconName;
BLOCKED_PERSON: IconName;
BRING_DATA: IconName;
CARET_DOWN: IconName;
CARET_LEFT: IconName;
CARET_RIGHT: IconName;
CARET_UP: IconName;
CARGO_SHIP: IconName;
CELL_TOWER: IconName;
CHEVRON_BACKWARD: IconName;
CHEVRON_DOWN: IconName;
CHEVRON_FORWARD: IconName;
CHEVRON_LEFT: IconName;
CHEVRON_RIGHT: IconName;
CHEVRON_UP: IconName;
CIRCLE_ARROW_DOWN: IconName;
CIRCLE_ARROW_LEFT: IconName;
CIRCLE_ARROW_RIGHT: IconName;
CIRCLE_ARROW_UP: IconName;
CLOUD_DOWNLOAD: IconName;
CLOUD_UPLOAD: IconName;
CODE_BLOCK: IconName;
COLLAPSE_ALL: IconName;
COLOR_FILL: IconName;
COLUMN_LAYOUT: IconName;
CREDIT_CARD: IconName;
CUBE_ADD: IconName;
CUBE_REMOVE: IconName;
CURVED_RANGE_CHART: IconName;
DATA_CONNECTION: IconName;
DATA_LINEAGE: IconName;
DERIVE_COLUMN: IconName;
DIAGRAM_TREE: IconName;
DIRECTION_LEFT: IconName;
DIRECTION_RIGHT: IconName;
DOCUMENT_OPEN: IconName;
DOCUMENT_SHARE: IconName;
DOUBLE_CARET_HORIZONTAL: IconName;
DOUBLE_CARET_VERTICAL: IconName;
DOUBLE_CHEVRON_DOWN: IconName;
DOUBLE_CHEVRON_LEFT: IconName;
DOUBLE_CHEVRON_RIGHT: IconName;
DOUBLE_CHEVRON_UP: IconName;
DOUGHNUT_CHART: IconName;
DRAG_HANDLE_HORIZONTAL: IconName;
DRAG_HANDLE_VERTICAL: IconName;
DRAWER_LEFT_FILLED: IconName;
DRAWER_LEFT: IconName;
DRAWER_RIGHT_FILLED: IconName;
DRAWER_RIGHT: IconName;
DRIVE_TIME: IconName;
EXCLUDE_ROW: IconName;
EXPAND_ALL: IconName;
EYE_OFF: IconName;
EYE_ON: IconName;
EYE_OPEN: IconName;
FAST_BACKWARD: IconName;
FAST_FORWARD: IconName;
FEED_SUBSCRIBED: IconName;
FILTER_KEEP: IconName;
FILTER_LIST: IconName;
FILTER_OPEN: IconName;
FILTER_REMOVE: IconName;
FLOPPY_DISK: IconName;
FLOW_BRANCH: IconName;
FLOW_END: IconName;
FLOW_LINEAR: IconName;
FLOW_REVIEW_BRANCH: IconName;
FLOW_REVIEW: IconName;
FOLDER_CLOSE: IconName;
FOLDER_NEW: IconName;
FOLDER_OPEN: IconName;
FOLDER_SHARED_OPEN: IconName;
FOLDER_SHARED: IconName;
FULL_CIRCLE: IconName;
FULL_STACKED_CHART: IconName;
GANTT_CHART: IconName;
GIT_BRANCH: IconName;
GIT_COMMIT: IconName;
GIT_MERGE: IconName;
GIT_NEW_BRANCH: IconName;
GIT_PULL: IconName;
GIT_PUSH: IconName;
GIT_REPO: IconName;
GLOBE_NETWORK: IconName;
GRAPH_REMOVE: IconName;
GREATER_THAN_OR_EQUAL_TO: IconName;
GREATER_THAN: IconName;
GRID_VIEW: IconName;
GROUP_OBJECTS: IconName;
GROUPED_BAR_CHART: IconName;
HAND_DOWN: IconName;
HAND_LEFT: IconName;
HAND_RIGHT: IconName;
HAND_UP: IconName;
HEADER_ONE: IconName;
HEADER_THREE: IconName;
HEADER_TWO: IconName;
HEART_BROKEN: IconName;
HEAT_GRID: IconName;
HELPER_MANAGEMENT: IconName;
HIGH_PRIORITY: IconName;
HORIZONTAL_BAR_CHART_ASC: IconName;
HORIZONTAL_BAR_CHART_DESC: IconName;
HORIZONTAL_BAR_CHART: IconName;
HORIZONTAL_DISTRIBUTION: IconName;
HORIZONTAL_INBETWEEN: IconName;
ID_NUMBER: IconName;
IMAGE_ROTATE_LEFT: IconName;
IMAGE_ROTATE_RIGHT: IconName;
INBOX_FILTERED: IconName;
INBOX_GEO: IconName;
INBOX_SEARCH: IconName;
INBOX_UPDATE: IconName;
INFO_SIGN: IconName;
INHERITED_GROUP: IconName;
INNER_JOIN: IconName;
IP_ADDRESS: IconName;
ISSUE_CLOSED: IconName;
ISSUE_NEW: IconName;
JOIN_TABLE: IconName;
KEY_BACKSPACE: IconName;
KEY_COMMAND: IconName;
KEY_CONTROL: IconName;
KEY_DELETE: IconName;
KEY_ENTER: IconName;
KEY_ESCAPE: IconName;
KEY_OPTION: IconName;
KEY_SHIFT: IconName;
KEY_TAB: IconName;
KNOWN_VEHICLE: IconName;
LAB_TEST: IconName;
LAYER_OUTLINE: IconName;
LAYOUT_AUTO: IconName;
LAYOUT_BALLOON: IconName;
LAYOUT_CIRCLE: IconName;
LAYOUT_GRID: IconName;
LAYOUT_GROUP_BY: IconName;
LAYOUT_HIERARCHY: IconName;
LAYOUT_LINEAR: IconName;
LAYOUT_SKEW_GRID: IconName;
LAYOUT_SORTED_CLUSTERS: IconName;
LEFT_JOIN: IconName;
LESS_THAN_OR_EQUAL_TO: IconName;
LESS_THAN: IconName;
LIST_COLUMNS: IconName;
LIST_DETAIL_VIEW: IconName;
LOG_IN: IconName;
LOG_OUT: IconName;
MANUALLY_ENTERED_DATA: IconName;
MANY_TO_MANY: IconName;
MANY_TO_ONE: IconName;
MAP_CREATE: IconName;
MAP_MARKER: IconName;
MENU_CLOSED: IconName;
MENU_OPEN: IconName;
MERGE_COLUMNS: IconName;
MERGE_LINKS: IconName;
MOBILE_PHONE: IconName;
MOBILE_VIDEO: IconName;
MODAL_FILLED: IconName;
MULTI_SELECT: IconName;
NEW_DRAWING: IconName;
NEW_GRID_ITEM: IconName;
NEW_LAYER: IconName;
NEW_LAYERS: IconName;
NEW_LINK: IconName;
NEW_OBJECT: IconName;
NEW_PERSON: IconName;
NEW_PRESCRIPTION: IconName;
NEW_TEXT_BOX: IconName;
NOT_EQUAL_TO: IconName;
NOTIFICATIONS_SNOOZE: IconName;
NOTIFICATIONS_UPDATED: IconName;
NUMBERED_LIST: IconName;
OIL_FIELD: IconName;
ONE_COLUMN: IconName;
ONE_TO_MANY: IconName;
ONE_TO_ONE: IconName;
OPEN_APPLICATION: IconName;
PAGE_LAYOUT: IconName;
PANEL_STATS: IconName;
PANEL_TABLE: IconName;
PATH_SEARCH: IconName;
PIE_CHART: IconName;
PIVOT_TABLE: IconName;
POLYGON_FILTER: IconName;
PREDICTIVE_ANALYSIS: IconName;
PUBLISH_FUNCTION: IconName;
RECT_HEIGHT: IconName;
RECT_WIDTH: IconName;
REGRESSION_CHART: IconName;
REMOVE_COLUMN_LEFT: IconName;
REMOVE_COLUMN_RIGHT: IconName;
REMOVE_COLUMN: IconName;
REMOVE_ROW_BOTTOM: IconName;
REMOVE_ROW_TOP: IconName;
RIGHT_JOIN: IconName;
ROCKET_SLANT: IconName;
ROTATE_DOCUMENT: IconName;
ROTATE_PAGE: IconName;
SCATTER_PLOT: IconName;
SEARCH_AROUND: IconName;
SEARCH_TEMPLATE: IconName;
SEARCH_TEXT: IconName;
SEGMENTED_CONTROL: IconName;
SEND_MESSAGE: IconName;
SEND_TO_GRAPH: IconName;
SEND_TO_MAP: IconName;
SEND_TO: IconName;
SERIES_ADD: IconName;
SERIES_CONFIGURATION: IconName;
SERIES_DERIVED: IconName;
SERIES_FILTERED: IconName;
SERIES_SEARCH: IconName;
SHARED_FILTER: IconName;
SHOPPING_CART: IconName;
SIGNAL_SEARCH: IconName;
SIM_CARD: IconName;
SMALL_CROSS: IconName;
SMALL_MINUS: IconName;
SMALL_PLUS: IconName;
SMALL_SQUARE: IconName;
SMALL_TICK: IconName;
SOCIAL_MEDIA: IconName;
SORT_ALPHABETICAL_DESC: IconName;
SORT_ALPHABETICAL: IconName;
SORT_ASC: IconName;
SORT_DESC: IconName;
SORT_NUMERICAL_DESC: IconName;
SORT_NUMERICAL: IconName;
SPLIT_COLUMNS: IconName;
STACKED_CHART: IconName;
STADIUM_GEOMETRY: IconName;
STAR_EMPTY: IconName;
STEP_BACKWARD: IconName;
STEP_CHART: IconName;
STEP_FORWARD: IconName;
SWAP_HORIZONTAL: IconName;
SWAP_VERTICAL: IconName;
SYMBOL_CIRCLE: IconName;
SYMBOL_CROSS: IconName;
SYMBOL_DIAMOND: IconName;
SYMBOL_RECTANGLE: IconName;
SYMBOL_SQUARE: IconName;
SYMBOL_TRIANGLE_DOWN: IconName;
SYMBOL_TRIANGLE_UP: IconName;
TAKE_ACTION: IconName;
TEXT_HIGHLIGHT: IconName;
TH_DERIVED: IconName;
TH_DISCONNECT: IconName;
TH_FILTERED: IconName;
TH_LIST: IconName;
THIRD_PARTY: IconName;
THUMBS_DOWN: IconName;
THUMBS_UP: IconName;
TICK_CIRCLE: IconName;
TIMELINE_AREA_CHART: IconName;
TIMELINE_BAR_CHART: IconName;
TIMELINE_EVENTS: IconName;
TIMELINE_LINE_CHART: IconName;
TRENDING_DOWN: IconName;
TRENDING_UP: IconName;
TWO_COLUMNS: IconName;
UNGROUP_OBJECTS: IconName;
UNKNOWN_VEHICLE: IconName;
VERTICAL_BAR_CHART_ASC: IconName;
VERTICAL_BAR_CHART_DESC: IconName;
VERTICAL_DISTRIBUTION: IconName;
VERTICAL_INBETWEEN: IconName;
VOLUME_DOWN: IconName;
VOLUME_OFF: IconName;
VOLUME_UP: IconName;
WARNING_SIGN: IconName;
WATERFALL_CHART: IconName;
WIDGET_BUTTON: IconName;
WIDGET_FOOTER: IconName;
WIDGET_HEADER: IconName;
ZOOM_IN: IconName;
ZOOM_OUT: IconName;
ZOOM_TO_FIT: IconName;
AddClip: IconName;
AddColumnLeft: IconName;
AddColumnRight: IconName;
AddLocation: IconName;
AddRowBottom: IconName;
AddRowTop: IconName;
AddToArtifact: IconName;
AddToFolder: IconName;
Add: IconName;
Airplane: IconName;
AlignCenter: IconName;
AlignJustify: IconName;
AlignLeft: IconName;
AlignRight: IconName;
AlignmentBottom: IconName;
AlignmentHorizontalCenter: IconName;
AlignmentLeft: IconName;
AlignmentRight: IconName;
AlignmentTop: IconName;
AlignmentVerticalCenter: IconName;
Annotation: IconName;
Antenna: IconName;
AppHeader: IconName;
Application: IconName;
Applications: IconName;
Archive: IconName;
AreaOfInterest: IconName;
ArrayBoolean: IconName;
ArrayDate: IconName;
ArrayNumeric: IconName;
ArrayString: IconName;
ArrayTimestamp: IconName;
Array: IconName;
ArrowBottomLeft: IconName;
ArrowBottomRight: IconName;
ArrowDown: IconName;
ArrowLeft: IconName;
ArrowRight: IconName;
ArrowTopLeft: IconName;
ArrowTopRight: IconName;
ArrowUp: IconName;
ArrowsHorizontal: IconName;
ArrowsVertical: IconName;
Asterisk: IconName;
AutomaticUpdates: IconName;
Backlink: IconName;
Badge: IconName;
BanCircle: IconName;
BankAccount: IconName;
Barcode: IconName;
Blank: IconName;
BlockedPerson: IconName;
Bold: IconName;
Book: IconName;
Bookmark: IconName;
Box: IconName;
Briefcase: IconName;
BringData: IconName;
Buggy: IconName;
Build: IconName;
Calculator: IconName;
Calendar: IconName;
Camera: IconName;
CaretDown: IconName;
CaretLeft: IconName;
CaretRight: IconName;
CaretUp: IconName;
CargoShip: IconName;
CellTower: IconName;
Changes: IconName;
Chart: IconName;
Chat: IconName;
ChevronBackward: IconName;
ChevronDown: IconName;
ChevronForward: IconName;
ChevronLeft: IconName;
ChevronRight: IconName;
ChevronUp: IconName;
CircleArrowDown: IconName;
CircleArrowLeft: IconName;
CircleArrowRight: IconName;
CircleArrowUp: IconName;
Circle: IconName;
Citation: IconName;
Clean: IconName;
Clip: IconName;
Clipboard: IconName;
CloudDownload: IconName;
CloudUpload: IconName;
Cloud: IconName;
CodeBlock: IconName;
Code: IconName;
Cog: IconName;
CollapseAll: IconName;
ColorFill: IconName;
ColumnLayout: IconName;
Comment: IconName;
Comparison: IconName;
Compass: IconName;
Compressed: IconName;
Confirm: IconName;
Console: IconName;
Contrast: IconName;
Control: IconName;
CreditCard: IconName;
Cross: IconName;
Crown: IconName;
CubeAdd: IconName;
CubeRemove: IconName;
Cube: IconName;
CurvedRangeChart: IconName;
Cut: IconName;
Cycle: IconName;
Dashboard: IconName;
DataConnection: IconName;
DataLineage: IconName;
Database: IconName;
Delete: IconName;
Delta: IconName;
DeriveColumn: IconName;
Desktop: IconName;
Diagnosis: IconName;
DiagramTree: IconName;
DirectionLeft: IconName;
DirectionRight: IconName;
Disable: IconName;
Divide: IconName;
DocumentOpen: IconName;
DocumentShare: IconName;
Document: IconName;
Dollar: IconName;
Dot: IconName;
DoubleCaretHorizontal: IconName;
DoubleCaretVertical: IconName;
DoubleChevronDown: IconName;
DoubleChevronLeft: IconName;
DoubleChevronRight: IconName;
DoubleChevronUp: IconName;
DoughnutChart: IconName;
Download: IconName;
DragHandleHorizontal: IconName;
DragHandleVertical: IconName;
Draw: IconName;
DrawerLeftFilled: IconName;
DrawerLeft: IconName;
DrawerRightFilled: IconName;
DrawerRight: IconName;
DriveTime: IconName;
Duplicate: IconName;
Edit: IconName;
Eject: IconName;
Emoji: IconName;
Endorsed: IconName;
Envelope: IconName;
Equals: IconName;
Eraser: IconName;
Error: IconName;
Euro: IconName;
Exchange: IconName;
ExcludeRow: IconName;
ExpandAll: IconName;
Export: IconName;
EyeOff: IconName;
EyeOn: IconName;
EyeOpen: IconName;
FastBackward: IconName;
FastForward: IconName;
FeedSubscribed: IconName;
Feed: IconName;
Film: IconName;
FilterKeep: IconName;
FilterList: IconName;
FilterOpen: IconName;
FilterRemove: IconName;
Filter: IconName;
Flag: IconName;
Flame: IconName;
Flash: IconName;
FloppyDisk: IconName;
FlowBranch: IconName;
FlowEnd: IconName;
FlowLinear: IconName;
FlowReviewBranch: IconName;
FlowReview: IconName;
Flows: IconName;
FolderClose: IconName;
FolderNew: IconName;
FolderOpen: IconName;
FolderSharedOpen: IconName;
FolderShared: IconName;
Follower: IconName;
Following: IconName;
Font: IconName;
Fork: IconName;
Form: IconName;
Fuel: IconName;
FullCircle: IconName;
FullStackedChart: IconName;
Fullscreen: IconName;
Function: IconName;
GanttChart: IconName;
Geofence: IconName;
Geolocation: IconName;
Geosearch: IconName;
GitBranch: IconName;
GitCommit: IconName;
GitMerge: IconName;
GitNewBranch: IconName;
GitPull: IconName;
GitPush: IconName;
GitRepo: IconName;
Glass: IconName;
GlobeNetwork: IconName;
Globe: IconName;
GraphRemove: IconName;
Graph: IconName;
GreaterThanOrEqualTo: IconName;
GreaterThan: IconName;
GridView: IconName;
Grid: IconName;
GroupObjects: IconName;
GroupedBarChart: IconName;
HandDown: IconName;
HandLeft: IconName;
HandRight: IconName;
HandUp: IconName;
Hand: IconName;
Hat: IconName;
HeaderOne: IconName;
HeaderThree: IconName;
HeaderTwo: IconName;
Header: IconName;
Headset: IconName;
HeartBroken: IconName;
Heart: IconName;
HeatGrid: IconName;
Heatmap: IconName;
Helicopter: IconName;
Help: IconName;
HelperManagement: IconName;
HighPriority: IconName;
Highlight: IconName;
History: IconName;
Home: IconName;
HorizontalBarChartAsc: IconName;
HorizontalBarChartDesc: IconName;
HorizontalBarChart: IconName;
HorizontalDistribution: IconName;
HorizontalInbetween: IconName;
Hurricane: IconName;
IdNumber: IconName;
ImageRotateLeft: IconName;
ImageRotateRight: IconName;
Import: IconName;
InboxFiltered: IconName;
InboxGeo: IconName;
InboxSearch: IconName;
InboxUpdate: IconName;
Inbox: IconName;
InfoSign: IconName;
Inheritance: IconName;
InheritedGroup: IconName;
InnerJoin: IconName;
Insert: IconName;
Intersection: IconName;
IpAddress: IconName;
IssueClosed: IconName;
IssueNew: IconName;
Issue: IconName;
Italic: IconName;
JoinTable: IconName;
KeyBackspace: IconName;
KeyCommand: IconName;
KeyControl: IconName;
KeyDelete: IconName;
KeyEnter: IconName;
KeyEscape: IconName;
KeyOption: IconName;
KeyShift: IconName;
KeyTab: IconName;
Key: IconName;
KnownVehicle: IconName;
LabTest: IconName;
Label: IconName;
LayerOutline: IconName;
Layer: IconName;
Layers: IconName;
LayoutAuto: IconName;
LayoutBalloon: IconName;
LayoutCircle: IconName;
LayoutGrid: IconName;
LayoutGroupBy: IconName;
LayoutHierarchy: IconName;
LayoutLinear: IconName;
LayoutSkewGrid: IconName;
LayoutSortedClusters: IconName;
Layout: IconName;
Learning: IconName;
LeftJoin: IconName;
LessThanOrEqualTo: IconName;
LessThan: IconName;
Lifesaver: IconName;
Lightbulb: IconName;
Lightning: IconName;
Link: IconName;
ListColumns: IconName;
ListDetailView: IconName;
List: IconName;
Locate: IconName;
Lock: IconName;
LogIn: IconName;
LogOut: IconName;
Manual: IconName;
ManuallyEnteredData: IconName;
ManyToMany: IconName;
ManyToOne: IconName;
MapCreate: IconName;
MapMarker: IconName;
Map: IconName;
Maximize: IconName;
Media: IconName;
MenuClosed: IconName;
MenuOpen: IconName;
Menu: IconName;
MergeColumns: IconName;
MergeLinks: IconName;
Minimize: IconName;
Minus: IconName;
MobilePhone: IconName;
MobileVideo: IconName;
ModalFilled: IconName;
Modal: IconName;
Moon: IconName;
More: IconName;
Mountain: IconName;
Move: IconName;
Mugshot: IconName;
MultiSelect: IconName;
Music: IconName;
Nest: IconName;
NewDrawing: IconName;
NewGridItem: IconName;
NewLayer: IconName;
NewLayers: IconName;
NewLink: IconName;
NewObject: IconName;
NewPerson: IconName;
NewPrescription: IconName;
NewTextBox: IconName;
Ninja: IconName;
NotEqualTo: IconName;
NotificationsSnooze: IconName;
NotificationsUpdated: IconName;
Notifications: IconName;
NumberedList: IconName;
Numerical: IconName;
Office: IconName;
Offline: IconName;
OilField: IconName;
OneColumn: IconName;
OneToMany: IconName;
OneToOne: IconName;
OpenApplication: IconName;
Outdated: IconName;
PageLayout: IconName;
PanelStats: IconName;
PanelTable: IconName;
Paperclip: IconName;
Paragraph: IconName;
PathSearch: IconName;
Path: IconName;
Pause: IconName;
People: IconName;
Percentage: IconName;
Person: IconName;
Phone: IconName;
PieChart: IconName;
Pin: IconName;
PivotTable: IconName;
Pivot: IconName;
Play: IconName;
Playbook: IconName;
Plus: IconName;
PolygonFilter: IconName;
Power: IconName;
PredictiveAnalysis: IconName;
Prescription: IconName;
Presentation: IconName;
Print: IconName;
Projects: IconName;
Properties: IconName;
Property: IconName;
PublishFunction: IconName;
Pulse: IconName;
Rain: IconName;
Random: IconName;
Record: IconName;
RectHeight: IconName;
RectWidth: IconName;
Rectangle: IconName;
Redo: IconName;
Refresh: IconName;
RegressionChart: IconName;
RemoveColumnLeft: IconName;
RemoveColumnRight: IconName;
RemoveColumn: IconName;
RemoveRowBottom: IconName;
RemoveRowTop: IconName;
Remove: IconName;
Repeat: IconName;
Reset: IconName;
Resolve: IconName;
Rig: IconName;
RightJoin: IconName;
Ring: IconName;
RocketSlant: IconName;
Rocket: IconName;
RotateDocument: IconName;
RotatePage: IconName;
Route: IconName;
Satellite: IconName;
Saved: IconName;
ScatterPlot: IconName;
SearchAround: IconName;
SearchTemplate: IconName;
SearchText: IconName;
Search: IconName;
SegmentedControl: IconName;
Select: IconName;
Selection: IconName;
SendMessage: IconName;
SendToGraph: IconName;
SendToMap: IconName;
SendTo: IconName;
SeriesAdd: IconName;
SeriesConfiguration: IconName;
SeriesDerived: IconName;
SeriesFiltered: IconName;
SeriesSearch: IconName;
Settings: IconName;
Shapes: IconName;
Share: IconName;
SharedFilter: IconName;
Shield: IconName;
Ship: IconName;
Shop: IconName;
ShoppingCart: IconName;
SignalSearch: IconName;
SimCard: IconName;
Slash: IconName;
SmallCross: IconName;
SmallMinus: IconName;
SmallPlus: IconName;
SmallSquare: IconName;
SmallTick: IconName;
Snowflake: IconName;
SocialMedia: IconName;
SortAlphabeticalDesc: IconName;
SortAlphabetical: IconName;
SortAsc: IconName;
SortDesc: IconName;
SortNumericalDesc: IconName;
SortNumerical: IconName;
Sort: IconName;
SplitColumns: IconName;
Square: IconName;
StackedChart: IconName;
StadiumGeometry: IconName;
StarEmpty: IconName;
Star: IconName;
StepBackward: IconName;
StepChart: IconName;
StepForward: IconName;
Stop: IconName;
Stopwatch: IconName;
Strikethrough: IconName;
Style: IconName;
SwapHorizontal: IconName;
SwapVertical: IconName;
Switch: IconName;
SymbolCircle: IconName;
SymbolCross: IconName;
SymbolDiamond: IconName;
SymbolRectangle: IconName;
SymbolSquare: IconName;
SymbolTriangleDown: IconName;
SymbolTriangleUp: IconName;
Syringe: IconName;
Tag: IconName;
TakeAction: IconName;
Tank: IconName;
Target: IconName;
Taxi: IconName;
Temperature: IconName;
TextHighlight: IconName;
ThDerived: IconName;
ThDisconnect: IconName;
ThFiltered: IconName;
ThList: IconName;
Th: IconName;
ThirdParty: IconName;
ThumbsDown: IconName;
ThumbsUp: IconName;
TickCircle: IconName;
Tick: IconName;
Time: IconName;
TimelineAreaChart: IconName;
TimelineBarChart: IconName;
TimelineEvents: IconName;
TimelineLineChart: IconName;
Tint: IconName;
Torch: IconName;
Tractor: IconName;
Train: IconName;
Translate: IconName;
Trash: IconName;
Tree: IconName;
TrendingDown: IconName;
TrendingUp: IconName;
Truck: IconName;
TwoColumns: IconName;
Unarchive: IconName;
Underline: IconName;
Undo: IconName;
UngroupObjects: IconName;
UnknownVehicle: IconName;
Unlock: IconName;
Unpin: IconName;
Unresolve: IconName;
Updated: IconName;
Upload: IconName;
User: IconName;
Variable: IconName;
VerticalBarChartAsc: IconName;
VerticalBarChartDesc: IconName;
VerticalDistribution: IconName;
VerticalInbetween: IconName;
Video: IconName;
Virus: IconName;
VolumeDown: IconName;
VolumeOff: IconName;
VolumeUp: IconName;
Walk: IconName;
WarningSign: IconName;
WaterfallChart: IconName;
Waves: IconName;
WidgetButton: IconName;
WidgetFooter: IconName;
WidgetHeader: IconName;
Widget: IconName;
Wind: IconName;
Wrench: IconName;
ZoomIn: IconName;
ZoomOut: IconName;
ZoomToFit: IconName;
};

    Functions

    function getIconContentString

    getIconContentString: (icon: IconName) => string;
    • Returns the hex code content string which represents the codepoint in the icon font for a given icon. You can render this string to the DOM and if the icon font is loaded as an active font family, this string will be replaced with the associated icon.

    function iconNameToPathsRecordKey

    iconNameToPathsRecordKey: (name: IconName) => PascalCase<IconName>;
    • Type safe string literal conversion of snake-case icon names to PascalCase icon names, useful for indexing into the SVG paths record to extract a single icon's SVG path definition.

    Type Aliases

    type IconName

    type BlueprintIcons_16Id =
    | 'add-clip'
    | 'add-column-left'
    | 'add-column-right'
    | 'add-location'
    | 'add-row-bottom'
    | 'add-row-top'
    | 'add-to-artifact'
    | 'add-to-folder'
    | 'add'
    | 'airplane'
    | 'align-center'
    | 'align-justify'
    | 'align-left'
    | 'align-right'
    | 'alignment-bottom'
    | 'alignment-horizontal-center'
    | 'alignment-left'
    | 'alignment-right'
    | 'alignment-top'
    | 'alignment-vertical-center'
    | 'annotation'
    | 'antenna'
    | 'app-header'
    | 'application'
    | 'applications'
    | 'archive'
    | 'area-of-interest'
    | 'array-boolean'
    | 'array-date'
    | 'array-numeric'
    | 'array-string'
    | 'array-timestamp'
    | 'array'
    | 'arrow-bottom-left'
    | 'arrow-bottom-right'
    | 'arrow-down'
    | 'arrow-left'
    | 'arrow-right'
    | 'arrow-top-left'
    | 'arrow-top-right'
    | 'arrow-up'
    | 'arrows-horizontal'
    | 'arrows-vertical'
    | 'asterisk'
    | 'automatic-updates'
    | 'backlink'
    | 'badge'
    | 'ban-circle'
    | 'bank-account'
    | 'barcode'
    | 'blank'
    | 'blocked-person'
    | 'bold'
    | 'book'
    | 'bookmark'
    | 'box'
    | 'briefcase'
    | 'bring-data'
    | 'buggy'
    | 'build'
    | 'calculator'
    | 'calendar'
    | 'camera'
    | 'caret-down'
    | 'caret-left'
    | 'caret-right'
    | 'caret-up'
    | 'cargo-ship'
    | 'cell-tower'
    | 'changes'
    | 'chart'
    | 'chat'
    | 'chevron-backward'
    | 'chevron-down'
    | 'chevron-forward'
    | 'chevron-left'
    | 'chevron-right'
    | 'chevron-up'
    | 'circle-arrow-down'
    | 'circle-arrow-left'
    | 'circle-arrow-right'
    | 'circle-arrow-up'
    | 'circle'
    | 'citation'
    | 'clean'
    | 'clip'
    | 'clipboard'
    | 'cloud-download'
    | 'cloud-upload'
    | 'cloud'
    | 'code-block'
    | 'code'
    | 'cog'
    | 'collapse-all'
    | 'color-fill'
    | 'column-layout'
    | 'comment'
    | 'comparison'
    | 'compass'
    | 'compressed'
    | 'confirm'
    | 'console'
    | 'contrast'
    | 'control'
    | 'credit-card'
    | 'cross'
    | 'crown'
    | 'cube-add'
    | 'cube-remove'
    | 'cube'
    | 'curved-range-chart'
    | 'cut'
    | 'cycle'
    | 'dashboard'
    | 'data-connection'
    | 'data-lineage'
    | 'database'
    | 'delete'
    | 'delta'
    | 'derive-column'
    | 'desktop'
    | 'diagnosis'
    | 'diagram-tree'
    | 'direction-left'
    | 'direction-right'
    | 'disable'
    | 'divide'
    | 'document-open'
    | 'document-share'
    | 'document'
    | 'dollar'
    | 'dot'
    | 'double-caret-horizontal'
    | 'double-caret-vertical'
    | 'double-chevron-down'
    | 'double-chevron-left'
    | 'double-chevron-right'
    | 'double-chevron-up'
    | 'doughnut-chart'
    | 'download'
    | 'drag-handle-horizontal'
    | 'drag-handle-vertical'
    | 'draw'
    | 'drawer-left-filled'
    | 'drawer-left'
    | 'drawer-right-filled'
    | 'drawer-right'
    | 'drive-time'
    | 'duplicate'
    | 'edit'
    | 'eject'
    | 'emoji'
    | 'endorsed'
    | 'envelope'
    | 'equals'
    | 'eraser'
    | 'error'
    | 'euro'
    | 'exchange'
    | 'exclude-row'
    | 'expand-all'
    | 'export'
    | 'eye-off'
    | 'eye-on'
    | 'eye-open'
    | 'fast-backward'
    | 'fast-forward'
    | 'feed-subscribed'
    | 'feed'
    | 'film'
    | 'filter-keep'
    | 'filter-list'
    | 'filter-open'
    | 'filter-remove'
    | 'filter'
    | 'flag'
    | 'flame'
    | 'flash'
    | 'floppy-disk'
    | 'flow-branch'
    | 'flow-end'
    | 'flow-linear'
    | 'flow-review-branch'
    | 'flow-review'
    | 'flows'
    | 'folder-close'
    | 'folder-new'
    | 'folder-open'
    | 'folder-shared-open'
    | 'folder-shared'
    | 'follower'
    | 'following'
    | 'font'
    | 'fork'
    | 'form'
    | 'fuel'
    | 'full-circle'
    | 'full-stacked-chart'
    | 'fullscreen'
    | 'function'
    | 'gantt-chart'
    | 'geofence'
    | 'geolocation'
    | 'geosearch'
    | 'git-branch'
    | 'git-commit'
    | 'git-merge'
    | 'git-new-branch'
    | 'git-pull'
    | 'git-push'
    | 'git-repo'
    | 'glass'
    | 'globe-network'
    | 'globe'
    | 'graph-remove'
    | 'graph'
    | 'greater-than-or-equal-to'
    | 'greater-than'
    | 'grid-view'
    | 'grid'
    | 'group-objects'
    | 'grouped-bar-chart'
    | 'hand-down'
    | 'hand-left'
    | 'hand-right'
    | 'hand-up'
    | 'hand'
    | 'hat'
    | 'header-one'
    | 'header-three'
    | 'header-two'
    | 'header'
    | 'headset'
    | 'heart-broken'
    | 'heart'
    | 'heat-grid'
    | 'heatmap'
    | 'helicopter'
    | 'help'
    | 'helper-management'
    | 'high-priority'
    | 'highlight'
    | 'history'
    | 'home'
    | 'horizontal-bar-chart-asc'
    | 'horizontal-bar-chart-desc'
    | 'horizontal-bar-chart'
    | 'horizontal-distribution'
    | 'horizontal-inbetween'
    | 'hurricane'
    | 'id-number'
    | 'image-rotate-left'
    | 'image-rotate-right'
    | 'import'
    | 'inbox-filtered'
    | 'inbox-geo'
    | 'inbox-search'
    | 'inbox-update'
    | 'inbox'
    | 'info-sign'
    | 'inheritance'
    | 'inherited-group'
    | 'inner-join'
    | 'insert'
    | 'intersection'
    | 'ip-address'
    | 'issue-closed'
    | 'issue-new'
    | 'issue'
    | 'italic'
    | 'join-table'
    | 'key-backspace'
    | 'key-command'
    | 'key-control'
    | 'key-delete'
    | 'key-enter'
    | 'key-escape'
    | 'key-option'
    | 'key-shift'
    | 'key-tab'
    | 'key'
    | 'known-vehicle'
    | 'lab-test'
    | 'label'
    | 'layer-outline'
    | 'layer'
    | 'layers'
    | 'layout-auto'
    | 'layout-balloon'
    | 'layout-circle'
    | 'layout-grid'
    | 'layout-group-by'
    | 'layout-hierarchy'
    | 'layout-linear'
    | 'layout-skew-grid'
    | 'layout-sorted-clusters'
    | 'layout'
    | 'learning'
    | 'left-join'
    | 'less-than-or-equal-to'
    | 'less-than'
    | 'lifesaver'
    | 'lightbulb'
    | 'lightning'
    | 'link'
    | 'list-columns'
    | 'list-detail-view'
    | 'list'
    | 'locate'
    | 'lock'
    | 'log-in'
    | 'log-out'
    | 'manual'
    | 'manually-entered-data'
    | 'many-to-many'
    | 'many-to-one'
    | 'map-create'
    | 'map-marker'
    | 'map'
    | 'maximize'
    | 'media'
    | 'menu-closed'
    | 'menu-open'
    | 'menu'
    | 'merge-columns'
    | 'merge-links'
    | 'minimize'
    | 'minus'
    | 'mobile-phone'
    | 'mobile-video'
    | 'modal-filled'
    | 'modal'
    | 'moon'
    | 'more'
    | 'mountain'
    | 'move'
    | 'mugshot'
    | 'multi-select'
    | 'music'
    | 'nest'
    | 'new-drawing'
    | 'new-grid-item'
    | 'new-layer'
    | 'new-layers'
    | 'new-link'
    | 'new-object'
    | 'new-person'
    | 'new-prescription'
    | 'new-text-box'
    | 'ninja'
    | 'not-equal-to'
    | 'notifications-snooze'
    | 'notifications-updated'
    | 'notifications'
    | 'numbered-list'
    | 'numerical'
    | 'office'
    | 'offline'
    | 'oil-field'
    | 'one-column'
    | 'one-to-many'
    | 'one-to-one'
    | 'open-application'
    | 'outdated'
    | 'page-layout'
    | 'panel-stats'
    | 'panel-table'
    | 'paperclip'
    | 'paragraph'
    | 'path-search'
    | 'path'
    | 'pause'
    | 'people'
    | 'percentage'
    | 'person'
    | 'phone'
    | 'pie-chart'
    | 'pin'
    | 'pivot-table'
    | 'pivot'
    | 'play'
    | 'playbook'
    | 'plus'
    | 'polygon-filter'
    | 'power'
    | 'predictive-analysis'
    | 'prescription'
    | 'presentation'
    | 'print'
    | 'projects'
    | 'properties'
    | 'property'
    | 'publish-function'
    | 'pulse'
    | 'rain'
    | 'random'
    | 'record'
    | 'rect-height'
    | 'rect-width'
    | 'rectangle'
    | 'redo'
    | 'refresh'
    | 'regression-chart'
    | 'remove-column-left'
    | 'remove-column-right'
    | 'remove-column'
    | 'remove-row-bottom'
    | 'remove-row-top'
    | 'remove'
    | 'repeat'
    | 'reset'
    | 'resolve'
    | 'rig'
    | 'right-join'
    | 'ring'
    | 'rocket-slant'
    | 'rocket'
    | 'rotate-document'
    | 'rotate-page'
    | 'route'
    | 'satellite'
    | 'saved'
    | 'scatter-plot'
    | 'search-around'
    | 'search-template'
    | 'search-text'
    | 'search'
    | 'segmented-control'
    | 'select'
    | 'selection'
    | 'send-message'
    | 'send-to-graph'
    | 'send-to-map'
    | 'send-to'
    | 'series-add'
    | 'series-configuration'
    | 'series-derived'
    | 'series-filtered'
    | 'series-search'
    | 'settings'
    | 'shapes'
    | 'share'
    | 'shared-filter'
    | 'shield'
    | 'ship'
    | 'shop'
    | 'shopping-cart'
    | 'signal-search'
    | 'sim-card'
    | 'slash'
    | 'small-cross'
    | 'small-minus'
    | 'small-plus'
    | 'small-square'
    | 'small-tick'
    | 'snowflake'
    | 'social-media'
    | 'sort-alphabetical-desc'
    | 'sort-alphabetical'
    | 'sort-asc'
    | 'sort-desc'
    | 'sort-numerical-desc'
    | 'sort-numerical'
    | 'sort'
    | 'split-columns'
    | 'square'
    | 'stacked-chart'
    | 'stadium-geometry'
    | 'star-empty'
    | 'star'
    | 'step-backward'
    | 'step-chart'
    | 'step-forward'
    | 'stop'
    | 'stopwatch'
    | 'strikethrough'
    | 'style'
    | 'swap-horizontal'
    | 'swap-vertical'
    | 'switch'
    | 'symbol-circle'
    | 'symbol-cross'
    | 'symbol-diamond'
    | 'symbol-rectangle'
    | 'symbol-square'
    | 'symbol-triangle-down'
    | 'symbol-triangle-up'
    | 'syringe'
    | 'tag'
    | 'take-action'
    | 'tank'
    | 'target'
    | 'taxi'
    | 'temperature'
    | 'text-highlight'
    | 'th-derived'
    | 'th-disconnect'
    | 'th-filtered'
    | 'th-list'
    | 'th'
    | 'third-party'
    | 'thumbs-down'
    | 'thumbs-up'
    | 'tick-circle'
    | 'tick'
    | 'time'
    | 'timeline-area-chart'
    | 'timeline-bar-chart'
    | 'timeline-events'
    | 'timeline-line-chart'
    | 'tint'
    | 'torch'
    | 'tractor'
    | 'train'
    | 'translate'
    | 'trash'
    | 'tree'
    | 'trending-down'
    | 'trending-up'
    | 'truck'
    | 'two-columns'
    | 'unarchive'
    | 'underline'
    | 'undo'
    | 'ungroup-objects'
    | 'unknown-vehicle'
    | 'unlock'
    | 'unpin'
    | 'unresolve'
    | 'updated'
    | 'upload'
    | 'user'
    | 'variable'
    | 'vertical-bar-chart-asc'
    | 'vertical-bar-chart-desc'
    | 'vertical-distribution'
    | 'vertical-inbetween'
    | 'video'
    | 'virus'
    | 'volume-down'
    | 'volume-off'
    | 'volume-up'
    | 'walk'
    | 'warning-sign'
    | 'waterfall-chart'
    | 'waves'
    | 'widget-button'
    | 'widget-footer'
    | 'widget-header'
    | 'widget'
    | 'wind'
    | 'wrench'
    | 'zoom-in'
    | 'zoom-out'
    | 'zoom-to-fit';

      Namespaces

      namespace IconSvgPaths16

      module 'lib/esm/generated/16px/paths/index.d.ts' {}

        variable Add

        const Add: string[];

          variable AddClip

          const AddClip: string[];

            variable AddColumnLeft

            const AddColumnLeft: string[];

              variable AddColumnRight

              const AddColumnRight: string[];

                variable AddLocation

                const AddLocation: string[];

                  variable AddRowBottom

                  const AddRowBottom: string[];

                    variable AddRowTop

                    const AddRowTop: string[];

                      variable AddToArtifact

                      const AddToArtifact: string[];

                        variable AddToFolder

                        const AddToFolder: string[];

                          variable Airplane

                          const Airplane: string[];

                            variable AlignCenter

                            const AlignCenter: string[];

                              variable AlignJustify

                              const AlignJustify: string[];

                                variable AlignLeft

                                const AlignLeft: string[];

                                  variable AlignmentBottom

                                  const AlignmentBottom: string[];

                                    variable AlignmentHorizontalCenter

                                    const AlignmentHorizontalCenter: string[];

                                      variable AlignmentLeft

                                      const AlignmentLeft: string[];

                                        variable AlignmentRight

                                        const AlignmentRight: string[];

                                          variable AlignmentTop

                                          const AlignmentTop: string[];

                                            variable AlignmentVerticalCenter

                                            const AlignmentVerticalCenter: string[];

                                              variable AlignRight

                                              const AlignRight: string[];

                                                variable Annotation

                                                const Annotation: string[];

                                                  variable Antenna

                                                  const Antenna: string[];

                                                    variable AppHeader

                                                    const AppHeader: string[];

                                                      variable Application

                                                      const Application: string[];

                                                        variable Applications

                                                        const Applications: string[];

                                                          variable Archive

                                                          const Archive: string[];

                                                            variable AreaOfInterest

                                                            const AreaOfInterest: string[];

                                                              variable Array

                                                              const Array: string[];

                                                                variable ArrayBoolean

                                                                const ArrayBoolean: string[];

                                                                  variable ArrayDate

                                                                  const ArrayDate: string[];

                                                                    variable ArrayNumeric

                                                                    const ArrayNumeric: string[];

                                                                      variable ArrayString

                                                                      const ArrayString: string[];

                                                                        variable ArrayTimestamp

                                                                        const ArrayTimestamp: string[];

                                                                          variable ArrowBottomLeft

                                                                          const ArrowBottomLeft: string[];

                                                                            variable ArrowBottomRight

                                                                            const ArrowBottomRight: string[];

                                                                              variable ArrowDown

                                                                              const ArrowDown: string[];

                                                                                variable ArrowLeft

                                                                                const ArrowLeft: string[];

                                                                                  variable ArrowRight

                                                                                  const ArrowRight: string[];

                                                                                    variable ArrowsHorizontal

                                                                                    const ArrowsHorizontal: string[];

                                                                                      variable ArrowsVertical

                                                                                      const ArrowsVertical: string[];

                                                                                        variable ArrowTopLeft

                                                                                        const ArrowTopLeft: string[];

                                                                                          variable ArrowTopRight

                                                                                          const ArrowTopRight: string[];

                                                                                            variable ArrowUp

                                                                                            const ArrowUp: string[];

                                                                                              variable Asterisk

                                                                                              const Asterisk: string[];

                                                                                                variable AutomaticUpdates

                                                                                                const AutomaticUpdates: string[];
                                                                                                  const Backlink: string[];

                                                                                                    variable Badge

                                                                                                    const Badge: string[];

                                                                                                      variable BanCircle

                                                                                                      const BanCircle: string[];

                                                                                                        variable BankAccount

                                                                                                        const BankAccount: string[];

                                                                                                          variable Barcode

                                                                                                          const Barcode: string[];

                                                                                                            variable Blank

                                                                                                            const Blank: string[];

                                                                                                              variable BlockedPerson

                                                                                                              const BlockedPerson: string[];

                                                                                                                variable Bold

                                                                                                                const Bold: string[];

                                                                                                                  variable Book

                                                                                                                  const Book: string[];

                                                                                                                    variable Bookmark

                                                                                                                    const Bookmark: string[];

                                                                                                                      variable Box

                                                                                                                      const Box: string[];

                                                                                                                        variable Briefcase

                                                                                                                        const Briefcase: string[];

                                                                                                                          variable BringData

                                                                                                                          const BringData: string[];

                                                                                                                            variable Buggy

                                                                                                                            const Buggy: string[];

                                                                                                                              variable Build

                                                                                                                              const Build: string[];

                                                                                                                                variable Calculator

                                                                                                                                const Calculator: string[];

                                                                                                                                  variable Calendar

                                                                                                                                  const Calendar: string[];

                                                                                                                                    variable Camera

                                                                                                                                    const Camera: string[];

                                                                                                                                      variable CaretDown

                                                                                                                                      const CaretDown: string[];

                                                                                                                                        variable CaretLeft

                                                                                                                                        const CaretLeft: string[];

                                                                                                                                          variable CaretRight

                                                                                                                                          const CaretRight: string[];

                                                                                                                                            variable CaretUp

                                                                                                                                            const CaretUp: string[];

                                                                                                                                              variable CargoShip

                                                                                                                                              const CargoShip: string[];

                                                                                                                                                variable CellTower

                                                                                                                                                const CellTower: string[];

                                                                                                                                                  variable Changes

                                                                                                                                                  const Changes: string[];

                                                                                                                                                    variable Chart

                                                                                                                                                    const Chart: string[];

                                                                                                                                                      variable Chat

                                                                                                                                                      const Chat: string[];

                                                                                                                                                        variable ChevronBackward

                                                                                                                                                        const ChevronBackward: string[];

                                                                                                                                                          variable ChevronDown

                                                                                                                                                          const ChevronDown: string[];

                                                                                                                                                            variable ChevronForward

                                                                                                                                                            const ChevronForward: string[];

                                                                                                                                                              variable ChevronLeft

                                                                                                                                                              const ChevronLeft: string[];

                                                                                                                                                                variable ChevronRight

                                                                                                                                                                const ChevronRight: string[];

                                                                                                                                                                  variable ChevronUp

                                                                                                                                                                  const ChevronUp: string[];

                                                                                                                                                                    variable Circle

                                                                                                                                                                    const Circle: string[];

                                                                                                                                                                      variable CircleArrowDown

                                                                                                                                                                      const CircleArrowDown: string[];

                                                                                                                                                                        variable CircleArrowLeft

                                                                                                                                                                        const CircleArrowLeft: string[];

                                                                                                                                                                          variable CircleArrowRight

                                                                                                                                                                          const CircleArrowRight: string[];

                                                                                                                                                                            variable CircleArrowUp

                                                                                                                                                                            const CircleArrowUp: string[];

                                                                                                                                                                              variable Citation

                                                                                                                                                                              const Citation: string[];

                                                                                                                                                                                variable Clean

                                                                                                                                                                                const Clean: string[];

                                                                                                                                                                                  variable Clip

                                                                                                                                                                                  const Clip: string[];

                                                                                                                                                                                    variable Clipboard

                                                                                                                                                                                    const Clipboard: string[];

                                                                                                                                                                                      variable Cloud

                                                                                                                                                                                      const Cloud: string[];

                                                                                                                                                                                        variable CloudDownload

                                                                                                                                                                                        const CloudDownload: string[];

                                                                                                                                                                                          variable CloudUpload

                                                                                                                                                                                          const CloudUpload: string[];

                                                                                                                                                                                            variable Code

                                                                                                                                                                                            const Code: string[];

                                                                                                                                                                                              variable CodeBlock

                                                                                                                                                                                              const CodeBlock: string[];

                                                                                                                                                                                                variable Cog

                                                                                                                                                                                                const Cog: string[];

                                                                                                                                                                                                  variable CollapseAll

                                                                                                                                                                                                  const CollapseAll: string[];

                                                                                                                                                                                                    variable ColorFill

                                                                                                                                                                                                    const ColorFill: string[];

                                                                                                                                                                                                      variable ColumnLayout

                                                                                                                                                                                                      const ColumnLayout: string[];

                                                                                                                                                                                                        variable Comment

                                                                                                                                                                                                        const Comment: string[];

                                                                                                                                                                                                          variable Comparison

                                                                                                                                                                                                          const Comparison: string[];

                                                                                                                                                                                                            variable Compass

                                                                                                                                                                                                            const Compass: string[];

                                                                                                                                                                                                              variable Compressed

                                                                                                                                                                                                              const Compressed: string[];

                                                                                                                                                                                                                variable Confirm

                                                                                                                                                                                                                const Confirm: string[];

                                                                                                                                                                                                                  variable Console

                                                                                                                                                                                                                  const Console: string[];

                                                                                                                                                                                                                    variable Contrast

                                                                                                                                                                                                                    const Contrast: string[];

                                                                                                                                                                                                                      variable Control

                                                                                                                                                                                                                      const Control: string[];

                                                                                                                                                                                                                        variable CreditCard

                                                                                                                                                                                                                        const CreditCard: string[];

                                                                                                                                                                                                                          variable Cross

                                                                                                                                                                                                                          const Cross: string[];

                                                                                                                                                                                                                            variable Crown

                                                                                                                                                                                                                            const Crown: string[];

                                                                                                                                                                                                                              variable Cube

                                                                                                                                                                                                                              const Cube: string[];

                                                                                                                                                                                                                                variable CubeAdd

                                                                                                                                                                                                                                const CubeAdd: string[];

                                                                                                                                                                                                                                  variable CubeRemove

                                                                                                                                                                                                                                  const CubeRemove: string[];

                                                                                                                                                                                                                                    variable CurvedRangeChart

                                                                                                                                                                                                                                    const CurvedRangeChart: string[];

                                                                                                                                                                                                                                      variable Cut

                                                                                                                                                                                                                                      const Cut: string[];

                                                                                                                                                                                                                                        variable Cycle

                                                                                                                                                                                                                                        const Cycle: string[];

                                                                                                                                                                                                                                          variable Dashboard

                                                                                                                                                                                                                                          const Dashboard: string[];

                                                                                                                                                                                                                                            variable Database

                                                                                                                                                                                                                                            const Database: string[];

                                                                                                                                                                                                                                              variable DataConnection

                                                                                                                                                                                                                                              const DataConnection: string[];

                                                                                                                                                                                                                                                variable DataLineage

                                                                                                                                                                                                                                                const DataLineage: string[];

                                                                                                                                                                                                                                                  variable Delete

                                                                                                                                                                                                                                                  const Delete: string[];

                                                                                                                                                                                                                                                    variable Delta

                                                                                                                                                                                                                                                    const Delta: string[];

                                                                                                                                                                                                                                                      variable DeriveColumn

                                                                                                                                                                                                                                                      const DeriveColumn: string[];

                                                                                                                                                                                                                                                        variable Desktop

                                                                                                                                                                                                                                                        const Desktop: string[];

                                                                                                                                                                                                                                                          variable Diagnosis

                                                                                                                                                                                                                                                          const Diagnosis: string[];

                                                                                                                                                                                                                                                            variable DiagramTree

                                                                                                                                                                                                                                                            const DiagramTree: string[];

                                                                                                                                                                                                                                                              variable DirectionLeft

                                                                                                                                                                                                                                                              const DirectionLeft: string[];

                                                                                                                                                                                                                                                                variable DirectionRight

                                                                                                                                                                                                                                                                const DirectionRight: string[];

                                                                                                                                                                                                                                                                  variable Disable

                                                                                                                                                                                                                                                                  const Disable: string[];

                                                                                                                                                                                                                                                                    variable Divide

                                                                                                                                                                                                                                                                    const Divide: string[];

                                                                                                                                                                                                                                                                      variable Document

                                                                                                                                                                                                                                                                      const Document: string[];

                                                                                                                                                                                                                                                                        variable DocumentOpen

                                                                                                                                                                                                                                                                        const DocumentOpen: string[];

                                                                                                                                                                                                                                                                          variable DocumentShare

                                                                                                                                                                                                                                                                          const DocumentShare: string[];

                                                                                                                                                                                                                                                                            variable Dollar

                                                                                                                                                                                                                                                                            const Dollar: string[];

                                                                                                                                                                                                                                                                              variable Dot

                                                                                                                                                                                                                                                                              const Dot: string[];

                                                                                                                                                                                                                                                                                variable DoubleCaretHorizontal

                                                                                                                                                                                                                                                                                const DoubleCaretHorizontal: string[];

                                                                                                                                                                                                                                                                                  variable DoubleCaretVertical

                                                                                                                                                                                                                                                                                  const DoubleCaretVertical: string[];

                                                                                                                                                                                                                                                                                    variable DoubleChevronDown

                                                                                                                                                                                                                                                                                    const DoubleChevronDown: string[];

                                                                                                                                                                                                                                                                                      variable DoubleChevronLeft

                                                                                                                                                                                                                                                                                      const DoubleChevronLeft: string[];

                                                                                                                                                                                                                                                                                        variable DoubleChevronRight

                                                                                                                                                                                                                                                                                        const DoubleChevronRight: string[];

                                                                                                                                                                                                                                                                                          variable DoubleChevronUp

                                                                                                                                                                                                                                                                                          const DoubleChevronUp: string[];

                                                                                                                                                                                                                                                                                            variable DoughnutChart

                                                                                                                                                                                                                                                                                            const DoughnutChart: string[];

                                                                                                                                                                                                                                                                                              variable Download

                                                                                                                                                                                                                                                                                              const Download: string[];

                                                                                                                                                                                                                                                                                                variable DragHandleHorizontal

                                                                                                                                                                                                                                                                                                const DragHandleHorizontal: string[];

                                                                                                                                                                                                                                                                                                  variable DragHandleVertical

                                                                                                                                                                                                                                                                                                  const DragHandleVertical: string[];

                                                                                                                                                                                                                                                                                                    variable Draw

                                                                                                                                                                                                                                                                                                    const Draw: string[];

                                                                                                                                                                                                                                                                                                      variable DrawerLeft

                                                                                                                                                                                                                                                                                                      const DrawerLeft: string[];

                                                                                                                                                                                                                                                                                                        variable DrawerLeftFilled

                                                                                                                                                                                                                                                                                                        const DrawerLeftFilled: string[];

                                                                                                                                                                                                                                                                                                          variable DrawerRight

                                                                                                                                                                                                                                                                                                          const DrawerRight: string[];

                                                                                                                                                                                                                                                                                                            variable DrawerRightFilled

                                                                                                                                                                                                                                                                                                            const DrawerRightFilled: string[];

                                                                                                                                                                                                                                                                                                              variable DriveTime

                                                                                                                                                                                                                                                                                                              const DriveTime: string[];

                                                                                                                                                                                                                                                                                                                variable Duplicate

                                                                                                                                                                                                                                                                                                                const Duplicate: string[];

                                                                                                                                                                                                                                                                                                                  variable Edit

                                                                                                                                                                                                                                                                                                                  const Edit: string[];

                                                                                                                                                                                                                                                                                                                    variable Eject

                                                                                                                                                                                                                                                                                                                    const Eject: string[];

                                                                                                                                                                                                                                                                                                                      variable Emoji

                                                                                                                                                                                                                                                                                                                      const Emoji: string[];

                                                                                                                                                                                                                                                                                                                        variable Endorsed

                                                                                                                                                                                                                                                                                                                        const Endorsed: string[];

                                                                                                                                                                                                                                                                                                                          variable Envelope

                                                                                                                                                                                                                                                                                                                          const Envelope: string[];

                                                                                                                                                                                                                                                                                                                            variable Equals

                                                                                                                                                                                                                                                                                                                            const Equals: string[];

                                                                                                                                                                                                                                                                                                                              variable Eraser

                                                                                                                                                                                                                                                                                                                              const Eraser: string[];

                                                                                                                                                                                                                                                                                                                                variable Error

                                                                                                                                                                                                                                                                                                                                const Error: string[];

                                                                                                                                                                                                                                                                                                                                  variable Euro