@blueprintjs/icons

  • Version 4.13.1
  • Published
  • 6.16 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;
'aimpoints-target': 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;
anchor: 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;
at: 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-circle': 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;
'high-voltage-pole': 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;
intelligence: 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;
'low-voltage-pole': 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;
regex: 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-info-sign': 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;
ADD: IconName;
AIRPLANE: IconName;
ANCHOR: IconName;
ANNOTATION: IconName;
ANTENNA: IconName;
APPLICATION: IconName;
APPLICATIONS: IconName;
ARCHIVE: IconName;
ARRAY: IconName;
ASTERISK: IconName;
AT: IconName;
BACKLINK: IconName;
BADGE: IconName;
BARCODE: IconName;
BLANK: IconName;
BOLD: 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;
CIRCLE: IconName;
CITATION: IconName;
CLEAN: IconName;
CLIP: IconName;
CLIPBOARD: IconName;
CLOUD: IconName;
CODE: IconName;
COG: IconName;
COMMENT: IconName;
COMPARISON: IconName;
COMPASS: IconName;
COMPRESSED: IconName;
CONFIRM: IconName;
CONSOLE: IconName;
CONTRAST: IconName;
CONTROL: IconName;
CROSS: IconName;
CROWN: IconName;
CUBE: IconName;
CUT: IconName;
CYCLE: IconName;
DASHBOARD: IconName;
DATABASE: IconName;
DELETE: IconName;
DELTA: IconName;
DESKTOP: IconName;
DIAGNOSIS: IconName;
DISABLE: IconName;
DIVIDE: IconName;
DOCUMENT: 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;
ERROR: IconName;
EURO: IconName;
EXCHANGE: IconName;
EXPORT: IconName;
FEED: IconName;
FILM: IconName;
FILTER: IconName;
FLAG: IconName;
FLAME: IconName;
FLASH: IconName;
FLOWS: IconName;
FOLLOWER: IconName;
FOLLOWING: IconName;
FONT: IconName;
FORK: IconName;
FORM: IconName;
FUEL: IconName;
FULLSCREEN: IconName;
GEOFENCE: IconName;
GEOLOCATION: IconName;
GEOSEARCH: IconName;
GLASS: IconName;
GLOBE: IconName;
GRAPH: IconName;
GRID: IconName;
HAND: IconName;
HAT: IconName;
HEADER: IconName;
HEADSET: IconName;
HEART: IconName;
HEATMAP: IconName;
HELICOPTER: IconName;
HELP: IconName;
HIGHLIGHT: IconName;
HISTORY: IconName;
HOME: IconName;
HURRICANE: IconName;
IMPORT: IconName;
INBOX: IconName;
INHERITANCE: IconName;
INSERT: IconName;
INTELLIGENCE: IconName;
INTERSECTION: IconName;
ISSUE: IconName;
ITALIC: IconName;
KEY: IconName;
LABEL: IconName;
LAYER: IconName;
LAYERS: IconName;
LAYOUT: IconName;
LEARNING: IconName;
LIFESAVER: IconName;
LIGHTBULB: IconName;
LIGHTNING: IconName;
LINK: IconName;
LIST: IconName;
LOCATE: IconName;
LOCK: IconName;
MANUAL: IconName;
MAP: IconName;
MAXIMIZE: IconName;
MEDIA: IconName;
MENU: IconName;
MINIMIZE: IconName;
MINUS: IconName;
MODAL: IconName;
MOON: IconName;
MORE: IconName;
MOUNTAIN: IconName;
MOVE: IconName;
MUGSHOT: IconName;
MUSIC: IconName;
NEST: IconName;
NINJA: IconName;
NOTIFICATIONS: IconName;
NUMERICAL: IconName;
OFFICE: IconName;
OFFLINE: IconName;
OUTDATED: IconName;
PAPERCLIP: IconName;
PARAGRAPH: IconName;
PATH: IconName;
PAUSE: IconName;
PEOPLE: IconName;
PERCENTAGE: IconName;
PERSON: IconName;
PHONE: IconName;
PIN: IconName;
PIVOT: IconName;
PLAY: IconName;
PLAYBOOK: IconName;
PLUS: IconName;
POWER: IconName;
PRESCRIPTION: IconName;
PRESENTATION: IconName;
PRINT: IconName;
PROJECTS: IconName;
PROPERTIES: IconName;
PROPERTY: IconName;
PULSE: IconName;
RAIN: IconName;
RANDOM: IconName;
RECORD: IconName;
RECTANGLE: IconName;
REDO: IconName;
REFRESH: IconName;
REGEX: IconName;
REMOVE: IconName;
REPEAT: IconName;
RESET: IconName;
RESOLVE: IconName;
RIG: IconName;
RING: IconName;
ROCKET: IconName;
ROUTE: IconName;
SATELLITE: IconName;
SAVED: IconName;
SEARCH: IconName;
SELECT: IconName;
SELECTION: IconName;
SETTINGS: IconName;
SHAPES: IconName;
SHARE: IconName;
SHIELD: IconName;
SHIP: IconName;
SHOP: IconName;
SLASH: IconName;
SNOWFLAKE: IconName;
SORT: IconName;
SQUARE: IconName;
STAR: IconName;
STOP: IconName;
STOPWATCH: IconName;
STRIKETHROUGH: IconName;
STYLE: IconName;
SWITCH: IconName;
SYRINGE: IconName;
TAG: IconName;
TANK: IconName;
TARGET: IconName;
TAXI: IconName;
TEMPERATURE: IconName;
TH: IconName;
TICK: IconName;
TIME: IconName;
TINT: IconName;
TORCH: IconName;
TRACTOR: IconName;
TRAIN: IconName;
TRANSLATE: IconName;
TRASH: IconName;
TREE: IconName;
TRUCK: IconName;
UNARCHIVE: IconName;
UNDERLINE: IconName;
UNDO: IconName;
UNLOCK: IconName;
UNPIN: IconName;
UNRESOLVE: IconName;
UPDATED: IconName;
UPLOAD: IconName;
USER: IconName;
VARIABLE: IconName;
VIDEO: 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;
AIMPOINTS_TARGET: 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;
CROSS_CIRCLE: 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;
HIGH_VOLTAGE_POLE: 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;
LOW_VOLTAGE_POLE: 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_INFO_SIGN: 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;
Clip: IconName;
Target: IconName;
Header: IconName;
FloatingPoint: IconName;
Circle: IconName;
Person: IconName;
Ship: IconName;
ArrowDown: IconName;
ArrowLeft: IconName;
ArrowRight: IconName;
ArrowUp: IconName;
Download: IconName;
Upload: IconName;
Layout: IconName;
Add: IconName;
Remove: IconName;
Chart: IconName;
Tree: IconName;
Share: IconName;
ChevronDown: IconName;
ChevronLeft: IconName;
ChevronRight: IconName;
ChevronUp: IconName;
Time: IconName;
List: IconName;
StackedChart: IconName;
Grid: IconName;
Search: IconName;
Control: IconName;
Delete: IconName;
Phone: IconName;
Video: IconName;
Select: IconName;
Layer: IconName;
Layers: IconName;
Link: IconName;
Prescription: IconName;
Box: IconName;
Updated: IconName;
Application: IconName;
Filter: IconName;
Function: IconName;
Document: IconName;
Graph: IconName;
Map: IconName;
Cross: IconName;
InfoSign: IconName;
Minus: IconName;
Plus: IconName;
Square: IconName;
Tick: IconName;
Media: IconName;
Numerical: IconName;
Rectangle: IconName;
Highlight: IconName;
Airplane: IconName;
Anchor: IconName;
Annotation: IconName;
Antenna: IconName;
Applications: IconName;
Archive: IconName;
Array: IconName;
Asterisk: IconName;
At: IconName;
Backlink: IconName;
Badge: IconName;
Barcode: IconName;
Blank: IconName;
Bold: IconName;
Book: IconName;
Bookmark: IconName;
Briefcase: IconName;
Bug: IconName;
Buggy: IconName;
Build: IconName;
Calculator: IconName;
Calendar: IconName;
Camera: IconName;
Changes: IconName;
Chat: IconName;
Citation: IconName;
Clean: IconName;
Clipboard: IconName;
Cloud: IconName;
Code: IconName;
Cog: IconName;
Comment: IconName;
Comparison: IconName;
Compass: IconName;
Compressed: IconName;
Confirm: IconName;
Console: IconName;
Contrast: IconName;
Crown: IconName;
Cube: IconName;
Cut: IconName;
Cycle: IconName;
Dashboard: IconName;
Database: IconName;
Delta: IconName;
Desktop: IconName;
Diagnosis: IconName;
Disable: IconName;
Divide: IconName;
Dollar: IconName;
Dot: IconName;
Draw: IconName;
Duplicate: IconName;
Edit: IconName;
Eject: IconName;
Emoji: IconName;
Endorsed: IconName;
Envelope: IconName;
Equals: IconName;
Eraser: IconName;
Error: IconName;
Euro: IconName;
Exchange: IconName;
Export: IconName;
Feed: IconName;
Film: IconName;
Flag: IconName;
Flame: IconName;
Flash: IconName;
Flows: IconName;
Follower: IconName;
Following: IconName;
Font: IconName;
Fork: IconName;
Form: IconName;
Fuel: IconName;
Fullscreen: IconName;
Geofence: IconName;
Geolocation: IconName;
Geosearch: IconName;
Glass: IconName;
Globe: IconName;
Hand: IconName;
Hat: IconName;
Headset: IconName;
Heart: IconName;
Heatmap: IconName;
Helicopter: IconName;
Help: IconName;
History: IconName;
Home: IconName;
Hurricane: IconName;
Import: IconName;
Inbox: IconName;
Inheritance: IconName;
Insert: IconName;
Intelligence: IconName;
Intersection: IconName;
Issue: IconName;
Italic: IconName;
Key: IconName;
Label: IconName;
Learning: IconName;
Lifesaver: IconName;
Lightbulb: IconName;
Lightning: IconName;
Locate: IconName;
Lock: IconName;
Manual: IconName;
Maximize: IconName;
Menu: IconName;
Minimize: IconName;
Modal: IconName;
Moon: IconName;
More: IconName;
Mountain: IconName;
Move: IconName;
Mugshot: IconName;
Music: IconName;
Nest: IconName;
Ninja: IconName;
Notifications: IconName;
Office: IconName;
Offline: IconName;
Outdated: IconName;
Paperclip: IconName;
Paragraph: IconName;
Path: IconName;
Pause: IconName;
People: IconName;
Percentage: IconName;
Pin: IconName;
Pivot: IconName;
Play: IconName;
Playbook: IconName;
Power: IconName;
Presentation: IconName;
Print: IconName;
Projects: IconName;
Properties: IconName;
Property: IconName;
Pulse: IconName;
Rain: IconName;
Random: IconName;
Record: IconName;
Redo: IconName;
Refresh: IconName;
Regex: IconName;
Repeat: IconName;
Reset: IconName;
Resolve: IconName;
Rig: IconName;
Ring: IconName;
Rocket: IconName;
Route: IconName;
Satellite: IconName;
Saved: IconName;
Selection: IconName;
Settings: IconName;
Shapes: IconName;
Shield: IconName;
Shop: IconName;
Slash: IconName;
Snowflake: IconName;
Sort: IconName;
Star: IconName;
Stop: IconName;
Stopwatch: IconName;
Strikethrough: IconName;
Style: IconName;
Switch: IconName;
Syringe: IconName;
Tag: IconName;
Tank: IconName;
Taxi: IconName;
Temperature: IconName;
Th: IconName;
Tint: IconName;
Torch: IconName;
Tractor: IconName;
Train: IconName;
Translate: IconName;
Trash: IconName;
Truck: IconName;
Unarchive: IconName;
Underline: IconName;
Undo: IconName;
Unlock: IconName;
Unpin: IconName;
Unresolve: IconName;
User: IconName;
Variable: IconName;
Virus: IconName;
Walk: IconName;
Waves: IconName;
Widget: IconName;
Wind: IconName;
Wrench: IconName;
AddClip: IconName;
AddColumnLeft: IconName;
AddColumnRight: IconName;
AddLocation: IconName;
AddRowBottom: IconName;
AddRowTop: IconName;
AddToArtifact: IconName;
AddToFolder: IconName;
AimpointsTarget: IconName;
AlignCenter: IconName;
AlignJustify: IconName;
AlignLeft: IconName;
AlignRight: IconName;
AlignmentBottom: IconName;
AlignmentHorizontalCenter: IconName;
AlignmentLeft: IconName;
AlignmentRight: IconName;
AlignmentTop: IconName;
AlignmentVerticalCenter: IconName;
AppHeader: IconName;
AreaOfInterest: IconName;
ArrayBoolean: IconName;
ArrayDate: IconName;
ArrayFloatingPoint: IconName;
ArrayNumeric: IconName;
ArrayString: IconName;
ArrayTimestamp: IconName;
ArrowBottomLeft: IconName;
ArrowBottomRight: IconName;
ArrowTopLeft: IconName;
ArrowTopRight: IconName;
ArrowsHorizontal: IconName;
ArrowsVertical: IconName;
AutomaticUpdates: IconName;
BanCircle: IconName;
BankAccount: IconName;
BlockedPerson: IconName;
BringData: IconName;
CaretDown: IconName;
CaretLeft: IconName;
CaretRight: IconName;
CaretUp: IconName;
CargoShip: IconName;
CellTower: IconName;
ChevronBackward: IconName;
ChevronForward: IconName;
CircleArrowDown: IconName;
CircleArrowLeft: IconName;
CircleArrowRight: IconName;
CircleArrowUp: IconName;
CloudDownload: IconName;
CloudUpload: IconName;
CodeBlock: IconName;
CollapseAll: IconName;
ColorFill: IconName;
ColumnLayout: IconName;
CreditCard: IconName;
CrossCircle: IconName;
CubeAdd: IconName;
CubeRemove: IconName;
CurvedRangeChart: IconName;
DataConnection: IconName;
DataLineage: IconName;
DeriveColumn: IconName;
DiagramTree: IconName;
DirectionLeft: IconName;
DirectionRight: IconName;
DocumentOpen: IconName;
DocumentShare: IconName;
DoubleCaretHorizontal: IconName;
DoubleCaretVertical: IconName;
DoubleChevronDown: IconName;
DoubleChevronLeft: IconName;
DoubleChevronRight: IconName;
DoubleChevronUp: IconName;
DoughnutChart: IconName;
DragHandleHorizontal: IconName;
DragHandleVertical: IconName;
DrawerLeftFilled: IconName;
DrawerLeft: IconName;
DrawerRightFilled: IconName;
DrawerRight: IconName;
DriveTime: IconName;
ExcludeRow: IconName;
ExpandAll: IconName;
EyeOff: IconName;
EyeOn: IconName;
EyeOpen: IconName;
FastBackward: IconName;
FastForward: IconName;
FeedSubscribed: IconName;
FilterKeep: IconName;
FilterList: IconName;
FilterOpen: IconName;
FilterRemove: IconName;
FloppyDisk: IconName;
FlowBranch: IconName;
FlowEnd: IconName;
FlowLinear: IconName;
FlowReviewBranch: IconName;
FlowReview: IconName;
FolderClose: IconName;
FolderNew: IconName;
FolderOpen: IconName;
FolderSharedOpen: IconName;
FolderShared: IconName;
FullCircle: IconName;
FullStackedChart: IconName;
GanttChart: IconName;
GitBranch: IconName;
GitCommit: IconName;
GitMerge: IconName;
GitNewBranch: IconName;
GitPull: IconName;
GitPush: IconName;
GitRepo: IconName;
GlobeNetwork: IconName;
GraphRemove: IconName;
GreaterThanOrEqualTo: IconName;
GreaterThan: IconName;
GridView: IconName;
GroupObjects: IconName;
GroupedBarChart: IconName;
HandDown: IconName;
HandLeft: IconName;
HandRight: IconName;
HandUp: IconName;
HeaderOne: IconName;
HeaderThree: IconName;
HeaderTwo: IconName;
HeartBroken: IconName;
HeatGrid: IconName;
HelperManagement: IconName;
HighPriority: IconName;
HighVoltagePole: IconName;
HorizontalBarChartAsc: IconName;
HorizontalBarChartDesc: IconName;
HorizontalBarChart: IconName;
HorizontalDistribution: IconName;
HorizontalInbetween: IconName;
IdNumber: IconName;
ImageRotateLeft: IconName;
ImageRotateRight: IconName;
InboxFiltered: IconName;
InboxGeo: IconName;
InboxSearch: IconName;
InboxUpdate: IconName;
InheritedGroup: IconName;
InnerJoin: IconName;
IpAddress: IconName;
IssueClosed: IconName;
IssueNew: IconName;
JoinTable: IconName;
KeyBackspace: IconName;
KeyCommand: IconName;
KeyControl: IconName;
KeyDelete: IconName;
KeyEnter: IconName;
KeyEscape: IconName;
KeyOption: IconName;
KeyShift: IconName;
KeyTab: IconName;
KnownVehicle: IconName;
LabTest: IconName;
LayerOutline: IconName;
LayoutAuto: IconName;
LayoutBalloon: IconName;
LayoutCircle: IconName;
LayoutGrid: IconName;
LayoutGroupBy: IconName;
LayoutHierarchy: IconName;
LayoutLinear: IconName;
LayoutSkewGrid: IconName;
LayoutSortedClusters: IconName;
LeftJoin: IconName;
LessThanOrEqualTo: IconName;
LessThan: IconName;
ListColumns: IconName;
ListDetailView: IconName;
LogIn: IconName;
LogOut: IconName;
LowVoltagePole: IconName;
ManuallyEnteredData: IconName;
ManyToMany: IconName;
ManyToOne: IconName;
MapCreate: IconName;
MapMarker: IconName;
MenuClosed: IconName;
MenuOpen: IconName;
MergeColumns: IconName;
MergeLinks: IconName;
MobilePhone: IconName;
MobileVideo: IconName;
ModalFilled: IconName;
MultiSelect: IconName;
NewDrawing: IconName;
NewGridItem: IconName;
NewLayer: IconName;
NewLayers: IconName;
NewLink: IconName;
NewObject: IconName;
NewPerson: IconName;
NewPrescription: IconName;
NewTextBox: IconName;
NotEqualTo: IconName;
NotificationsSnooze: IconName;
NotificationsUpdated: IconName;
NumberedList: IconName;
OilField: IconName;
OneColumn: IconName;
OneToMany: IconName;
OneToOne: IconName;
OpenApplication: IconName;
PageLayout: IconName;
PanelStats: IconName;
PanelTable: IconName;
PathSearch: IconName;
PieChart: IconName;
PivotTable: IconName;
PolygonFilter: IconName;
PredictiveAnalysis: IconName;
PublishFunction: IconName;
RectHeight: IconName;
RectWidth: IconName;
RegressionChart: IconName;
RemoveColumnLeft: IconName;
RemoveColumnRight: IconName;
RemoveColumn: IconName;
RemoveRowBottom: IconName;
RemoveRowTop: IconName;
RightJoin: IconName;
RocketSlant: IconName;
RotateDocument: IconName;
RotatePage: IconName;
ScatterPlot: IconName;
SearchAround: IconName;
SearchTemplate: IconName;
SearchText: IconName;
SegmentedControl: IconName;
SendMessage: IconName;
SendToGraph: IconName;
SendToMap: IconName;
SendTo: IconName;
SeriesAdd: IconName;
SeriesConfiguration: IconName;
SeriesDerived: IconName;
SeriesFiltered: IconName;
SeriesSearch: IconName;
SharedFilter: IconName;
ShoppingCart: IconName;
SignalSearch: IconName;
SimCard: IconName;
SmallCross: IconName;
SmallInfoSign: IconName;
SmallMinus: IconName;
SmallPlus: IconName;
SmallSquare: IconName;
SmallTick: IconName;
SocialMedia: IconName;
SortAlphabeticalDesc: IconName;
SortAlphabetical: IconName;
SortAsc: IconName;
SortDesc: IconName;
SortNumericalDesc: IconName;
SortNumerical: IconName;
SplitColumns: IconName;
StadiumGeometry: IconName;
StarEmpty: IconName;
StepBackward: IconName;
StepChart: IconName;
StepForward: IconName;
SwapHorizontal: IconName;
SwapVertical: IconName;
SymbolCircle: IconName;
SymbolCross: IconName;
SymbolDiamond: IconName;
SymbolRectangle: IconName;
SymbolSquare: IconName;
SymbolTriangleDown: IconName;
SymbolTriangleUp: IconName;
TakeAction: IconName;
TextHighlight: IconName;
ThDerived: IconName;
ThDisconnect: IconName;
ThFiltered: IconName;
ThList: IconName;
ThirdParty: IconName;
ThumbsDown: IconName;
ThumbsUp: IconName;
TickCircle: IconName;
TimelineAreaChart: IconName;
TimelineBarChart: IconName;
TimelineEvents: IconName;
TimelineLineChart: IconName;
TrendingDown: IconName;
TrendingUp: IconName;
TwoColumns: IconName;
UngroupObjects: IconName;
UnknownVehicle: IconName;
VerticalBarChartAsc: IconName;
VerticalBarChartDesc: IconName;
VerticalDistribution: IconName;
VerticalInbetween: IconName;
VolumeDown: IconName;
VolumeOff: IconName;
VolumeUp: IconName;
WarningSign: IconName;
WaterfallChart: IconName;
WidgetButton: IconName;
WidgetFooter: IconName;
WidgetHeader: 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. This is 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'
    | 'aimpoints-target'
    | 'airplane'
    | 'align-center'
    | 'align-justify'
    | 'align-left'
    | 'align-right'
    | 'alignment-bottom'
    | 'alignment-horizontal-center'
    | 'alignment-left'
    | 'alignment-right'
    | 'alignment-top'
    | 'alignment-vertical-center'
    | 'anchor'
    | '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'
    | 'at'
    | '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-circle'
    | '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'
    | 'high-voltage-pole'
    | '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'
    | 'intelligence'
    | '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'
    | 'low-voltage-pole'
    | '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'
    | 'regex'
    | '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-info-sign'
    | '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-icons/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 AimpointsTarget

                          const AimpointsTarget: 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 Anchor

                                                  const Anchor: 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 At

                                                                                                      const At: 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 CrossCircle

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