@blueprintjs/icons

  • Version 4.6.0
  • Published
  • 6.54 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-floating-point': 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;
bug: 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;
'floating-point': 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;
BUG: 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_FLOATING_POINT: 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;
FLOATING_POINT: 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;
ArrayFloatingPoint: 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;
Bug: 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;
FloatingPoint: 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-floating-point'
    | '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'
    | 'bug'
    | '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'
    | 'floating-point'
    | '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 ArrayFloatingPoint

                                                                    const ArrayFloatingPoint: 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 Bug

                                                                                                                              const Bug: 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

                                                                                                                                                                                                                                                                                                                                      const Euro: string[];

                                                                                                                                                                                                                                                                                                                                        variable Exchange

                                                                                                                                                                                                                                                                                                                                        const Exchange: string[];

                                                                                                                                                                                                                                                                                                                                          variable ExcludeRow

                                                                                                                                                                                                                                                                                                                                          const ExcludeRow: string[];

                                                                                                                                                                                                                                                                                                                                            variable ExpandAll

                                                                                                                                                                                                                                                                                                                                            const ExpandAll: string[];

                                                                                                                                                                                                                                                                                                                                              variable Export

                                                                                                                                                                                                                                                                                                                                              const Export: string[];

                                                                                                                                                                                                                                                                                                                                                variable EyeOff

                                                                                                                                                                                                                                                                                                                                                const EyeOff: string[];

                                                                                                                                                                                                                                                                                                                                                  variable EyeOn

                                                                                                                                                                                                                                                                                                                                                  const EyeOn: string[];

                                                                                                                                                                                                                                                                                                                                                    variable EyeOpen

                                                                                                                                                                                                                                                                                                                                                    const EyeOpen: string[];

                                                                                                                                                                                                                                                                                                                                                      variable FastBackward

                                                                                                                                                                                                                                                                                                                                                      const FastBackward: string[];

                                                                                                                                                                                                                                                                                                                                                        variable FastForward

                                                                                                                                                                                                                                                                                                                                                        const FastForward: string[];

                                                                                                                                                                                                                                                                                                                                                          variable Feed

                                                                                                                                                                                                                                                                                                                                                          const Feed: string[];

                                                                                                                                                                                                                                                                                                                                                            variable FeedSubscribed

                                                                                                                                                                                                                                                                                                                                                            const FeedSubscribed: string[];

                                                                                                                                                                                                                                                                                                                                                              variable Film

                                                                                                                                                                                                                                                                                                                                                              const Film: string[];

                                                                                                                                                                                                                                                                                                                                                                variable Filter

                                                                                                                                                                                                                                                                                                                                                                const Filter: string[];

                                                                                                                                                                                                                                                                                                                                                                  variable FilterKeep

                                                                                                                                                                                                                                                                                                                                                                  const FilterKeep: string[];

                                                                                                                                                                                                                                                                                                                                                                    variable FilterList

                                                                                                                                                                                                                                                                                                                                                                    const FilterList: string[];

                                                                                                                                                                                                                                                                                                                                                                      variable FilterOpen

                                                                                                                                                                                                                                                                                                                                                                      const FilterOpen: string[];

                                                                                                                                                                                                                                                                                                                                                                        variable FilterRemove

                                                                                                                                                                                                                                                                                                                                                                        const FilterRemove: string[];

                                                                                                                                                                                                                                                                                                                                                                          variable Flag

                                                                                                                                                                                                                                                                                                                                                                          const Flag: string[];

                                                                                                                                                                                                                                                                                                                                                                            variable Flame

                                                                                                                                                                                                                                                                                                                                                                            const Flame: string[];

                                                                                                                                                                                                                                                                                                                                                                              variable Flash

                                                                                                                                                                                                                                                                                                                                                                              const Flash: string[];

                                                                                                                                                                                                                                                                                                                                                                                variable FloatingPoint

                                                                                                                                                                                                                                                                                                                                                                                const FloatingPoint: string[];

                                                                                                                                                                                                                                                                                                                                                                                  variable FloppyDisk

                                                                                                                                                                                                                                                                                                                                                                                  const FloppyDisk: string[];

                                                                                                                                                                                                                                                                                                                                                                                    variable FlowBranch

                                                                                                                                                                                                                                                                                                                                                                                    const FlowBranch: string[];

                                                                                                                                                                                                                                                                                                                                                                                      variable FlowEnd

                                                                                                                                                                                                                                                                                                                                                                                      const FlowEnd: string[];

                                                                                                                                                                                                                                                                                                                                                                                        variable FlowLinear

                                                                                                                                                                                                                                                                                                                                                                                        const FlowLinear: string[];

                                                                                                                                                                                                                                                                                                                                                                                          variable FlowReview

                                                                                                                                                                                                                                                                                                                                                                                          const FlowReview: string[];

                                                                                                                                                                                                                                                                                                                                                                                            variable FlowReviewBranch

                                                                                                                                                                                                                                                                                                                                                                                            const FlowReviewBranch: string[];

                                                                                                                                                                                                                                                                                                                                                                                              variable Flows

                                                                                                                                                                                                                                                                                                                                                                                              const Flows: string[];

                                                                                                                                                                                                                                                                                                                                                                                                variable FolderClose

                                                                                                                                                                                                                                                                                                                                                                                                const FolderClose: string[];

                                                                                                                                                                                                                                                                                                                                                                                                  variable FolderNew

                                                                                                                                                                                                                                                                                                                                                                                                  const FolderNew: string[];

                                                                                                                                                                                                                                                                                                                                                                                                    variable FolderOpen

                                                                                                                                                                                                                                                                                                                                                                                                    const FolderOpen: string[];

                                                                                                                                                                                                                                                                                                                                                                                                      variable FolderShared

                                                                                                                                                                                                                                                                                                                                                                                                      const FolderShared: string[];

                                                                                                                                                                                                                                                                                                                                                                                                        variable FolderSharedOpen

                                                                                                                                                                                                                                                                                                                                                                                                        const FolderSharedOpen: string[];

                                                                                                                                                                                                                                                                                                                                                                                                          variable Follower

                                                                                                                                                                                                                                                                                                                                                                                                          const Follower: string[];

                                                                                                                                                                                                                                                                                                                                                                                                            variable Following

                                                                                                                                                                                                                                                                                                                                                                                                            const Following: string[];

                                                                                                                                                                                                                                                                                                                                                                                                              variable Font

                                                                                                                                                                                                                                                                                                                                                                                                              const Font: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                variable Fork

                                                                                                                                                                                                                                                                                                                                                                                                                const Fork: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                  variable Form

                                                                                                                                                                                                                                                                                                                                                                                                                  const Form: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                    variable Fuel

                                                                                                                                                                                                                                                                                                                                                                                                                    const Fuel: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                      variable FullCircle

                                                                                                                                                                                                                                                                                                                                                                                                                      const FullCircle: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                        variable Fullscreen

                                                                                                                                                                                                                                                                                                                                                                                                                        const Fullscreen: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                          variable FullStackedChart

                                                                                                                                                                                                                                                                                                                                                                                                                          const FullStackedChart: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                            variable Function

                                                                                                                                                                                                                                                                                                                                                                                                                            const Function: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                              variable GanttChart

                                                                                                                                                                                                                                                                                                                                                                                                                              const GanttChart: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                variable Geofence

                                                                                                                                                                                                                                                                                                                                                                                                                                const Geofence: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                  variable Geolocation

                                                                                                                                                                                                                                                                                                                                                                                                                                  const Geolocation: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                    variable Geosearch

                                                                                                                                                                                                                                                                                                                                                                                                                                    const Geosearch: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                      variable GitBranch

                                                                                                                                                                                                                                                                                                                                                                                                                                      const GitBranch: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                        variable GitCommit

                                                                                                                                                                                                                                                                                                                                                                                                                                        const GitCommit: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                          variable GitMerge

                                                                                                                                                                                                                                                                                                                                                                                                                                          const GitMerge: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                            variable GitNewBranch

                                                                                                                                                                                                                                                                                                                                                                                                                                            const