diff --git a/packages/__docs__/components.ts b/packages/__docs__/components.ts
index 4145d9c9b4..5fc4821138 100644
--- a/packages/__docs__/components.ts
+++ b/packages/__docs__/components.ts
@@ -123,6 +123,7 @@ export { View, ContextView } from '@instructure/ui-view'
 export { Tray } from '@instructure/ui-tray'
 export { Spinner } from '@instructure/ui-spinner'
 export * from '@instructure/ui-icons'
+export * from '@instructure/ui-icons-lucide'
 // eslint-disable-next-line no-restricted-imports
 export { Guidelines } from './src/Guidelines'
 // eslint-disable-next-line no-restricted-imports
diff --git a/packages/__docs__/package.json b/packages/__docs__/package.json
index eb62cd8e56..a0ec908850 100644
--- a/packages/__docs__/package.json
+++ b/packages/__docs__/package.json
@@ -64,6 +64,7 @@
     "@instructure/ui-heading": "workspace:*",
     "@instructure/ui-i18n": "workspace:*",
     "@instructure/ui-icons": "workspace:*",
+    "@instructure/ui-icons-lucide": "workspace:*",
     "@instructure/ui-img": "workspace:*",
     "@instructure/ui-instructure": "workspace:*",
     "@instructure/ui-link": "workspace:*",
diff --git a/packages/__docs__/src/Icons/LegacyIconsGallery.tsx b/packages/__docs__/src/Icons/LegacyIconsGallery.tsx
new file mode 100644
index 0000000000..e18f0c46d4
--- /dev/null
+++ b/packages/__docs__/src/Icons/LegacyIconsGallery.tsx
@@ -0,0 +1,376 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { useState, useRef, memo, useCallback } from 'react'
+
+import { InlineSVG } from '@instructure/ui-svg-images'
+import { Heading } from '@instructure/ui-heading'
+import { TextInput } from '@instructure/ui-text-input'
+import { SimpleSelect } from '@instructure/ui-simple-select'
+import { Checkbox } from '@instructure/ui-checkbox'
+import { FormFieldGroup } from '@instructure/ui-form-field'
+import { IconButton } from '@instructure/ui-buttons'
+import { Alert } from '@instructure/ui-alerts'
+import {
+  ScreenReaderContent,
+  AccessibleContent
+} from '@instructure/ui-a11y-content'
+import { Modal } from '@instructure/ui-modal'
+import { SourceCodeEditor } from '@instructure/ui-source-code-editor'
+import * as InstIcons from '@instructure/ui-icons'
+import { IconXSolid } from '@instructure/ui-icons'
+import { Link } from '@instructure/ui-link'
+import { Flex } from '@instructure/ui-flex'
+import { Glyph } from '../../buildScripts/DataTypes.mjs'
+
+type Format = 'react' | 'svg' | 'font'
+
+type IconTileProps = {
+  glyph: Glyph
+  format: Format
+  rtl: boolean
+  onClick: (glyph: Glyph, styleType: StyleType) => void
+}
+
+type LegacyIconsGalleryProps = {
+  glyphs: Glyph[]
+}
+
+type StyleType = 'line' | 'solid'
+
+function getUsageInfo(
+  selectedGlyph: { glyph: Glyph; styleType: StyleType },
+  format: Format
+) {
+  const {
+    glyph: { name, lineSrc, solidSrc, glyphName },
+    styleType
+  } = selectedGlyph
+  const styleTypeTitleCase = styleType === 'line' ? 'Line' : 'Solid'
+  if (format === 'react') {
+    const componentName = `${name}${styleTypeTitleCase}`
+    return `import { ${componentName} } from '@instructure/ui-icons'
+
+const MyIcon = () => {
+  return (
+    <${componentName} />
+  )
+}`
+  } else if (format === 'svg') {
+    return styleType === 'line' ? lineSrc : solidSrc
+  }
+
+  return `import '@instructure/ui-icons/es/icon-font/${styleTypeTitleCase}/InstructureIcons-${styleTypeTitleCase}.css'
+
+const MyIcon = () => {
+  return (
+    <i className="icon-${styleType} icon-${styleType}-${glyphName}" aria-hidden="true" />
+  )
+}`
+}
+
+// use react memo to improve performance
+const IconTile = memo(
+  ({ format, glyph, rtl, onClick }: IconTileProps) => {
+    const { name, glyphName, lineSrc, solidSrc } = glyph
+    const getIconNode = (styleType: StyleType) => {
+      if (format === 'react') {
+        const componentName = `${name}${
+          styleType === 'line' ? 'Line' : 'Solid'
+        }`
+        // @ts-ignore TS cant type import *
+        const IconComponent = InstIcons[componentName]
+        return <IconComponent />
+      } else if (format === 'svg') {
+        const src = styleType === 'line' ? lineSrc : solidSrc
+        return <InlineSVG src={src} />
+      }
+      return (
+        <span css={{ height: '1em' }}>
+          <i
+            className={`icon-${styleType} icon-${styleType}-${glyphName}`}
+            aria-hidden="true"
+          />
+        </span>
+      )
+    }
+
+    return (
+      <div
+        css={{
+          display: 'flex',
+          alignItems: 'center',
+          flexDirection: 'column',
+          minWidth: '16em',
+          flexBasis: '16em',
+          flexGrow: 1,
+          margin: '0.5rem'
+        }}
+      >
+        <div
+          css={{
+            width: '100%',
+            display: 'flex',
+            justifyContent: 'center',
+            backgroundImage:
+              'linear-gradient(45deg, rgb(238, 238, 238) 25%, transparent 25%, transparent 75%, rgb(238, 238, 238) 75%, rgb(238, 238, 238)), linear-gradient(45deg, rgb(238, 238, 238) 25%, transparent 25%, transparent 75%, rgb(238, 238, 238) 75%, rgb(238, 238, 238))',
+            backgroundPosition: '0px 0px, calc(0.5rem) calc(0.5rem)',
+            backgroundSize: `1rem 1rem`,
+            border: '0.0625rem solid rgb(238, 238, 238)',
+            borderRadius: '0.25rem',
+            marginBottom: '0.5rem'
+          }}
+        >
+          <div dir={rtl ? 'rtl' : undefined}>
+            <IconButton
+              withBackground={false}
+              withBorder={false}
+              screenReaderLabel={name}
+              size="large"
+              margin="xx-small 0 xx-small 0"
+              onClick={() => onClick(glyph, 'line')}
+            >
+              {getIconNode('line')}
+            </IconButton>
+            <IconButton
+              withBackground={false}
+              withBorder={false}
+              screenReaderLabel={name}
+              size="large"
+              margin="xx-small 0 xx-small 0"
+              onClick={() => onClick(glyph, 'solid')}
+            >
+              {getIconNode('solid')}
+            </IconButton>
+          </div>
+        </div>
+        <Heading level="h4" as="h3">
+          {glyphName.toLowerCase()}
+        </Heading>
+      </div>
+    )
+  },
+  (prevProps, nextProps) => {
+    // only re-render the component if these values change
+    return (
+      prevProps.format === nextProps.format &&
+      prevProps.glyph.glyphName === nextProps.glyph.glyphName &&
+      prevProps.rtl === nextProps.rtl
+    )
+  }
+)
+IconTile.displayName = 'IconTile'
+
+const LegacyIconsGallery = ({ glyphs }: LegacyIconsGalleryProps) => {
+  const [selectedFormat, setSelectedFormat] = useState<Format>('react')
+  const [searchQuery, setSearchQuery] = useState<string>('')
+  const [selectedGlyph, setSelectedGlyph] = useState<{
+    glyph: Glyph
+    styleType: StyleType
+  } | null>(null)
+  const [rtl, setRtl] = useState<boolean>(false)
+  const timeoutId = useRef<NodeJS.Timeout | null>(null)
+
+  // Memoize handlers to prevent unnecessary re-renders
+  const handleSearchChange = useCallback(
+    (_e: React.ChangeEvent, value: string) => {
+      // don't debounce when typing, it should be instant because of React.memo
+      if (value.startsWith(searchQuery)) {
+        setSearchQuery(value)
+        return
+      }
+
+      // clear already running timeout on search query change
+      if (timeoutId.current) {
+        clearTimeout(timeoutId.current)
+      }
+
+      // 500ms debounce so the UI doesn't lag when reloading all icons
+      timeoutId.current = setTimeout(() => {
+        setSearchQuery(value)
+      }, 500)
+    },
+    [searchQuery]
+  )
+
+  const handleBidirectionToggle = useCallback((e: React.ChangeEvent<any>) => {
+    // 0ms timeout so the UI doesn't freeze
+    setTimeout(() => {
+      setRtl(e.target.checked)
+    }, 0)
+  }, [])
+
+  const handleFormatChange = useCallback(
+    (_e: React.SyntheticEvent, { value }: { value?: string | number }) => {
+      // 0ms timeout so the UI doesn't freeze
+      setTimeout(() => {
+        setSelectedFormat(value as Format)
+      }, 0)
+    },
+    []
+  )
+
+  const handleIconClick = useCallback((glyph: Glyph, styleType: StyleType) => {
+    setSelectedGlyph({ glyph, styleType })
+  }, [])
+
+  const handleModalDismiss = useCallback(() => {
+    setSelectedGlyph(null)
+  }, [])
+
+  const formats = {
+    react: 'React',
+    svg: 'SVG',
+    font: 'Icon Font'
+  }
+  const allMatch = glyphs.filter((g) => {
+    if (!searchQuery) return true
+    return g.glyphName.toLowerCase().includes(searchQuery.toLowerCase())
+  })
+
+  return (
+    <div>
+      <Alert variant="warning" margin="0 0 medium 0">
+        <strong>Deprecated:</strong> These icons will be removed in v12. Please
+        migrate to Lucide icons using the codemod:
+        <br />
+        <code>npx @instructure/ui-codemods migrate-lucide-icons src/</code>
+      </Alert>
+
+      <FormFieldGroup
+        layout="columns"
+        colSpacing="small"
+        description={<ScreenReaderContent>Filter Icons</ScreenReaderContent>}
+      >
+        <TextInput
+          placeholder="Filter icons..."
+          onChange={handleSearchChange}
+          renderLabel={<ScreenReaderContent>Icon Name</ScreenReaderContent>}
+        />
+        <SimpleSelect
+          name="format"
+          renderLabel={<ScreenReaderContent>Icon Format</ScreenReaderContent>}
+          onChange={handleFormatChange}
+        >
+          {Object.keys(formats).map((f) => (
+            <SimpleSelect.Option value={f} id={f} key={f}>
+              {formats[f as keyof typeof formats]}
+            </SimpleSelect.Option>
+          ))}
+        </SimpleSelect>
+        <Checkbox
+          label={
+            <AccessibleContent alt="Render icons with right-to-left text direction">
+              RTL
+            </AccessibleContent>
+          }
+          variant="toggle"
+          size="small"
+          onChange={handleBidirectionToggle}
+        />
+      </FormFieldGroup>
+      {selectedFormat === 'font' && (
+        <Alert variant="warning" margin="small 0">
+          Icon Font is a deprecated format and only here for compatibility
+          reasons. It doesn&apos;t have right-to-left support and some icons
+          have visual artifacts due to svg-to-ttf conversion. We recommend using
+          the React format.
+        </Alert>
+      )}
+      {selectedFormat === 'svg' && (
+        <Alert variant="info" margin="small 0">
+          The SVG format doesn&apos;t have right-to-left support. If you need
+          that, please use the React format.
+        </Alert>
+      )}
+      <div
+        css={{
+          display: 'flex',
+          flexWrap: 'wrap',
+          margin: '0 auto',
+          paddingTop: '1rem'
+        }}
+      >
+        {allMatch.map((g) => (
+          <IconTile
+            glyph={g}
+            format={selectedFormat}
+            key={g.name}
+            rtl={rtl}
+            onClick={handleIconClick}
+          />
+        ))}
+      </div>
+      {selectedGlyph && (
+        <Modal
+          open
+          onDismiss={handleModalDismiss}
+          label={`Usage: ...`}
+          size="medium"
+          shouldCloseOnDocumentClick
+        >
+          <Modal.Header>
+            <Flex justifyItems="space-between">
+              <Flex.Item>
+                <Heading>
+                  {selectedGlyph.glyph.glyphName} ({selectedGlyph.styleType})
+                </Heading>
+              </Flex.Item>
+              <Flex.Item>
+                <IconButton
+                  onClick={handleModalDismiss}
+                  screenReaderLabel="Close"
+                  renderIcon={IconXSolid}
+                  withBorder={false}
+                  withBackground={false}
+                />
+              </Flex.Item>
+            </Flex>
+          </Modal.Header>
+          <Modal.Body>
+            <div>
+              <Heading level="h3" margin="small 0">
+                Usage
+              </Heading>
+              <SourceCodeEditor
+                label={`How to use`}
+                defaultValue={getUsageInfo(selectedGlyph, selectedFormat)}
+                language="javascript"
+                readOnly
+              />
+              {selectedFormat === 'react' && (
+                <p>
+                  See the <Link href="#SVGIcon">SVGIcon</Link> component for
+                  props and examples.
+                </p>
+              )}
+            </div>
+          </Modal.Body>
+        </Modal>
+      )}
+    </div>
+  )
+}
+
+export default LegacyIconsGallery
diff --git a/packages/__docs__/src/Icons/LucideIconsGallery.tsx b/packages/__docs__/src/Icons/LucideIconsGallery.tsx
new file mode 100644
index 0000000000..800e2e760f
--- /dev/null
+++ b/packages/__docs__/src/Icons/LucideIconsGallery.tsx
@@ -0,0 +1,287 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { useState, memo, useCallback } from 'react'
+
+import { Heading } from '@instructure/ui-heading'
+import { TextInput } from '@instructure/ui-text-input'
+import { Checkbox } from '@instructure/ui-checkbox'
+import { FormFieldGroup } from '@instructure/ui-form-field'
+import { IconButton } from '@instructure/ui-buttons'
+import {
+  ScreenReaderContent,
+  AccessibleContent
+} from '@instructure/ui-a11y-content'
+import { Modal } from '@instructure/ui-modal'
+import { SourceCodeEditor } from '@instructure/ui-source-code-editor'
+import * as LucideIcons from '@instructure/ui-icons-lucide'
+import { X } from '@instructure/ui-icons-lucide'
+import { Link } from '@instructure/ui-link'
+import { Flex } from '@instructure/ui-flex'
+
+// Get all exported Lucide icons (excluding utilities and types)
+const lucideIconNames = Object.keys(LucideIcons).filter(
+  (name) =>
+    name !== 'withRTL' &&
+    name !== 'wrapLucideIcon' &&
+    name !== 'LucideProps' &&
+    name !== 'LucideIcon' &&
+    name !== 'LucideIconWrapperProps' &&
+    name !== 'InstUIIconProps' &&
+    name !== 'LucideIconTheme' &&
+    name !== 'BIDIRECTIONAL_ICONS'
+)
+
+type LucideIconTileProps = {
+  name: string
+  rtl: boolean
+  onClick: (name: string) => void
+}
+
+function getUsageInfo(iconName: string) {
+  return `import { ${iconName} } from '@instructure/ui-icons-lucide'
+
+const MyIcon = () => {
+  return (
+    <${iconName} size={24} />
+  )
+}`
+}
+
+// use react memo to improve performance
+const LucideIconTile = memo(
+  ({ name, rtl, onClick }: LucideIconTileProps) => {
+    // @ts-ignore - dynamic import
+    const IconComponent = LucideIcons[name]
+
+    // Defensive check - if icon doesn't exist, don't render
+    if (!IconComponent) {
+      return null
+    }
+
+    return (
+      <div
+        css={{
+          display: 'flex',
+          alignItems: 'center',
+          flexDirection: 'column',
+          minWidth: '16em',
+          flexBasis: '16em',
+          flexGrow: 1,
+          margin: '0.5rem'
+        }}
+      >
+        <div
+          css={{
+            width: '100%',
+            display: 'flex',
+            justifyContent: 'center',
+            backgroundImage:
+              'linear-gradient(45deg, rgb(238, 238, 238) 25%, transparent 25%, transparent 75%, rgb(238, 238, 238) 75%, rgb(238, 238, 238)), linear-gradient(45deg, rgb(238, 238, 238) 25%, transparent 25%, transparent 75%, rgb(238, 238, 238) 75%, rgb(238, 238, 238))',
+            backgroundPosition: '0px 0px, calc(0.5rem) calc(0.5rem)',
+            backgroundSize: `1rem 1rem`,
+            border: '0.0625rem solid rgb(238, 238, 238)',
+            borderRadius: '0.25rem',
+            marginBottom: '0.5rem'
+          }}
+        >
+          <div dir={rtl ? 'rtl' : undefined}>
+            <button
+              onClick={() => onClick(name)}
+              style={{
+                background: 'none',
+                border: 'none',
+                cursor: 'pointer',
+                padding: '1rem',
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center'
+              }}
+              aria-label={name}
+            >
+              <IconComponent size={32} />
+            </button>
+          </div>
+        </div>
+        <Heading level="h4" as="h3">
+          {name}
+        </Heading>
+      </div>
+    )
+  },
+  (prevProps, nextProps) => {
+    // only re-render the component if these values change
+    return prevProps.name === nextProps.name && prevProps.rtl === nextProps.rtl
+  }
+)
+LucideIconTile.displayName = 'LucideIconTile'
+
+const LucideIconsGallery = () => {
+  const [searchQuery, setSearchQuery] = useState<string>('')
+  const [selectedIcon, setSelectedIcon] = useState<string | null>(null)
+  const [rtl, setRtl] = useState<boolean>(false)
+
+  // Memoize handlers to prevent unnecessary re-renders
+  const handleSearchChange = useCallback(
+    (_e: React.ChangeEvent, value: string) => {
+      setSearchQuery(value)
+    },
+    []
+  )
+
+  const handleBidirectionToggle = useCallback((e: React.ChangeEvent<any>) => {
+    setRtl(e.target.checked)
+  }, [])
+
+  const handleIconClick = useCallback((name: string) => {
+    setSelectedIcon(name)
+  }, [])
+
+  const handleModalDismiss = useCallback(() => {
+    setSelectedIcon(null)
+  }, [])
+
+  const filteredIcons = lucideIconNames.filter((name) => {
+    if (!searchQuery) return true
+    return name.toLowerCase().includes(searchQuery.toLowerCase())
+  })
+
+  return (
+    <div>
+      {/*<Alert variant="info" margin="0 0 medium 0">*/}
+      {/*  <strong>New:</strong> Lucide icons with pure API! These icons use the*/}
+      {/*  native Lucide API with RTL support where needed.{' '}*/}
+      {/*  <Link href="https://lucide.dev/icons" target="_blank">*/}
+      {/*    Browse all 1,500+ icons →*/}
+      {/*  </Link>*/}
+      {/*</Alert>*/}
+
+      <FormFieldGroup
+        layout="columns"
+        colSpacing="small"
+        description={<ScreenReaderContent>Filter Icons</ScreenReaderContent>}
+      >
+        <TextInput
+          placeholder="Filter icons..."
+          value={searchQuery}
+          onChange={handleSearchChange}
+          renderLabel={<ScreenReaderContent>Icon Name</ScreenReaderContent>}
+        />
+        <Checkbox
+          label={
+            <AccessibleContent alt="Render icons with right-to-left text direction">
+              RTL
+            </AccessibleContent>
+          }
+          variant="toggle"
+          size="small"
+          onChange={handleBidirectionToggle}
+        />
+      </FormFieldGroup>
+
+      <div
+        css={{
+          display: 'flex',
+          flexWrap: 'wrap',
+          margin: '0 auto',
+          paddingTop: '1rem'
+        }}
+      >
+        {filteredIcons.map((name) => (
+          <LucideIconTile
+            name={name}
+            key={name}
+            rtl={rtl}
+            onClick={handleIconClick}
+          />
+        ))}
+      </div>
+
+      {selectedIcon && (
+        <Modal
+          open
+          onDismiss={handleModalDismiss}
+          label={`Usage: ${selectedIcon}`}
+          size="medium"
+          shouldCloseOnDocumentClick
+        >
+          <Modal.Header>
+            <Flex justifyItems="space-between">
+              <Flex.Item>
+                <Heading>{selectedIcon}</Heading>
+              </Flex.Item>
+              <Flex.Item>
+                <IconButton
+                  onClick={handleModalDismiss}
+                  screenReaderLabel="Close"
+                  renderIcon={() => <X />}
+                  withBorder={false}
+                  withBackground={false}
+                />
+              </Flex.Item>
+            </Flex>
+          </Modal.Header>
+          <Modal.Body>
+            <div>
+              <Heading level="h3" margin="small 0">
+                Usage
+              </Heading>
+              <SourceCodeEditor
+                label={`How to use ${selectedIcon}`}
+                defaultValue={getUsageInfo(selectedIcon)}
+                language="javascript"
+                readOnly
+              />
+              <Heading level="h4" margin="medium 0 small 0">
+                Available Props
+              </Heading>
+              <ul>
+                <li>
+                  <code>size</code>: Number (pixels) - e.g., <code>24</code>
+                </li>
+                <li>
+                  <code>color</code>: CSS color - e.g.,{' '}
+                  <code>&quot;currentColor&quot;</code>
+                </li>
+                <li>
+                  <code>strokeWidth</code>: Number - e.g., <code>2</code>
+                </li>
+                <li>Plus all standard SVG props (className, style, etc.)</li>
+              </ul>
+              <p>
+                These icons use the pure Lucide API. See{' '}
+                <Link href="https://lucide.dev/guide/" target="_blank">
+                  Lucide documentation
+                </Link>{' '}
+                for more details.
+              </p>
+            </div>
+          </Modal.Body>
+        </Modal>
+      )}
+    </div>
+  )
+}
+
+export default LucideIconsGallery
diff --git a/packages/__docs__/src/Icons/index.tsx b/packages/__docs__/src/Icons/index.tsx
index 4cfa256687..efa956a592 100644
--- a/packages/__docs__/src/Icons/index.tsx
+++ b/packages/__docs__/src/Icons/index.tsx
@@ -22,334 +22,71 @@
  * SOFTWARE.
  */
 
-import { useState, useRef, memo } from 'react'
+import { useState, lazy, Suspense } from 'react'
 
-import { InlineSVG } from '@instructure/ui-svg-images'
-import { Heading } from '@instructure/ui-heading'
-import { TextInput } from '@instructure/ui-text-input'
-import { SimpleSelect } from '@instructure/ui-simple-select'
-import { Checkbox } from '@instructure/ui-checkbox'
-import { FormFieldGroup } from '@instructure/ui-form-field'
-import { IconButton } from '@instructure/ui-buttons'
-import { Alert } from '@instructure/ui-alerts'
-import {
-  ScreenReaderContent,
-  AccessibleContent
-} from '@instructure/ui-a11y-content'
-import { Modal } from '@instructure/ui-modal'
-import { SourceCodeEditor } from '@instructure/ui-source-code-editor'
-import * as InstIcons from '@instructure/ui-icons'
-import { IconXSolid } from '@instructure/ui-icons'
-import { Link } from '@instructure/ui-link'
-import { Flex } from '@instructure/ui-flex'
+import { Tabs } from '@instructure/ui-tabs'
+import { Spinner } from '@instructure/ui-spinner'
 import { Glyph } from '../../buildScripts/DataTypes.mjs'
 
-type Format = 'react' | 'svg' | 'font'
-
-type IconTileProps = {
-  glyph: Glyph
-  format: Format
-  rtl: boolean
-  onClick: (styleType: StyleType) => void
-}
+// Lazy load gallery components for better initial load performance
+const LucideIconsGallery = lazy(() => import('./LucideIconsGallery'))
+const LegacyIconsGallery = lazy(() => import('./LegacyIconsGallery'))
 
 type IconsPageProps = {
   glyphs: Glyph[]
 }
 
-type StyleType = 'line' | 'solid'
-
-function getUsageInfo(
-  selectedGlyph: { glyph: Glyph; styleType: StyleType },
-  format: Format
-) {
-  const {
-    glyph: { name, lineSrc, solidSrc, glyphName },
-    styleType
-  } = selectedGlyph
-  const styleTypeTitleCase = styleType === 'line' ? 'Line' : 'Solid'
-  if (format === 'react') {
-    const componentName = `${name}${styleTypeTitleCase}`
-    return `import { ${componentName} } from '@instructure/ui-icons'
+const IconsPage = ({ glyphs }: IconsPageProps) => {
+  const [selectedTabIndex, setSelectedTabIndex] = useState<number>(0)
 
-const MyIcon = () => {
-  return (
-    <${componentName} />
-  )
-}`
-  } else if (format === 'svg') {
-    return styleType === 'line' ? lineSrc : solidSrc
+  const handleTabChange = (_event: any, { index }: { index: number }) => {
+    setSelectedTabIndex(index)
   }
 
-  return `import '@instructure/ui-icons/es/icon-font/${styleTypeTitleCase}/InstructureIcons-${styleTypeTitleCase}.css'
-
-const MyIcon = () => {
   return (
-    <i className="icon-${styleType} icon-${styleType}-${glyphName}" aria-hidden="true" />
-  )
-}`
-}
-
-// use react memo to improve performance
-const IconTile = memo(
-  ({ format, glyph, rtl, onClick }: IconTileProps) => {
-    const { name, glyphName, lineSrc, solidSrc } = glyph
-    const getIconNode = (styleType: StyleType) => {
-      if (format === 'react') {
-        const componentName = `${name}${
-          styleType === 'line' ? 'Line' : 'Solid'
-        }`
-        // @ts-ignore TS cant type import *
-        const IconComponent = InstIcons[componentName]
-        return <IconComponent />
-      } else if (format === 'svg') {
-        const src = styleType === 'line' ? lineSrc : solidSrc
-        return <InlineSVG src={src} />
-      }
-      return (
-        <span css={{ height: '1em' }}>
-          <i
-            className={`icon-${styleType} icon-${styleType}-${glyphName}`}
-            aria-hidden="true"
-          />
-        </span>
-      )
-    }
-
-    return (
-      <div
-        css={{
-          display: 'flex',
-          alignItems: 'center',
-          flexDirection: 'column',
-          minWidth: '16em',
-          flexBasis: '16em',
-          flexGrow: 1,
-          margin: '0.5rem'
-        }}
-      >
-        <div
-          css={{
-            width: '100%',
-            display: 'flex',
-            justifyContent: 'center',
-            backgroundImage:
-              'linear-gradient(45deg, rgb(238, 238, 238) 25%, transparent 25%, transparent 75%, rgb(238, 238, 238) 75%, rgb(238, 238, 238)), linear-gradient(45deg, rgb(238, 238, 238) 25%, transparent 25%, transparent 75%, rgb(238, 238, 238) 75%, rgb(238, 238, 238))',
-            backgroundPosition: '0px 0px, calc(0.5rem) calc(0.5rem)',
-            backgroundSize: `1rem 1rem`,
-            border: '0.0625rem solid rgb(238, 238, 238)',
-            borderRadius: '0.25rem',
-            marginBottom: '0.5rem'
-          }}
+    <div>
+      {/*<Alert variant="info" margin="0 0 medium 0">*/}
+      {/*  <strong>New:</strong> InstUI now uses Lucide icons! The Lucide icon*/}
+      {/*  library provides 1,500+ tree-shakable icons with a modern API.{' '}*/}
+      {/*  <Link href="https://lucide.dev/icons" target="_blank" rel="noopener">*/}
+      {/*    Browse all Lucide icons →*/}
+      {/*  </Link>*/}
+      {/*</Alert>*/}
+
+      <Tabs onRequestTabChange={handleTabChange}>
+        <Tabs.Panel
+          renderTitle="Lucide Icons (New)"
+          isSelected={selectedTabIndex === 0}
+          padding="medium 0"
         >
-          <div dir={rtl ? 'rtl' : undefined}>
-            <IconButton
-              withBackground={false}
-              withBorder={false}
-              screenReaderLabel={name}
-              size="large"
-              margin="xx-small 0 xx-small 0"
-              onClick={() => onClick('line')}
+          {/* Keep both galleries mounted but hide inactive one with CSS for instant switching */}
+          <div style={{ display: selectedTabIndex === 0 ? 'block' : 'none' }}>
+            <Suspense
+              fallback={
+                <Spinner renderTitle="Loading Lucide icons..." size="large" />
+              }
             >
-              {getIconNode('line')}
-            </IconButton>
-            <IconButton
-              withBackground={false}
-              withBorder={false}
-              screenReaderLabel={name}
-              size="large"
-              margin="xx-small 0 xx-small 0"
-              onClick={() => onClick('solid')}
-            >
-              {getIconNode('solid')}
-            </IconButton>
+              <LucideIconsGallery />
+            </Suspense>
           </div>
-        </div>
-        <Heading level="h4" as="h3">
-          {glyphName.toLowerCase()}
-        </Heading>
-      </div>
-    )
-  },
-  (prevProps, nextProps) => {
-    // only re-render the component if these values change
-    return (
-      prevProps.format === nextProps.format &&
-      prevProps.glyph.glyphName === nextProps.glyph.glyphName &&
-      prevProps.rtl === nextProps.rtl
-    )
-  }
-)
-IconTile.displayName = 'IconTile'
-
-const IconsPage = ({ glyphs }: IconsPageProps) => {
-  const [selectedFormat, setSelectedFormat] = useState<Format>('react')
-  const [searchQuery, setSearchQuery] = useState<string>('')
-  const [selectedGlyph, setSelectedGlyph] = useState<{
-    glyph: Glyph
-    styleType: StyleType
-  } | null>(null)
-  const [rtl, setRtl] = useState<boolean>(false)
-  const timeoutId = useRef<NodeJS.Timeout | null>(null)
+        </Tabs.Panel>
 
-  const handleSearchChange = (_e: React.ChangeEvent, value: string) => {
-    // don't debounce when typing, it should be instant because of React.memo
-    if (value.startsWith(searchQuery)) {
-      setSearchQuery(value)
-      return
-    }
-
-    // clear already running timeout on search query change
-    if (timeoutId.current) {
-      clearTimeout(timeoutId.current)
-    }
-
-    // 500ms debounce so the UI doesn't lag when reloading all icons
-    timeoutId.current = setTimeout(() => {
-      setSearchQuery(value)
-    }, 500)
-  }
-
-  const handleBidirectionToggle = (e: React.ChangeEvent<any>) => {
-    // 0ms timeout so the UI doesn't freeze
-    setTimeout(() => {
-      setRtl(e.target.checked)
-    }, 0)
-  }
-
-  const handleFormatChange = (
-    _e: React.SyntheticEvent,
-    { value }: { value?: string | number }
-  ) => {
-    // 0ms timeout so the UI doesn't freeze
-    setTimeout(() => {
-      setSelectedFormat(value as Format)
-    }, 0)
-  }
-
-  const formats = {
-    react: 'React',
-    svg: 'SVG',
-    font: 'Icon Font'
-  }
-  const allMatch = glyphs.filter((g) => {
-    if (!searchQuery) return true
-    return g.glyphName.toLowerCase().includes(searchQuery.toLowerCase())
-  })
-
-  return (
-    <div>
-      <FormFieldGroup
-        layout="columns"
-        colSpacing="small"
-        description={<ScreenReaderContent>Filter Icons</ScreenReaderContent>}
-      >
-        <TextInput
-          placeholder="Filter icons..."
-          onChange={handleSearchChange}
-          renderLabel={<ScreenReaderContent>Icon Name</ScreenReaderContent>}
-        />
-        <SimpleSelect
-          name="format"
-          renderLabel={<ScreenReaderContent>Icon Format</ScreenReaderContent>}
-          onChange={handleFormatChange}
+        <Tabs.Panel
+          renderTitle="Legacy Icons (Deprecated)"
+          isSelected={selectedTabIndex === 1}
+          padding="medium 0"
         >
-          {Object.keys(formats).map((f) => (
-            <SimpleSelect.Option value={f} id={f} key={f}>
-              {formats[f as keyof typeof formats]}
-            </SimpleSelect.Option>
-          ))}
-        </SimpleSelect>
-        <Checkbox
-          label={
-            <AccessibleContent alt="Render icons with right-to-left text direction">
-              RTL
-            </AccessibleContent>
-          }
-          variant="toggle"
-          size="small"
-          onChange={handleBidirectionToggle}
-        />
-      </FormFieldGroup>
-      {selectedFormat === 'font' && (
-        <Alert variant="warning" margin="small 0">
-          Icon Font is a deprecated format and only here for compatibility
-          reasons. It doesn&apos;t have right-to-left support and some icons
-          have visual artifacts due to svg-to-ttf conversion. We recommend using
-          the React format.
-        </Alert>
-      )}
-      {selectedFormat === 'svg' && (
-        <Alert variant="info" margin="small 0">
-          The SVG format doesn&apos;t have right-to-left support. If you need
-          that, please use the React format.
-        </Alert>
-      )}
-      <div
-        css={{
-          display: 'flex',
-          flexWrap: 'wrap',
-          margin: '0 auto',
-          paddingTop: '1rem'
-        }}
-      >
-        {allMatch.map((g) => (
-          <IconTile
-            glyph={g}
-            format={selectedFormat}
-            key={g.name}
-            rtl={rtl}
-            onClick={(styleType) => setSelectedGlyph({ glyph: g, styleType })}
-          />
-        ))}
-      </div>
-      {selectedGlyph && (
-        <Modal
-          open
-          onDismiss={() => setSelectedGlyph(null)}
-          label={`Usage: ...`}
-          size="medium"
-          shouldCloseOnDocumentClick
-        >
-          <Modal.Header>
-            <Flex justifyItems="space-between">
-              <Flex.Item>
-                <Heading>
-                  {selectedGlyph.glyph.glyphName} ({selectedGlyph.styleType})
-                </Heading>
-              </Flex.Item>
-              <Flex.Item>
-                <IconButton
-                  onClick={() => setSelectedGlyph(null)}
-                  screenReaderLabel="Close"
-                  renderIcon={IconXSolid}
-                  withBorder={false}
-                  withBackground={false}
-                />
-              </Flex.Item>
-            </Flex>
-          </Modal.Header>
-          <Modal.Body>
-            <div>
-              <Heading level="h3" margin="small 0">
-                Usage
-              </Heading>
-              <SourceCodeEditor
-                label={`How to use`}
-                defaultValue={getUsageInfo(selectedGlyph, selectedFormat)}
-                language="javascript"
-                readOnly
-              />
-              {selectedFormat === 'react' && (
-                <p>
-                  See the <Link href="#SVGIcon">SVGIcon</Link> component for
-                  props and examples.
-                </p>
-              )}
-            </div>
-          </Modal.Body>
-        </Modal>
-      )}
+          <div style={{ display: selectedTabIndex === 1 ? 'block' : 'none' }}>
+            <Suspense
+              fallback={
+                <Spinner renderTitle="Loading legacy icons..." size="large" />
+              }
+            >
+              <LegacyIconsGallery glyphs={glyphs} />
+            </Suspense>
+          </div>
+        </Tabs.Panel>
+      </Tabs>
     </div>
   )
 }
diff --git a/packages/__docs__/tsconfig.build.json b/packages/__docs__/tsconfig.build.json
index 2550b80f50..99b82d4d33 100644
--- a/packages/__docs__/tsconfig.build.json
+++ b/packages/__docs__/tsconfig.build.json
@@ -121,6 +121,9 @@
     {
       "path": "../ui-icons/tsconfig.build.json"
     },
+    {
+      "path": "../ui-icons-lucide/tsconfig.build.json"
+    },
     {
       "path": "../ui-img/tsconfig.build.json"
     },
diff --git a/packages/ui-icons-lucide/.gitignore b/packages/ui-icons-lucide/.gitignore
new file mode 100644
index 0000000000..f6517645bf
--- /dev/null
+++ b/packages/ui-icons-lucide/.gitignore
@@ -0,0 +1,5 @@
+lib/
+.babel-cache/
+es/
+__build__/
+types/
diff --git a/packages/ui-icons-lucide/README.md b/packages/ui-icons-lucide/README.md
new file mode 100644
index 0000000000..c3c034aba6
--- /dev/null
+++ b/packages/ui-icons-lucide/README.md
@@ -0,0 +1,122 @@
+# @instructure/ui-icons-lucide
+
+Lucide icons for Instructure UI with RTL (Right-to-Left) support.
+
+## Installation
+
+```bash
+npm install @instructure/ui-icons-lucide lucide-react
+```
+
+or with pnpm:
+
+```bash
+pnpm add @instructure/ui-icons-lucide lucide-react
+```
+
+## Usage
+
+### Basic Usage (Lucide API)
+
+```tsx
+import { Plus, Check, ArrowLeft } from '@instructure/ui-icons-lucide'
+
+function MyComponent() {
+  return (
+    <div>
+      <Plus size={24} />
+      <Check size={24} color="green" />
+      <ArrowLeft size={24} /> {/* Automatically flips in RTL */}
+    </div>
+  )
+}
+```
+
+### InstUI Semantic Props
+
+```tsx
+import { Plus, Check, ArrowLeft } from '@instructure/ui-icons-lucide'
+
+function MyComponent() {
+  return (
+    <div>
+      {/* Semantic sizing */}
+      <Plus size="small" />
+      <Check size="medium" color="success" />
+
+      {/* Rotation and RTL control */}
+      <ArrowLeft size="large" rotate="90" />
+      <ArrowLeft size="large" bidirectional={false} />
+
+      {/* Accessibility */}
+      <Check
+        size="medium"
+        title="Completed"
+        description="This task has been completed"
+      />
+    </div>
+  )
+}
+```
+
+## Features
+
+- **Pure Lucide API**: Direct access to Lucide's native API
+- **RTL Support**: Bidirectional icons automatically flip in RTL contexts
+- **Tree-shakable**: Only bundle the icons you use
+- **TypeScript**: Full type support
+- **1,500+ Icons**: Access to the full Lucide icon library
+
+## Migrating from @instructure/ui-icons
+
+Run the automated codemod:
+
+```bash
+npx @instructure/ui-codemods migrate-lucide-icons src/
+```
+
+See the [migration guide](https://instructure.design/guides/migrating-to-lucide-icons) for more details.
+
+## API
+
+### InstUI-Specific Props
+
+All icons are wrapped with InstUI theming support and accept semantic props:
+
+- `size`: Semantic string (`'x-small'`, `'small'`, `'medium'`, `'large'`, `'x-large'`) OR number (pixels)
+  - `'x-small'` → 18px
+  - `'small'` → 32px
+  - `'medium'` → 48px
+  - `'large'` → 80px
+  - `'x-large'` → 160px
+- `color`: Semantic color (`'primary'`, `'secondary'`, `'success'`, `'error'`, etc.) OR CSS color
+- `rotate`: Rotation in degrees (`'0'`, `'90'`, `'180'`, `'270'`)
+- `bidirectional`: Boolean (default: `true`) - Enable/disable RTL flipping
+- `inline`: Boolean (default: `true`) - Display mode (inline-block vs block)
+- `title`: String - Accessible title for the icon
+- `description`: String - Additional accessible description
+
+### Lucide Native Props
+
+Plus all standard Lucide props:
+
+- `size`: Number (pixels) - e.g., `24`
+- `color`: CSS color value - e.g., `"#FF0000"` or `"currentColor"`
+- `strokeWidth`: Number - e.g., `2`
+- Plus all standard SVG props (className, style, onClick, etc.)
+
+**Note:** Lucide icons do not inherit `fontSize` from parent elements. When using semantic sizes, the wrapper automatically converts them to explicit pixel values that Lucide understands.
+
+## RTL Support
+
+Icons that need RTL support (arrows, directional icons) automatically handle flipping based on `document.dir`:
+
+```tsx
+// In LTR: points left
+// In RTL: points right (flipped)
+<ArrowLeft size={24} />
+```
+
+## License
+
+MIT
diff --git a/packages/ui-icons-lucide/babel.config.js b/packages/ui-icons-lucide/babel.config.js
new file mode 100644
index 0000000000..17fe90eb38
--- /dev/null
+++ b/packages/ui-icons-lucide/babel.config.js
@@ -0,0 +1,28 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+module.exports = function (api) {
+  api.cache(true)
+  return require('@instructure/ui-babel-preset')(api)
+}
diff --git a/packages/ui-icons-lucide/package.json b/packages/ui-icons-lucide/package.json
new file mode 100644
index 0000000000..88733e5065
--- /dev/null
+++ b/packages/ui-icons-lucide/package.json
@@ -0,0 +1,45 @@
+{
+  "name": "@instructure/ui-icons-lucide",
+  "version": "11.3.0",
+  "description": "Lucide icons for Instructure UI with RTL support",
+  "author": "Instructure, Inc. Engineering and Product Design",
+  "module": "./es/index.js",
+  "main": "./lib/index.js",
+  "types": "./types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/instructure/instructure-ui.git"
+  },
+  "homepage": "https://instructure.github.io/instructure-ui/",
+  "bugs": "https://github.com/instructure/instructure-ui/issues",
+  "scripts": {
+    "generate": "ts-node --project tsconfig.scripts.json scripts/generateIndex.ts",
+    "lint": "ui-scripts lint",
+    "build": "ui-scripts build --modules es,cjs",
+    "build:types": "tsc -p tsconfig.build.json",
+    "ts:check": "tsc -p tsconfig.build.json --noEmit --emitDeclarationOnly false",
+    "test:vitest": "vitest --watch=false"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@babel/runtime": "^7.27.6",
+    "@instructure/emotion": "workspace:*",
+    "@instructure/shared-types": "workspace:*",
+    "@instructure/ui-react-utils": "workspace:*",
+    "@instructure/ui-themes": "workspace:*",
+    "@instructure/ui-utils": "workspace:*",
+    "lucide-react": "^0.460.0"
+  },
+  "devDependencies": {
+    "@instructure/ui-babel-preset": "workspace:*",
+    "@types/node": "^22.5.4",
+    "ts-node": "^10.9.2"
+  },
+  "peerDependencies": {
+    "react": ">=18 <=19"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}
diff --git a/packages/ui-icons-lucide/scripts/generateIndex.ts b/packages/ui-icons-lucide/scripts/generateIndex.ts
new file mode 100644
index 0000000000..e7ab011870
--- /dev/null
+++ b/packages/ui-icons-lucide/scripts/generateIndex.ts
@@ -0,0 +1,211 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+
+interface IconMapping {
+  instUI: {
+    line: string
+    solid: string
+  }
+  lucide: {
+    name: string
+  }
+  bidirectional: boolean
+  notes?: string
+}
+
+interface MappingData {
+  version: string
+  lastUpdated: string
+  mappings: IconMapping[]
+  unmapped?: Array<{
+    instUI: {
+      line: string
+      solid: string
+    }
+    reason: string
+  }>
+}
+
+const HEADER = `/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * @packageDocumentation
+ * Lucide icons for Instructure UI with RTL support.
+ *
+ * This package provides access to all 1,500+ Lucide icons with automatic
+ * RTL (right-to-left) support for bidirectional icons.
+ *
+ * ## Usage
+ *
+ * \`\`\`tsx
+ * import { ArrowLeft, Plus, Check } from '@instructure/ui-icons-lucide'
+ *
+ * const MyComponent = () => (
+ *   <div>
+ *     <ArrowLeft size={24} />
+ *     <Plus size={24} />
+ *   </div>
+ * )
+ * \`\`\`
+ *
+ * ## RTL Support
+ *
+ * Bidirectional icons (arrows, chevrons, etc.) automatically flip horizontally
+ * in RTL contexts. Non-directional icons render normally in all contexts.
+ *
+ * ## API
+ *
+ * All icons accept the standard Lucide props:
+ * - \`size\`: number - Icon size in pixels
+ * - \`color\`: string - Icon color (defaults to currentColor)
+ * - \`strokeWidth\`: number - Stroke width
+ * - Plus all standard SVG attributes
+ *
+ * See https://lucide.dev for complete icon list and documentation.
+ */
+`
+
+function generateIndex() {
+  // Read mapping.json
+  const mappingPath = path.join(__dirname, '../src/mapping.json')
+  const mappingData: MappingData = JSON.parse(
+    fs.readFileSync(mappingPath, 'utf-8')
+  )
+
+  // Get all Lucide icon names by importing the package
+  const lucideReact = require('lucide-react')
+  const allLucideIcons = Object.keys(lucideReact).filter((key) => {
+    const value = lucideReact[key]
+    // Filter for actual icon components (they're objects with displayName)
+    // Exclude:
+    // - *Icon suffix duplicates (e.g., "AArrowDownIcon")
+    // - Lucide* prefix duplicates (e.g., "LucideAArrowDown")
+    // - createLucideIcon utility
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      value.displayName &&
+      !key.endsWith('Icon') &&
+      !key.startsWith('Lucide') &&
+      !key.startsWith('create')
+    )
+  })
+
+  // JavaScript built-ins that need to be renamed to avoid conflicts
+  const CONFLICTING_NAMES = ['Infinity', 'Map']
+
+  // Generate export statements for all icons (all bidirectional by default)
+  const iconExports = allLucideIcons
+    .map((iconName) => {
+      // Rename icons that conflict with JavaScript built-ins
+      if (CONFLICTING_NAMES.includes(iconName)) {
+        return `// Renamed from '${iconName}' to avoid conflict with JavaScript built-in\nexport const Icon${iconName} = wrapLucideIcon(Lucide.${iconName})`
+      }
+      return `export const ${iconName} = wrapLucideIcon(Lucide.${iconName})`
+    })
+    .join('\n')
+
+  // Generate index.ts content
+  const content = `${HEADER}
+import * as Lucide from 'lucide-react'
+import { wrapLucideIcon } from './wrapLucideIcon'
+
+// Re-export types
+export type { LucideProps, LucideIcon } from 'lucide-react'
+export type {
+  LucideIconWrapperProps,
+  InstUIIconProps,
+  LucideIconTheme
+} from './wrapLucideIcon'
+
+// Re-export utilities
+export { wrapLucideIcon }
+
+/**
+ * All Lucide icons wrapped with InstUI theming and RTL support
+ *
+ * All icons are wrapped with wrapLucideIcon and are bidirectional by default.
+ * Icons automatically flip horizontally in RTL contexts.
+ *
+ * To disable RTL flipping for a specific instance:
+ * \\\`\\\`\\\`tsx
+ * <IconName bidirectional={false} />
+ * \\\`\\\`\\\`
+ *
+ * InstUI-style usage:
+ * \\\`\\\`\\\`tsx
+ * <IconName size="large" color="primary" rotate="90" />
+ * \\\`\\\`\\\`
+ *
+ * Lucide-style usage (still supported):
+ * \\\`\\\`\\\`tsx
+ * <IconName size={24} strokeWidth={2} color="#ff0000" />
+ * \\\`\\\`\\\`
+ *
+ * Based on mapping.json version ${mappingData.version} (updated ${mappingData.lastUpdated})
+ * Total icons: ${allLucideIcons.length}
+ */
+
+${iconExports}
+`
+
+  const outputPath = path.join(__dirname, '../src/index.ts')
+  fs.writeFileSync(outputPath, content, 'utf-8')
+
+  console.error(`✓ Generated index.ts`)
+  console.error(`✓ Total Lucide icons: ${allLucideIcons.length}`)
+  console.error(
+    `✓ All icons are bidirectional by default (can be disabled per-instance)`
+  )
+  console.error(
+    `✓ Total mapped icons from InstUI: ${mappingData.mappings.length}`
+  )
+}
+
+generateIndex()
diff --git a/packages/ui-icons-lucide/src/index.ts b/packages/ui-icons-lucide/src/index.ts
new file mode 100644
index 0000000000..67be5d9b93
--- /dev/null
+++ b/packages/ui-icons-lucide/src/index.ts
@@ -0,0 +1,1938 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * @packageDocumentation
+ * Lucide icons for Instructure UI with RTL support.
+ *
+ * This package provides access to all 1,500+ Lucide icons with automatic
+ * RTL (right-to-left) support for bidirectional icons.
+ *
+ * ## Usage
+ *
+ * ```tsx
+ * import { ArrowLeft, Plus, Check } from '@instructure/ui-icons-lucide'
+ *
+ * const MyComponent = () => (
+ *   <div>
+ *     <ArrowLeft size={24} />
+ *     <Plus size={24} />
+ *   </div>
+ * )
+ * ```
+ *
+ * ## RTL Support
+ *
+ * Bidirectional icons (arrows, chevrons, etc.) automatically flip horizontally
+ * in RTL contexts. Non-directional icons render normally in all contexts.
+ *
+ * ## API
+ *
+ * All icons accept the standard Lucide props:
+ * - `size`: number - Icon size in pixels
+ * - `color`: string - Icon color (defaults to currentColor)
+ * - `strokeWidth`: number - Stroke width
+ * - Plus all standard SVG attributes
+ *
+ * See https://lucide.dev for complete icon list and documentation.
+ */
+
+import * as Lucide from 'lucide-react'
+import { wrapLucideIcon } from './wrapLucideIcon'
+
+// Re-export types
+export type { LucideProps, LucideIcon } from 'lucide-react'
+export type {
+  LucideIconWrapperProps,
+  InstUIIconProps,
+  LucideIconTheme
+} from './wrapLucideIcon'
+
+// Re-export utilities
+export { wrapLucideIcon }
+
+/**
+ * All Lucide icons wrapped with InstUI theming and RTL support
+ *
+ * All icons are wrapped with wrapLucideIcon and are bidirectional by default.
+ * Icons automatically flip horizontally in RTL contexts.
+ *
+ * To disable RTL flipping for a specific instance:
+ * \`\`\`tsx
+ * <IconName bidirectional={false} />
+ * \`\`\`
+ *
+ * InstUI-style usage:
+ * \`\`\`tsx
+ * <IconName size="large" color="primary" rotate="90" />
+ * \`\`\`
+ *
+ * Lucide-style usage (still supported):
+ * \`\`\`tsx
+ * <IconName size={24} strokeWidth={2} color="#ff0000" />
+ * \`\`\`
+ *
+ * Based on mapping.json version 1.0 (updated 2025-11-07)
+ * Total icons: 1737
+ */
+
+export const AArrowDown = wrapLucideIcon(Lucide.AArrowDown)
+export const AArrowUp = wrapLucideIcon(Lucide.AArrowUp)
+export const ALargeSmall = wrapLucideIcon(Lucide.ALargeSmall)
+export const Accessibility = wrapLucideIcon(Lucide.Accessibility)
+export const Activity = wrapLucideIcon(Lucide.Activity)
+export const ActivitySquare = wrapLucideIcon(Lucide.ActivitySquare)
+export const AirVent = wrapLucideIcon(Lucide.AirVent)
+export const Airplay = wrapLucideIcon(Lucide.Airplay)
+export const AlarmCheck = wrapLucideIcon(Lucide.AlarmCheck)
+export const AlarmClock = wrapLucideIcon(Lucide.AlarmClock)
+export const AlarmClockCheck = wrapLucideIcon(Lucide.AlarmClockCheck)
+export const AlarmClockMinus = wrapLucideIcon(Lucide.AlarmClockMinus)
+export const AlarmClockOff = wrapLucideIcon(Lucide.AlarmClockOff)
+export const AlarmClockPlus = wrapLucideIcon(Lucide.AlarmClockPlus)
+export const AlarmMinus = wrapLucideIcon(Lucide.AlarmMinus)
+export const AlarmPlus = wrapLucideIcon(Lucide.AlarmPlus)
+export const AlarmSmoke = wrapLucideIcon(Lucide.AlarmSmoke)
+export const Album = wrapLucideIcon(Lucide.Album)
+export const AlertCircle = wrapLucideIcon(Lucide.AlertCircle)
+export const AlertOctagon = wrapLucideIcon(Lucide.AlertOctagon)
+export const AlertTriangle = wrapLucideIcon(Lucide.AlertTriangle)
+export const AlignCenter = wrapLucideIcon(Lucide.AlignCenter)
+export const AlignCenterHorizontal = wrapLucideIcon(
+  Lucide.AlignCenterHorizontal
+)
+export const AlignCenterVertical = wrapLucideIcon(Lucide.AlignCenterVertical)
+export const AlignEndHorizontal = wrapLucideIcon(Lucide.AlignEndHorizontal)
+export const AlignEndVertical = wrapLucideIcon(Lucide.AlignEndVertical)
+export const AlignHorizontalDistributeCenter = wrapLucideIcon(
+  Lucide.AlignHorizontalDistributeCenter
+)
+export const AlignHorizontalDistributeEnd = wrapLucideIcon(
+  Lucide.AlignHorizontalDistributeEnd
+)
+export const AlignHorizontalDistributeStart = wrapLucideIcon(
+  Lucide.AlignHorizontalDistributeStart
+)
+export const AlignHorizontalJustifyCenter = wrapLucideIcon(
+  Lucide.AlignHorizontalJustifyCenter
+)
+export const AlignHorizontalJustifyEnd = wrapLucideIcon(
+  Lucide.AlignHorizontalJustifyEnd
+)
+export const AlignHorizontalJustifyStart = wrapLucideIcon(
+  Lucide.AlignHorizontalJustifyStart
+)
+export const AlignHorizontalSpaceAround = wrapLucideIcon(
+  Lucide.AlignHorizontalSpaceAround
+)
+export const AlignHorizontalSpaceBetween = wrapLucideIcon(
+  Lucide.AlignHorizontalSpaceBetween
+)
+export const AlignJustify = wrapLucideIcon(Lucide.AlignJustify)
+export const AlignLeft = wrapLucideIcon(Lucide.AlignLeft)
+export const AlignRight = wrapLucideIcon(Lucide.AlignRight)
+export const AlignStartHorizontal = wrapLucideIcon(Lucide.AlignStartHorizontal)
+export const AlignStartVertical = wrapLucideIcon(Lucide.AlignStartVertical)
+export const AlignVerticalDistributeCenter = wrapLucideIcon(
+  Lucide.AlignVerticalDistributeCenter
+)
+export const AlignVerticalDistributeEnd = wrapLucideIcon(
+  Lucide.AlignVerticalDistributeEnd
+)
+export const AlignVerticalDistributeStart = wrapLucideIcon(
+  Lucide.AlignVerticalDistributeStart
+)
+export const AlignVerticalJustifyCenter = wrapLucideIcon(
+  Lucide.AlignVerticalJustifyCenter
+)
+export const AlignVerticalJustifyEnd = wrapLucideIcon(
+  Lucide.AlignVerticalJustifyEnd
+)
+export const AlignVerticalJustifyStart = wrapLucideIcon(
+  Lucide.AlignVerticalJustifyStart
+)
+export const AlignVerticalSpaceAround = wrapLucideIcon(
+  Lucide.AlignVerticalSpaceAround
+)
+export const AlignVerticalSpaceBetween = wrapLucideIcon(
+  Lucide.AlignVerticalSpaceBetween
+)
+export const Ambulance = wrapLucideIcon(Lucide.Ambulance)
+export const Ampersand = wrapLucideIcon(Lucide.Ampersand)
+export const Ampersands = wrapLucideIcon(Lucide.Ampersands)
+export const Amphora = wrapLucideIcon(Lucide.Amphora)
+export const Anchor = wrapLucideIcon(Lucide.Anchor)
+export const Angry = wrapLucideIcon(Lucide.Angry)
+export const Annoyed = wrapLucideIcon(Lucide.Annoyed)
+export const Antenna = wrapLucideIcon(Lucide.Antenna)
+export const Anvil = wrapLucideIcon(Lucide.Anvil)
+export const Aperture = wrapLucideIcon(Lucide.Aperture)
+export const AppWindow = wrapLucideIcon(Lucide.AppWindow)
+export const AppWindowMac = wrapLucideIcon(Lucide.AppWindowMac)
+export const Apple = wrapLucideIcon(Lucide.Apple)
+export const Archive = wrapLucideIcon(Lucide.Archive)
+export const ArchiveRestore = wrapLucideIcon(Lucide.ArchiveRestore)
+export const ArchiveX = wrapLucideIcon(Lucide.ArchiveX)
+export const AreaChart = wrapLucideIcon(Lucide.AreaChart)
+export const Armchair = wrapLucideIcon(Lucide.Armchair)
+export const ArrowBigDown = wrapLucideIcon(Lucide.ArrowBigDown)
+export const ArrowBigDownDash = wrapLucideIcon(Lucide.ArrowBigDownDash)
+export const ArrowBigLeft = wrapLucideIcon(Lucide.ArrowBigLeft)
+export const ArrowBigLeftDash = wrapLucideIcon(Lucide.ArrowBigLeftDash)
+export const ArrowBigRight = wrapLucideIcon(Lucide.ArrowBigRight)
+export const ArrowBigRightDash = wrapLucideIcon(Lucide.ArrowBigRightDash)
+export const ArrowBigUp = wrapLucideIcon(Lucide.ArrowBigUp)
+export const ArrowBigUpDash = wrapLucideIcon(Lucide.ArrowBigUpDash)
+export const ArrowDown = wrapLucideIcon(Lucide.ArrowDown)
+export const ArrowDown01 = wrapLucideIcon(Lucide.ArrowDown01)
+export const ArrowDown10 = wrapLucideIcon(Lucide.ArrowDown10)
+export const ArrowDownAZ = wrapLucideIcon(Lucide.ArrowDownAZ)
+export const ArrowDownAz = wrapLucideIcon(Lucide.ArrowDownAz)
+export const ArrowDownCircle = wrapLucideIcon(Lucide.ArrowDownCircle)
+export const ArrowDownFromLine = wrapLucideIcon(Lucide.ArrowDownFromLine)
+export const ArrowDownLeft = wrapLucideIcon(Lucide.ArrowDownLeft)
+export const ArrowDownLeftFromCircle = wrapLucideIcon(
+  Lucide.ArrowDownLeftFromCircle
+)
+export const ArrowDownLeftFromSquare = wrapLucideIcon(
+  Lucide.ArrowDownLeftFromSquare
+)
+export const ArrowDownLeftSquare = wrapLucideIcon(Lucide.ArrowDownLeftSquare)
+export const ArrowDownNarrowWide = wrapLucideIcon(Lucide.ArrowDownNarrowWide)
+export const ArrowDownRight = wrapLucideIcon(Lucide.ArrowDownRight)
+export const ArrowDownRightFromCircle = wrapLucideIcon(
+  Lucide.ArrowDownRightFromCircle
+)
+export const ArrowDownRightFromSquare = wrapLucideIcon(
+  Lucide.ArrowDownRightFromSquare
+)
+export const ArrowDownRightSquare = wrapLucideIcon(Lucide.ArrowDownRightSquare)
+export const ArrowDownSquare = wrapLucideIcon(Lucide.ArrowDownSquare)
+export const ArrowDownToDot = wrapLucideIcon(Lucide.ArrowDownToDot)
+export const ArrowDownToLine = wrapLucideIcon(Lucide.ArrowDownToLine)
+export const ArrowDownUp = wrapLucideIcon(Lucide.ArrowDownUp)
+export const ArrowDownWideNarrow = wrapLucideIcon(Lucide.ArrowDownWideNarrow)
+export const ArrowDownZA = wrapLucideIcon(Lucide.ArrowDownZA)
+export const ArrowDownZa = wrapLucideIcon(Lucide.ArrowDownZa)
+export const ArrowLeft = wrapLucideIcon(Lucide.ArrowLeft)
+export const ArrowLeftCircle = wrapLucideIcon(Lucide.ArrowLeftCircle)
+export const ArrowLeftFromLine = wrapLucideIcon(Lucide.ArrowLeftFromLine)
+export const ArrowLeftRight = wrapLucideIcon(Lucide.ArrowLeftRight)
+export const ArrowLeftSquare = wrapLucideIcon(Lucide.ArrowLeftSquare)
+export const ArrowLeftToLine = wrapLucideIcon(Lucide.ArrowLeftToLine)
+export const ArrowRight = wrapLucideIcon(Lucide.ArrowRight)
+export const ArrowRightCircle = wrapLucideIcon(Lucide.ArrowRightCircle)
+export const ArrowRightFromLine = wrapLucideIcon(Lucide.ArrowRightFromLine)
+export const ArrowRightLeft = wrapLucideIcon(Lucide.ArrowRightLeft)
+export const ArrowRightSquare = wrapLucideIcon(Lucide.ArrowRightSquare)
+export const ArrowRightToLine = wrapLucideIcon(Lucide.ArrowRightToLine)
+export const ArrowUp = wrapLucideIcon(Lucide.ArrowUp)
+export const ArrowUp01 = wrapLucideIcon(Lucide.ArrowUp01)
+export const ArrowUp10 = wrapLucideIcon(Lucide.ArrowUp10)
+export const ArrowUpAZ = wrapLucideIcon(Lucide.ArrowUpAZ)
+export const ArrowUpAz = wrapLucideIcon(Lucide.ArrowUpAz)
+export const ArrowUpCircle = wrapLucideIcon(Lucide.ArrowUpCircle)
+export const ArrowUpDown = wrapLucideIcon(Lucide.ArrowUpDown)
+export const ArrowUpFromDot = wrapLucideIcon(Lucide.ArrowUpFromDot)
+export const ArrowUpFromLine = wrapLucideIcon(Lucide.ArrowUpFromLine)
+export const ArrowUpLeft = wrapLucideIcon(Lucide.ArrowUpLeft)
+export const ArrowUpLeftFromCircle = wrapLucideIcon(
+  Lucide.ArrowUpLeftFromCircle
+)
+export const ArrowUpLeftFromSquare = wrapLucideIcon(
+  Lucide.ArrowUpLeftFromSquare
+)
+export const ArrowUpLeftSquare = wrapLucideIcon(Lucide.ArrowUpLeftSquare)
+export const ArrowUpNarrowWide = wrapLucideIcon(Lucide.ArrowUpNarrowWide)
+export const ArrowUpRight = wrapLucideIcon(Lucide.ArrowUpRight)
+export const ArrowUpRightFromCircle = wrapLucideIcon(
+  Lucide.ArrowUpRightFromCircle
+)
+export const ArrowUpRightFromSquare = wrapLucideIcon(
+  Lucide.ArrowUpRightFromSquare
+)
+export const ArrowUpRightSquare = wrapLucideIcon(Lucide.ArrowUpRightSquare)
+export const ArrowUpSquare = wrapLucideIcon(Lucide.ArrowUpSquare)
+export const ArrowUpToLine = wrapLucideIcon(Lucide.ArrowUpToLine)
+export const ArrowUpWideNarrow = wrapLucideIcon(Lucide.ArrowUpWideNarrow)
+export const ArrowUpZA = wrapLucideIcon(Lucide.ArrowUpZA)
+export const ArrowUpZa = wrapLucideIcon(Lucide.ArrowUpZa)
+export const ArrowsUpFromLine = wrapLucideIcon(Lucide.ArrowsUpFromLine)
+export const Asterisk = wrapLucideIcon(Lucide.Asterisk)
+export const AsteriskSquare = wrapLucideIcon(Lucide.AsteriskSquare)
+export const AtSign = wrapLucideIcon(Lucide.AtSign)
+export const Atom = wrapLucideIcon(Lucide.Atom)
+export const AudioLines = wrapLucideIcon(Lucide.AudioLines)
+export const AudioWaveform = wrapLucideIcon(Lucide.AudioWaveform)
+export const Award = wrapLucideIcon(Lucide.Award)
+export const Axe = wrapLucideIcon(Lucide.Axe)
+export const Axis3D = wrapLucideIcon(Lucide.Axis3D)
+export const Axis3d = wrapLucideIcon(Lucide.Axis3d)
+export const Baby = wrapLucideIcon(Lucide.Baby)
+export const Backpack = wrapLucideIcon(Lucide.Backpack)
+export const Badge = wrapLucideIcon(Lucide.Badge)
+export const BadgeAlert = wrapLucideIcon(Lucide.BadgeAlert)
+export const BadgeCent = wrapLucideIcon(Lucide.BadgeCent)
+export const BadgeCheck = wrapLucideIcon(Lucide.BadgeCheck)
+export const BadgeDollarSign = wrapLucideIcon(Lucide.BadgeDollarSign)
+export const BadgeEuro = wrapLucideIcon(Lucide.BadgeEuro)
+export const BadgeHelp = wrapLucideIcon(Lucide.BadgeHelp)
+export const BadgeIndianRupee = wrapLucideIcon(Lucide.BadgeIndianRupee)
+export const BadgeInfo = wrapLucideIcon(Lucide.BadgeInfo)
+export const BadgeJapaneseYen = wrapLucideIcon(Lucide.BadgeJapaneseYen)
+export const BadgeMinus = wrapLucideIcon(Lucide.BadgeMinus)
+export const BadgePercent = wrapLucideIcon(Lucide.BadgePercent)
+export const BadgePlus = wrapLucideIcon(Lucide.BadgePlus)
+export const BadgePoundSterling = wrapLucideIcon(Lucide.BadgePoundSterling)
+export const BadgeRussianRuble = wrapLucideIcon(Lucide.BadgeRussianRuble)
+export const BadgeSwissFranc = wrapLucideIcon(Lucide.BadgeSwissFranc)
+export const BadgeX = wrapLucideIcon(Lucide.BadgeX)
+export const BaggageClaim = wrapLucideIcon(Lucide.BaggageClaim)
+export const Ban = wrapLucideIcon(Lucide.Ban)
+export const Banana = wrapLucideIcon(Lucide.Banana)
+export const Bandage = wrapLucideIcon(Lucide.Bandage)
+export const Banknote = wrapLucideIcon(Lucide.Banknote)
+export const BarChart = wrapLucideIcon(Lucide.BarChart)
+export const BarChart2 = wrapLucideIcon(Lucide.BarChart2)
+export const BarChart3 = wrapLucideIcon(Lucide.BarChart3)
+export const BarChart4 = wrapLucideIcon(Lucide.BarChart4)
+export const BarChartBig = wrapLucideIcon(Lucide.BarChartBig)
+export const BarChartHorizontal = wrapLucideIcon(Lucide.BarChartHorizontal)
+export const BarChartHorizontalBig = wrapLucideIcon(
+  Lucide.BarChartHorizontalBig
+)
+export const Barcode = wrapLucideIcon(Lucide.Barcode)
+export const Baseline = wrapLucideIcon(Lucide.Baseline)
+export const Bath = wrapLucideIcon(Lucide.Bath)
+export const Battery = wrapLucideIcon(Lucide.Battery)
+export const BatteryCharging = wrapLucideIcon(Lucide.BatteryCharging)
+export const BatteryFull = wrapLucideIcon(Lucide.BatteryFull)
+export const BatteryLow = wrapLucideIcon(Lucide.BatteryLow)
+export const BatteryMedium = wrapLucideIcon(Lucide.BatteryMedium)
+export const BatteryWarning = wrapLucideIcon(Lucide.BatteryWarning)
+export const Beaker = wrapLucideIcon(Lucide.Beaker)
+export const Bean = wrapLucideIcon(Lucide.Bean)
+export const BeanOff = wrapLucideIcon(Lucide.BeanOff)
+export const Bed = wrapLucideIcon(Lucide.Bed)
+export const BedDouble = wrapLucideIcon(Lucide.BedDouble)
+export const BedSingle = wrapLucideIcon(Lucide.BedSingle)
+export const Beef = wrapLucideIcon(Lucide.Beef)
+export const Beer = wrapLucideIcon(Lucide.Beer)
+export const BeerOff = wrapLucideIcon(Lucide.BeerOff)
+export const Bell = wrapLucideIcon(Lucide.Bell)
+export const BellDot = wrapLucideIcon(Lucide.BellDot)
+export const BellElectric = wrapLucideIcon(Lucide.BellElectric)
+export const BellMinus = wrapLucideIcon(Lucide.BellMinus)
+export const BellOff = wrapLucideIcon(Lucide.BellOff)
+export const BellPlus = wrapLucideIcon(Lucide.BellPlus)
+export const BellRing = wrapLucideIcon(Lucide.BellRing)
+export const BetweenHorizonalEnd = wrapLucideIcon(Lucide.BetweenHorizonalEnd)
+export const BetweenHorizonalStart = wrapLucideIcon(
+  Lucide.BetweenHorizonalStart
+)
+export const BetweenHorizontalEnd = wrapLucideIcon(Lucide.BetweenHorizontalEnd)
+export const BetweenHorizontalStart = wrapLucideIcon(
+  Lucide.BetweenHorizontalStart
+)
+export const BetweenVerticalEnd = wrapLucideIcon(Lucide.BetweenVerticalEnd)
+export const BetweenVerticalStart = wrapLucideIcon(Lucide.BetweenVerticalStart)
+export const BicepsFlexed = wrapLucideIcon(Lucide.BicepsFlexed)
+export const Bike = wrapLucideIcon(Lucide.Bike)
+export const Binary = wrapLucideIcon(Lucide.Binary)
+export const Binoculars = wrapLucideIcon(Lucide.Binoculars)
+export const Biohazard = wrapLucideIcon(Lucide.Biohazard)
+export const Bird = wrapLucideIcon(Lucide.Bird)
+export const Bitcoin = wrapLucideIcon(Lucide.Bitcoin)
+export const Blend = wrapLucideIcon(Lucide.Blend)
+export const Blinds = wrapLucideIcon(Lucide.Blinds)
+export const Blocks = wrapLucideIcon(Lucide.Blocks)
+export const Bluetooth = wrapLucideIcon(Lucide.Bluetooth)
+export const BluetoothConnected = wrapLucideIcon(Lucide.BluetoothConnected)
+export const BluetoothOff = wrapLucideIcon(Lucide.BluetoothOff)
+export const BluetoothSearching = wrapLucideIcon(Lucide.BluetoothSearching)
+export const Bold = wrapLucideIcon(Lucide.Bold)
+export const Bolt = wrapLucideIcon(Lucide.Bolt)
+export const Bomb = wrapLucideIcon(Lucide.Bomb)
+export const Bone = wrapLucideIcon(Lucide.Bone)
+export const Book = wrapLucideIcon(Lucide.Book)
+export const BookA = wrapLucideIcon(Lucide.BookA)
+export const BookAudio = wrapLucideIcon(Lucide.BookAudio)
+export const BookCheck = wrapLucideIcon(Lucide.BookCheck)
+export const BookCopy = wrapLucideIcon(Lucide.BookCopy)
+export const BookDashed = wrapLucideIcon(Lucide.BookDashed)
+export const BookDown = wrapLucideIcon(Lucide.BookDown)
+export const BookHeadphones = wrapLucideIcon(Lucide.BookHeadphones)
+export const BookHeart = wrapLucideIcon(Lucide.BookHeart)
+export const BookImage = wrapLucideIcon(Lucide.BookImage)
+export const BookKey = wrapLucideIcon(Lucide.BookKey)
+export const BookLock = wrapLucideIcon(Lucide.BookLock)
+export const BookMarked = wrapLucideIcon(Lucide.BookMarked)
+export const BookMinus = wrapLucideIcon(Lucide.BookMinus)
+export const BookOpen = wrapLucideIcon(Lucide.BookOpen)
+export const BookOpenCheck = wrapLucideIcon(Lucide.BookOpenCheck)
+export const BookOpenText = wrapLucideIcon(Lucide.BookOpenText)
+export const BookPlus = wrapLucideIcon(Lucide.BookPlus)
+export const BookTemplate = wrapLucideIcon(Lucide.BookTemplate)
+export const BookText = wrapLucideIcon(Lucide.BookText)
+export const BookType = wrapLucideIcon(Lucide.BookType)
+export const BookUp = wrapLucideIcon(Lucide.BookUp)
+export const BookUp2 = wrapLucideIcon(Lucide.BookUp2)
+export const BookUser = wrapLucideIcon(Lucide.BookUser)
+export const BookX = wrapLucideIcon(Lucide.BookX)
+export const Bookmark = wrapLucideIcon(Lucide.Bookmark)
+export const BookmarkCheck = wrapLucideIcon(Lucide.BookmarkCheck)
+export const BookmarkMinus = wrapLucideIcon(Lucide.BookmarkMinus)
+export const BookmarkPlus = wrapLucideIcon(Lucide.BookmarkPlus)
+export const BookmarkX = wrapLucideIcon(Lucide.BookmarkX)
+export const BoomBox = wrapLucideIcon(Lucide.BoomBox)
+export const Bot = wrapLucideIcon(Lucide.Bot)
+export const BotMessageSquare = wrapLucideIcon(Lucide.BotMessageSquare)
+export const BotOff = wrapLucideIcon(Lucide.BotOff)
+export const Box = wrapLucideIcon(Lucide.Box)
+export const BoxSelect = wrapLucideIcon(Lucide.BoxSelect)
+export const Boxes = wrapLucideIcon(Lucide.Boxes)
+export const Braces = wrapLucideIcon(Lucide.Braces)
+export const Brackets = wrapLucideIcon(Lucide.Brackets)
+export const Brain = wrapLucideIcon(Lucide.Brain)
+export const BrainCircuit = wrapLucideIcon(Lucide.BrainCircuit)
+export const BrainCog = wrapLucideIcon(Lucide.BrainCog)
+export const BrickWall = wrapLucideIcon(Lucide.BrickWall)
+export const Briefcase = wrapLucideIcon(Lucide.Briefcase)
+export const BriefcaseBusiness = wrapLucideIcon(Lucide.BriefcaseBusiness)
+export const BriefcaseConveyorBelt = wrapLucideIcon(
+  Lucide.BriefcaseConveyorBelt
+)
+export const BriefcaseMedical = wrapLucideIcon(Lucide.BriefcaseMedical)
+export const BringToFront = wrapLucideIcon(Lucide.BringToFront)
+export const Brush = wrapLucideIcon(Lucide.Brush)
+export const Bug = wrapLucideIcon(Lucide.Bug)
+export const BugOff = wrapLucideIcon(Lucide.BugOff)
+export const BugPlay = wrapLucideIcon(Lucide.BugPlay)
+export const Building = wrapLucideIcon(Lucide.Building)
+export const Building2 = wrapLucideIcon(Lucide.Building2)
+export const Bus = wrapLucideIcon(Lucide.Bus)
+export const BusFront = wrapLucideIcon(Lucide.BusFront)
+export const Cable = wrapLucideIcon(Lucide.Cable)
+export const CableCar = wrapLucideIcon(Lucide.CableCar)
+export const Cake = wrapLucideIcon(Lucide.Cake)
+export const CakeSlice = wrapLucideIcon(Lucide.CakeSlice)
+export const Calculator = wrapLucideIcon(Lucide.Calculator)
+export const Calendar = wrapLucideIcon(Lucide.Calendar)
+export const Calendar1 = wrapLucideIcon(Lucide.Calendar1)
+export const CalendarArrowDown = wrapLucideIcon(Lucide.CalendarArrowDown)
+export const CalendarArrowUp = wrapLucideIcon(Lucide.CalendarArrowUp)
+export const CalendarCheck = wrapLucideIcon(Lucide.CalendarCheck)
+export const CalendarCheck2 = wrapLucideIcon(Lucide.CalendarCheck2)
+export const CalendarClock = wrapLucideIcon(Lucide.CalendarClock)
+export const CalendarCog = wrapLucideIcon(Lucide.CalendarCog)
+export const CalendarDays = wrapLucideIcon(Lucide.CalendarDays)
+export const CalendarFold = wrapLucideIcon(Lucide.CalendarFold)
+export const CalendarHeart = wrapLucideIcon(Lucide.CalendarHeart)
+export const CalendarMinus = wrapLucideIcon(Lucide.CalendarMinus)
+export const CalendarMinus2 = wrapLucideIcon(Lucide.CalendarMinus2)
+export const CalendarOff = wrapLucideIcon(Lucide.CalendarOff)
+export const CalendarPlus = wrapLucideIcon(Lucide.CalendarPlus)
+export const CalendarPlus2 = wrapLucideIcon(Lucide.CalendarPlus2)
+export const CalendarRange = wrapLucideIcon(Lucide.CalendarRange)
+export const CalendarSearch = wrapLucideIcon(Lucide.CalendarSearch)
+export const CalendarX = wrapLucideIcon(Lucide.CalendarX)
+export const CalendarX2 = wrapLucideIcon(Lucide.CalendarX2)
+export const Camera = wrapLucideIcon(Lucide.Camera)
+export const CameraOff = wrapLucideIcon(Lucide.CameraOff)
+export const CandlestickChart = wrapLucideIcon(Lucide.CandlestickChart)
+export const Candy = wrapLucideIcon(Lucide.Candy)
+export const CandyCane = wrapLucideIcon(Lucide.CandyCane)
+export const CandyOff = wrapLucideIcon(Lucide.CandyOff)
+export const Cannabis = wrapLucideIcon(Lucide.Cannabis)
+export const Captions = wrapLucideIcon(Lucide.Captions)
+export const CaptionsOff = wrapLucideIcon(Lucide.CaptionsOff)
+export const Car = wrapLucideIcon(Lucide.Car)
+export const CarFront = wrapLucideIcon(Lucide.CarFront)
+export const CarTaxiFront = wrapLucideIcon(Lucide.CarTaxiFront)
+export const Caravan = wrapLucideIcon(Lucide.Caravan)
+export const Carrot = wrapLucideIcon(Lucide.Carrot)
+export const CaseLower = wrapLucideIcon(Lucide.CaseLower)
+export const CaseSensitive = wrapLucideIcon(Lucide.CaseSensitive)
+export const CaseUpper = wrapLucideIcon(Lucide.CaseUpper)
+export const CassetteTape = wrapLucideIcon(Lucide.CassetteTape)
+export const Cast = wrapLucideIcon(Lucide.Cast)
+export const Castle = wrapLucideIcon(Lucide.Castle)
+export const Cat = wrapLucideIcon(Lucide.Cat)
+export const Cctv = wrapLucideIcon(Lucide.Cctv)
+export const ChartArea = wrapLucideIcon(Lucide.ChartArea)
+export const ChartBar = wrapLucideIcon(Lucide.ChartBar)
+export const ChartBarBig = wrapLucideIcon(Lucide.ChartBarBig)
+export const ChartBarDecreasing = wrapLucideIcon(Lucide.ChartBarDecreasing)
+export const ChartBarIncreasing = wrapLucideIcon(Lucide.ChartBarIncreasing)
+export const ChartBarStacked = wrapLucideIcon(Lucide.ChartBarStacked)
+export const ChartCandlestick = wrapLucideIcon(Lucide.ChartCandlestick)
+export const ChartColumn = wrapLucideIcon(Lucide.ChartColumn)
+export const ChartColumnBig = wrapLucideIcon(Lucide.ChartColumnBig)
+export const ChartColumnDecreasing = wrapLucideIcon(
+  Lucide.ChartColumnDecreasing
+)
+export const ChartColumnIncreasing = wrapLucideIcon(
+  Lucide.ChartColumnIncreasing
+)
+export const ChartColumnStacked = wrapLucideIcon(Lucide.ChartColumnStacked)
+export const ChartGantt = wrapLucideIcon(Lucide.ChartGantt)
+export const ChartLine = wrapLucideIcon(Lucide.ChartLine)
+export const ChartNetwork = wrapLucideIcon(Lucide.ChartNetwork)
+export const ChartNoAxesColumn = wrapLucideIcon(Lucide.ChartNoAxesColumn)
+export const ChartNoAxesColumnDecreasing = wrapLucideIcon(
+  Lucide.ChartNoAxesColumnDecreasing
+)
+export const ChartNoAxesColumnIncreasing = wrapLucideIcon(
+  Lucide.ChartNoAxesColumnIncreasing
+)
+export const ChartNoAxesCombined = wrapLucideIcon(Lucide.ChartNoAxesCombined)
+export const ChartNoAxesGantt = wrapLucideIcon(Lucide.ChartNoAxesGantt)
+export const ChartPie = wrapLucideIcon(Lucide.ChartPie)
+export const ChartScatter = wrapLucideIcon(Lucide.ChartScatter)
+export const ChartSpline = wrapLucideIcon(Lucide.ChartSpline)
+export const Check = wrapLucideIcon(Lucide.Check)
+export const CheckCheck = wrapLucideIcon(Lucide.CheckCheck)
+export const CheckCircle = wrapLucideIcon(Lucide.CheckCircle)
+export const CheckCircle2 = wrapLucideIcon(Lucide.CheckCircle2)
+export const CheckSquare = wrapLucideIcon(Lucide.CheckSquare)
+export const CheckSquare2 = wrapLucideIcon(Lucide.CheckSquare2)
+export const ChefHat = wrapLucideIcon(Lucide.ChefHat)
+export const Cherry = wrapLucideIcon(Lucide.Cherry)
+export const ChevronDown = wrapLucideIcon(Lucide.ChevronDown)
+export const ChevronDownCircle = wrapLucideIcon(Lucide.ChevronDownCircle)
+export const ChevronDownSquare = wrapLucideIcon(Lucide.ChevronDownSquare)
+export const ChevronFirst = wrapLucideIcon(Lucide.ChevronFirst)
+export const ChevronLast = wrapLucideIcon(Lucide.ChevronLast)
+export const ChevronLeft = wrapLucideIcon(Lucide.ChevronLeft)
+export const ChevronLeftCircle = wrapLucideIcon(Lucide.ChevronLeftCircle)
+export const ChevronLeftSquare = wrapLucideIcon(Lucide.ChevronLeftSquare)
+export const ChevronRight = wrapLucideIcon(Lucide.ChevronRight)
+export const ChevronRightCircle = wrapLucideIcon(Lucide.ChevronRightCircle)
+export const ChevronRightSquare = wrapLucideIcon(Lucide.ChevronRightSquare)
+export const ChevronUp = wrapLucideIcon(Lucide.ChevronUp)
+export const ChevronUpCircle = wrapLucideIcon(Lucide.ChevronUpCircle)
+export const ChevronUpSquare = wrapLucideIcon(Lucide.ChevronUpSquare)
+export const ChevronsDown = wrapLucideIcon(Lucide.ChevronsDown)
+export const ChevronsDownUp = wrapLucideIcon(Lucide.ChevronsDownUp)
+export const ChevronsLeft = wrapLucideIcon(Lucide.ChevronsLeft)
+export const ChevronsLeftRight = wrapLucideIcon(Lucide.ChevronsLeftRight)
+export const ChevronsLeftRightEllipsis = wrapLucideIcon(
+  Lucide.ChevronsLeftRightEllipsis
+)
+export const ChevronsRight = wrapLucideIcon(Lucide.ChevronsRight)
+export const ChevronsRightLeft = wrapLucideIcon(Lucide.ChevronsRightLeft)
+export const ChevronsUp = wrapLucideIcon(Lucide.ChevronsUp)
+export const ChevronsUpDown = wrapLucideIcon(Lucide.ChevronsUpDown)
+export const Chrome = wrapLucideIcon(Lucide.Chrome)
+export const Church = wrapLucideIcon(Lucide.Church)
+export const Cigarette = wrapLucideIcon(Lucide.Cigarette)
+export const CigaretteOff = wrapLucideIcon(Lucide.CigaretteOff)
+export const Circle = wrapLucideIcon(Lucide.Circle)
+export const CircleAlert = wrapLucideIcon(Lucide.CircleAlert)
+export const CircleArrowDown = wrapLucideIcon(Lucide.CircleArrowDown)
+export const CircleArrowLeft = wrapLucideIcon(Lucide.CircleArrowLeft)
+export const CircleArrowOutDownLeft = wrapLucideIcon(
+  Lucide.CircleArrowOutDownLeft
+)
+export const CircleArrowOutDownRight = wrapLucideIcon(
+  Lucide.CircleArrowOutDownRight
+)
+export const CircleArrowOutUpLeft = wrapLucideIcon(Lucide.CircleArrowOutUpLeft)
+export const CircleArrowOutUpRight = wrapLucideIcon(
+  Lucide.CircleArrowOutUpRight
+)
+export const CircleArrowRight = wrapLucideIcon(Lucide.CircleArrowRight)
+export const CircleArrowUp = wrapLucideIcon(Lucide.CircleArrowUp)
+export const CircleCheck = wrapLucideIcon(Lucide.CircleCheck)
+export const CircleCheckBig = wrapLucideIcon(Lucide.CircleCheckBig)
+export const CircleChevronDown = wrapLucideIcon(Lucide.CircleChevronDown)
+export const CircleChevronLeft = wrapLucideIcon(Lucide.CircleChevronLeft)
+export const CircleChevronRight = wrapLucideIcon(Lucide.CircleChevronRight)
+export const CircleChevronUp = wrapLucideIcon(Lucide.CircleChevronUp)
+export const CircleDashed = wrapLucideIcon(Lucide.CircleDashed)
+export const CircleDivide = wrapLucideIcon(Lucide.CircleDivide)
+export const CircleDollarSign = wrapLucideIcon(Lucide.CircleDollarSign)
+export const CircleDot = wrapLucideIcon(Lucide.CircleDot)
+export const CircleDotDashed = wrapLucideIcon(Lucide.CircleDotDashed)
+export const CircleEllipsis = wrapLucideIcon(Lucide.CircleEllipsis)
+export const CircleEqual = wrapLucideIcon(Lucide.CircleEqual)
+export const CircleFadingArrowUp = wrapLucideIcon(Lucide.CircleFadingArrowUp)
+export const CircleFadingPlus = wrapLucideIcon(Lucide.CircleFadingPlus)
+export const CircleGauge = wrapLucideIcon(Lucide.CircleGauge)
+export const CircleHelp = wrapLucideIcon(Lucide.CircleHelp)
+export const CircleMinus = wrapLucideIcon(Lucide.CircleMinus)
+export const CircleOff = wrapLucideIcon(Lucide.CircleOff)
+export const CircleParking = wrapLucideIcon(Lucide.CircleParking)
+export const CircleParkingOff = wrapLucideIcon(Lucide.CircleParkingOff)
+export const CirclePause = wrapLucideIcon(Lucide.CirclePause)
+export const CirclePercent = wrapLucideIcon(Lucide.CirclePercent)
+export const CirclePlay = wrapLucideIcon(Lucide.CirclePlay)
+export const CirclePlus = wrapLucideIcon(Lucide.CirclePlus)
+export const CirclePower = wrapLucideIcon(Lucide.CirclePower)
+export const CircleSlash = wrapLucideIcon(Lucide.CircleSlash)
+export const CircleSlash2 = wrapLucideIcon(Lucide.CircleSlash2)
+export const CircleSlashed = wrapLucideIcon(Lucide.CircleSlashed)
+export const CircleStop = wrapLucideIcon(Lucide.CircleStop)
+export const CircleUser = wrapLucideIcon(Lucide.CircleUser)
+export const CircleUserRound = wrapLucideIcon(Lucide.CircleUserRound)
+export const CircleX = wrapLucideIcon(Lucide.CircleX)
+export const CircuitBoard = wrapLucideIcon(Lucide.CircuitBoard)
+export const Citrus = wrapLucideIcon(Lucide.Citrus)
+export const Clapperboard = wrapLucideIcon(Lucide.Clapperboard)
+export const Clipboard = wrapLucideIcon(Lucide.Clipboard)
+export const ClipboardCheck = wrapLucideIcon(Lucide.ClipboardCheck)
+export const ClipboardCopy = wrapLucideIcon(Lucide.ClipboardCopy)
+export const ClipboardEdit = wrapLucideIcon(Lucide.ClipboardEdit)
+export const ClipboardList = wrapLucideIcon(Lucide.ClipboardList)
+export const ClipboardMinus = wrapLucideIcon(Lucide.ClipboardMinus)
+export const ClipboardPaste = wrapLucideIcon(Lucide.ClipboardPaste)
+export const ClipboardPen = wrapLucideIcon(Lucide.ClipboardPen)
+export const ClipboardPenLine = wrapLucideIcon(Lucide.ClipboardPenLine)
+export const ClipboardPlus = wrapLucideIcon(Lucide.ClipboardPlus)
+export const ClipboardSignature = wrapLucideIcon(Lucide.ClipboardSignature)
+export const ClipboardType = wrapLucideIcon(Lucide.ClipboardType)
+export const ClipboardX = wrapLucideIcon(Lucide.ClipboardX)
+export const Clock = wrapLucideIcon(Lucide.Clock)
+export const Clock1 = wrapLucideIcon(Lucide.Clock1)
+export const Clock10 = wrapLucideIcon(Lucide.Clock10)
+export const Clock11 = wrapLucideIcon(Lucide.Clock11)
+export const Clock12 = wrapLucideIcon(Lucide.Clock12)
+export const Clock2 = wrapLucideIcon(Lucide.Clock2)
+export const Clock3 = wrapLucideIcon(Lucide.Clock3)
+export const Clock4 = wrapLucideIcon(Lucide.Clock4)
+export const Clock5 = wrapLucideIcon(Lucide.Clock5)
+export const Clock6 = wrapLucideIcon(Lucide.Clock6)
+export const Clock7 = wrapLucideIcon(Lucide.Clock7)
+export const Clock8 = wrapLucideIcon(Lucide.Clock8)
+export const Clock9 = wrapLucideIcon(Lucide.Clock9)
+export const ClockAlert = wrapLucideIcon(Lucide.ClockAlert)
+export const ClockArrowDown = wrapLucideIcon(Lucide.ClockArrowDown)
+export const ClockArrowUp = wrapLucideIcon(Lucide.ClockArrowUp)
+export const Cloud = wrapLucideIcon(Lucide.Cloud)
+export const CloudAlert = wrapLucideIcon(Lucide.CloudAlert)
+export const CloudCog = wrapLucideIcon(Lucide.CloudCog)
+export const CloudDownload = wrapLucideIcon(Lucide.CloudDownload)
+export const CloudDrizzle = wrapLucideIcon(Lucide.CloudDrizzle)
+export const CloudFog = wrapLucideIcon(Lucide.CloudFog)
+export const CloudHail = wrapLucideIcon(Lucide.CloudHail)
+export const CloudLightning = wrapLucideIcon(Lucide.CloudLightning)
+export const CloudMoon = wrapLucideIcon(Lucide.CloudMoon)
+export const CloudMoonRain = wrapLucideIcon(Lucide.CloudMoonRain)
+export const CloudOff = wrapLucideIcon(Lucide.CloudOff)
+export const CloudRain = wrapLucideIcon(Lucide.CloudRain)
+export const CloudRainWind = wrapLucideIcon(Lucide.CloudRainWind)
+export const CloudSnow = wrapLucideIcon(Lucide.CloudSnow)
+export const CloudSun = wrapLucideIcon(Lucide.CloudSun)
+export const CloudSunRain = wrapLucideIcon(Lucide.CloudSunRain)
+export const CloudUpload = wrapLucideIcon(Lucide.CloudUpload)
+export const Cloudy = wrapLucideIcon(Lucide.Cloudy)
+export const Clover = wrapLucideIcon(Lucide.Clover)
+export const Club = wrapLucideIcon(Lucide.Club)
+export const Code = wrapLucideIcon(Lucide.Code)
+export const Code2 = wrapLucideIcon(Lucide.Code2)
+export const CodeSquare = wrapLucideIcon(Lucide.CodeSquare)
+export const CodeXml = wrapLucideIcon(Lucide.CodeXml)
+export const Codepen = wrapLucideIcon(Lucide.Codepen)
+export const Codesandbox = wrapLucideIcon(Lucide.Codesandbox)
+export const Coffee = wrapLucideIcon(Lucide.Coffee)
+export const Cog = wrapLucideIcon(Lucide.Cog)
+export const Coins = wrapLucideIcon(Lucide.Coins)
+export const Columns = wrapLucideIcon(Lucide.Columns)
+export const Columns2 = wrapLucideIcon(Lucide.Columns2)
+export const Columns3 = wrapLucideIcon(Lucide.Columns3)
+export const Columns4 = wrapLucideIcon(Lucide.Columns4)
+export const Combine = wrapLucideIcon(Lucide.Combine)
+export const Command = wrapLucideIcon(Lucide.Command)
+export const Compass = wrapLucideIcon(Lucide.Compass)
+export const Component = wrapLucideIcon(Lucide.Component)
+export const Computer = wrapLucideIcon(Lucide.Computer)
+export const ConciergeBell = wrapLucideIcon(Lucide.ConciergeBell)
+export const Cone = wrapLucideIcon(Lucide.Cone)
+export const Construction = wrapLucideIcon(Lucide.Construction)
+export const Contact = wrapLucideIcon(Lucide.Contact)
+export const Contact2 = wrapLucideIcon(Lucide.Contact2)
+export const ContactRound = wrapLucideIcon(Lucide.ContactRound)
+export const Container = wrapLucideIcon(Lucide.Container)
+export const Contrast = wrapLucideIcon(Lucide.Contrast)
+export const Cookie = wrapLucideIcon(Lucide.Cookie)
+export const CookingPot = wrapLucideIcon(Lucide.CookingPot)
+export const Copy = wrapLucideIcon(Lucide.Copy)
+export const CopyCheck = wrapLucideIcon(Lucide.CopyCheck)
+export const CopyMinus = wrapLucideIcon(Lucide.CopyMinus)
+export const CopyPlus = wrapLucideIcon(Lucide.CopyPlus)
+export const CopySlash = wrapLucideIcon(Lucide.CopySlash)
+export const CopyX = wrapLucideIcon(Lucide.CopyX)
+export const Copyleft = wrapLucideIcon(Lucide.Copyleft)
+export const Copyright = wrapLucideIcon(Lucide.Copyright)
+export const CornerDownLeft = wrapLucideIcon(Lucide.CornerDownLeft)
+export const CornerDownRight = wrapLucideIcon(Lucide.CornerDownRight)
+export const CornerLeftDown = wrapLucideIcon(Lucide.CornerLeftDown)
+export const CornerLeftUp = wrapLucideIcon(Lucide.CornerLeftUp)
+export const CornerRightDown = wrapLucideIcon(Lucide.CornerRightDown)
+export const CornerRightUp = wrapLucideIcon(Lucide.CornerRightUp)
+export const CornerUpLeft = wrapLucideIcon(Lucide.CornerUpLeft)
+export const CornerUpRight = wrapLucideIcon(Lucide.CornerUpRight)
+export const Cpu = wrapLucideIcon(Lucide.Cpu)
+export const CreativeCommons = wrapLucideIcon(Lucide.CreativeCommons)
+export const CreditCard = wrapLucideIcon(Lucide.CreditCard)
+export const Croissant = wrapLucideIcon(Lucide.Croissant)
+export const Crop = wrapLucideIcon(Lucide.Crop)
+export const Cross = wrapLucideIcon(Lucide.Cross)
+export const Crosshair = wrapLucideIcon(Lucide.Crosshair)
+export const Crown = wrapLucideIcon(Lucide.Crown)
+export const Cuboid = wrapLucideIcon(Lucide.Cuboid)
+export const CupSoda = wrapLucideIcon(Lucide.CupSoda)
+export const CurlyBraces = wrapLucideIcon(Lucide.CurlyBraces)
+export const Currency = wrapLucideIcon(Lucide.Currency)
+export const Cylinder = wrapLucideIcon(Lucide.Cylinder)
+export const Dam = wrapLucideIcon(Lucide.Dam)
+export const Database = wrapLucideIcon(Lucide.Database)
+export const DatabaseBackup = wrapLucideIcon(Lucide.DatabaseBackup)
+export const DatabaseZap = wrapLucideIcon(Lucide.DatabaseZap)
+export const Delete = wrapLucideIcon(Lucide.Delete)
+export const Dessert = wrapLucideIcon(Lucide.Dessert)
+export const Diameter = wrapLucideIcon(Lucide.Diameter)
+export const Diamond = wrapLucideIcon(Lucide.Diamond)
+export const DiamondMinus = wrapLucideIcon(Lucide.DiamondMinus)
+export const DiamondPercent = wrapLucideIcon(Lucide.DiamondPercent)
+export const DiamondPlus = wrapLucideIcon(Lucide.DiamondPlus)
+export const Dice1 = wrapLucideIcon(Lucide.Dice1)
+export const Dice2 = wrapLucideIcon(Lucide.Dice2)
+export const Dice3 = wrapLucideIcon(Lucide.Dice3)
+export const Dice4 = wrapLucideIcon(Lucide.Dice4)
+export const Dice5 = wrapLucideIcon(Lucide.Dice5)
+export const Dice6 = wrapLucideIcon(Lucide.Dice6)
+export const Dices = wrapLucideIcon(Lucide.Dices)
+export const Diff = wrapLucideIcon(Lucide.Diff)
+export const Disc = wrapLucideIcon(Lucide.Disc)
+export const Disc2 = wrapLucideIcon(Lucide.Disc2)
+export const Disc3 = wrapLucideIcon(Lucide.Disc3)
+export const DiscAlbum = wrapLucideIcon(Lucide.DiscAlbum)
+export const Divide = wrapLucideIcon(Lucide.Divide)
+export const DivideCircle = wrapLucideIcon(Lucide.DivideCircle)
+export const DivideSquare = wrapLucideIcon(Lucide.DivideSquare)
+export const Dna = wrapLucideIcon(Lucide.Dna)
+export const DnaOff = wrapLucideIcon(Lucide.DnaOff)
+export const Dock = wrapLucideIcon(Lucide.Dock)
+export const Dog = wrapLucideIcon(Lucide.Dog)
+export const DollarSign = wrapLucideIcon(Lucide.DollarSign)
+export const Donut = wrapLucideIcon(Lucide.Donut)
+export const DoorClosed = wrapLucideIcon(Lucide.DoorClosed)
+export const DoorOpen = wrapLucideIcon(Lucide.DoorOpen)
+export const Dot = wrapLucideIcon(Lucide.Dot)
+export const DotSquare = wrapLucideIcon(Lucide.DotSquare)
+export const Download = wrapLucideIcon(Lucide.Download)
+export const DownloadCloud = wrapLucideIcon(Lucide.DownloadCloud)
+export const DraftingCompass = wrapLucideIcon(Lucide.DraftingCompass)
+export const Drama = wrapLucideIcon(Lucide.Drama)
+export const Dribbble = wrapLucideIcon(Lucide.Dribbble)
+export const Drill = wrapLucideIcon(Lucide.Drill)
+export const Droplet = wrapLucideIcon(Lucide.Droplet)
+export const Droplets = wrapLucideIcon(Lucide.Droplets)
+export const Drum = wrapLucideIcon(Lucide.Drum)
+export const Drumstick = wrapLucideIcon(Lucide.Drumstick)
+export const Dumbbell = wrapLucideIcon(Lucide.Dumbbell)
+export const Ear = wrapLucideIcon(Lucide.Ear)
+export const EarOff = wrapLucideIcon(Lucide.EarOff)
+export const Earth = wrapLucideIcon(Lucide.Earth)
+export const EarthLock = wrapLucideIcon(Lucide.EarthLock)
+export const Eclipse = wrapLucideIcon(Lucide.Eclipse)
+export const Edit = wrapLucideIcon(Lucide.Edit)
+export const Edit2 = wrapLucideIcon(Lucide.Edit2)
+export const Edit3 = wrapLucideIcon(Lucide.Edit3)
+export const Egg = wrapLucideIcon(Lucide.Egg)
+export const EggFried = wrapLucideIcon(Lucide.EggFried)
+export const EggOff = wrapLucideIcon(Lucide.EggOff)
+export const Ellipsis = wrapLucideIcon(Lucide.Ellipsis)
+export const EllipsisVertical = wrapLucideIcon(Lucide.EllipsisVertical)
+export const Equal = wrapLucideIcon(Lucide.Equal)
+export const EqualApproximately = wrapLucideIcon(Lucide.EqualApproximately)
+export const EqualNot = wrapLucideIcon(Lucide.EqualNot)
+export const EqualSquare = wrapLucideIcon(Lucide.EqualSquare)
+export const Eraser = wrapLucideIcon(Lucide.Eraser)
+export const EthernetPort = wrapLucideIcon(Lucide.EthernetPort)
+export const Euro = wrapLucideIcon(Lucide.Euro)
+export const Expand = wrapLucideIcon(Lucide.Expand)
+export const ExternalLink = wrapLucideIcon(Lucide.ExternalLink)
+export const Eye = wrapLucideIcon(Lucide.Eye)
+export const EyeClosed = wrapLucideIcon(Lucide.EyeClosed)
+export const EyeOff = wrapLucideIcon(Lucide.EyeOff)
+export const Facebook = wrapLucideIcon(Lucide.Facebook)
+export const Factory = wrapLucideIcon(Lucide.Factory)
+export const Fan = wrapLucideIcon(Lucide.Fan)
+export const FastForward = wrapLucideIcon(Lucide.FastForward)
+export const Feather = wrapLucideIcon(Lucide.Feather)
+export const Fence = wrapLucideIcon(Lucide.Fence)
+export const FerrisWheel = wrapLucideIcon(Lucide.FerrisWheel)
+export const Figma = wrapLucideIcon(Lucide.Figma)
+export const File = wrapLucideIcon(Lucide.File)
+export const FileArchive = wrapLucideIcon(Lucide.FileArchive)
+export const FileAudio = wrapLucideIcon(Lucide.FileAudio)
+export const FileAudio2 = wrapLucideIcon(Lucide.FileAudio2)
+export const FileAxis3D = wrapLucideIcon(Lucide.FileAxis3D)
+export const FileAxis3d = wrapLucideIcon(Lucide.FileAxis3d)
+export const FileBadge = wrapLucideIcon(Lucide.FileBadge)
+export const FileBadge2 = wrapLucideIcon(Lucide.FileBadge2)
+export const FileBarChart = wrapLucideIcon(Lucide.FileBarChart)
+export const FileBarChart2 = wrapLucideIcon(Lucide.FileBarChart2)
+export const FileBox = wrapLucideIcon(Lucide.FileBox)
+export const FileChartColumn = wrapLucideIcon(Lucide.FileChartColumn)
+export const FileChartColumnIncreasing = wrapLucideIcon(
+  Lucide.FileChartColumnIncreasing
+)
+export const FileChartLine = wrapLucideIcon(Lucide.FileChartLine)
+export const FileChartPie = wrapLucideIcon(Lucide.FileChartPie)
+export const FileCheck = wrapLucideIcon(Lucide.FileCheck)
+export const FileCheck2 = wrapLucideIcon(Lucide.FileCheck2)
+export const FileClock = wrapLucideIcon(Lucide.FileClock)
+export const FileCode = wrapLucideIcon(Lucide.FileCode)
+export const FileCode2 = wrapLucideIcon(Lucide.FileCode2)
+export const FileCog = wrapLucideIcon(Lucide.FileCog)
+export const FileCog2 = wrapLucideIcon(Lucide.FileCog2)
+export const FileDiff = wrapLucideIcon(Lucide.FileDiff)
+export const FileDigit = wrapLucideIcon(Lucide.FileDigit)
+export const FileDown = wrapLucideIcon(Lucide.FileDown)
+export const FileEdit = wrapLucideIcon(Lucide.FileEdit)
+export const FileHeart = wrapLucideIcon(Lucide.FileHeart)
+export const FileImage = wrapLucideIcon(Lucide.FileImage)
+export const FileInput = wrapLucideIcon(Lucide.FileInput)
+export const FileJson = wrapLucideIcon(Lucide.FileJson)
+export const FileJson2 = wrapLucideIcon(Lucide.FileJson2)
+export const FileKey = wrapLucideIcon(Lucide.FileKey)
+export const FileKey2 = wrapLucideIcon(Lucide.FileKey2)
+export const FileLineChart = wrapLucideIcon(Lucide.FileLineChart)
+export const FileLock = wrapLucideIcon(Lucide.FileLock)
+export const FileLock2 = wrapLucideIcon(Lucide.FileLock2)
+export const FileMinus = wrapLucideIcon(Lucide.FileMinus)
+export const FileMinus2 = wrapLucideIcon(Lucide.FileMinus2)
+export const FileMusic = wrapLucideIcon(Lucide.FileMusic)
+export const FileOutput = wrapLucideIcon(Lucide.FileOutput)
+export const FilePen = wrapLucideIcon(Lucide.FilePen)
+export const FilePenLine = wrapLucideIcon(Lucide.FilePenLine)
+export const FilePieChart = wrapLucideIcon(Lucide.FilePieChart)
+export const FilePlus = wrapLucideIcon(Lucide.FilePlus)
+export const FilePlus2 = wrapLucideIcon(Lucide.FilePlus2)
+export const FileQuestion = wrapLucideIcon(Lucide.FileQuestion)
+export const FileScan = wrapLucideIcon(Lucide.FileScan)
+export const FileSearch = wrapLucideIcon(Lucide.FileSearch)
+export const FileSearch2 = wrapLucideIcon(Lucide.FileSearch2)
+export const FileSignature = wrapLucideIcon(Lucide.FileSignature)
+export const FileSliders = wrapLucideIcon(Lucide.FileSliders)
+export const FileSpreadsheet = wrapLucideIcon(Lucide.FileSpreadsheet)
+export const FileStack = wrapLucideIcon(Lucide.FileStack)
+export const FileSymlink = wrapLucideIcon(Lucide.FileSymlink)
+export const FileTerminal = wrapLucideIcon(Lucide.FileTerminal)
+export const FileText = wrapLucideIcon(Lucide.FileText)
+export const FileType = wrapLucideIcon(Lucide.FileType)
+export const FileType2 = wrapLucideIcon(Lucide.FileType2)
+export const FileUp = wrapLucideIcon(Lucide.FileUp)
+export const FileUser = wrapLucideIcon(Lucide.FileUser)
+export const FileVideo = wrapLucideIcon(Lucide.FileVideo)
+export const FileVideo2 = wrapLucideIcon(Lucide.FileVideo2)
+export const FileVolume = wrapLucideIcon(Lucide.FileVolume)
+export const FileVolume2 = wrapLucideIcon(Lucide.FileVolume2)
+export const FileWarning = wrapLucideIcon(Lucide.FileWarning)
+export const FileX = wrapLucideIcon(Lucide.FileX)
+export const FileX2 = wrapLucideIcon(Lucide.FileX2)
+export const Files = wrapLucideIcon(Lucide.Files)
+export const Film = wrapLucideIcon(Lucide.Film)
+export const Filter = wrapLucideIcon(Lucide.Filter)
+export const FilterX = wrapLucideIcon(Lucide.FilterX)
+export const Fingerprint = wrapLucideIcon(Lucide.Fingerprint)
+export const FireExtinguisher = wrapLucideIcon(Lucide.FireExtinguisher)
+export const Fish = wrapLucideIcon(Lucide.Fish)
+export const FishOff = wrapLucideIcon(Lucide.FishOff)
+export const FishSymbol = wrapLucideIcon(Lucide.FishSymbol)
+export const Flag = wrapLucideIcon(Lucide.Flag)
+export const FlagOff = wrapLucideIcon(Lucide.FlagOff)
+export const FlagTriangleLeft = wrapLucideIcon(Lucide.FlagTriangleLeft)
+export const FlagTriangleRight = wrapLucideIcon(Lucide.FlagTriangleRight)
+export const Flame = wrapLucideIcon(Lucide.Flame)
+export const FlameKindling = wrapLucideIcon(Lucide.FlameKindling)
+export const Flashlight = wrapLucideIcon(Lucide.Flashlight)
+export const FlashlightOff = wrapLucideIcon(Lucide.FlashlightOff)
+export const FlaskConical = wrapLucideIcon(Lucide.FlaskConical)
+export const FlaskConicalOff = wrapLucideIcon(Lucide.FlaskConicalOff)
+export const FlaskRound = wrapLucideIcon(Lucide.FlaskRound)
+export const FlipHorizontal = wrapLucideIcon(Lucide.FlipHorizontal)
+export const FlipHorizontal2 = wrapLucideIcon(Lucide.FlipHorizontal2)
+export const FlipVertical = wrapLucideIcon(Lucide.FlipVertical)
+export const FlipVertical2 = wrapLucideIcon(Lucide.FlipVertical2)
+export const Flower = wrapLucideIcon(Lucide.Flower)
+export const Flower2 = wrapLucideIcon(Lucide.Flower2)
+export const Focus = wrapLucideIcon(Lucide.Focus)
+export const FoldHorizontal = wrapLucideIcon(Lucide.FoldHorizontal)
+export const FoldVertical = wrapLucideIcon(Lucide.FoldVertical)
+export const Folder = wrapLucideIcon(Lucide.Folder)
+export const FolderArchive = wrapLucideIcon(Lucide.FolderArchive)
+export const FolderCheck = wrapLucideIcon(Lucide.FolderCheck)
+export const FolderClock = wrapLucideIcon(Lucide.FolderClock)
+export const FolderClosed = wrapLucideIcon(Lucide.FolderClosed)
+export const FolderCode = wrapLucideIcon(Lucide.FolderCode)
+export const FolderCog = wrapLucideIcon(Lucide.FolderCog)
+export const FolderCog2 = wrapLucideIcon(Lucide.FolderCog2)
+export const FolderDot = wrapLucideIcon(Lucide.FolderDot)
+export const FolderDown = wrapLucideIcon(Lucide.FolderDown)
+export const FolderEdit = wrapLucideIcon(Lucide.FolderEdit)
+export const FolderGit = wrapLucideIcon(Lucide.FolderGit)
+export const FolderGit2 = wrapLucideIcon(Lucide.FolderGit2)
+export const FolderHeart = wrapLucideIcon(Lucide.FolderHeart)
+export const FolderInput = wrapLucideIcon(Lucide.FolderInput)
+export const FolderKanban = wrapLucideIcon(Lucide.FolderKanban)
+export const FolderKey = wrapLucideIcon(Lucide.FolderKey)
+export const FolderLock = wrapLucideIcon(Lucide.FolderLock)
+export const FolderMinus = wrapLucideIcon(Lucide.FolderMinus)
+export const FolderOpen = wrapLucideIcon(Lucide.FolderOpen)
+export const FolderOpenDot = wrapLucideIcon(Lucide.FolderOpenDot)
+export const FolderOutput = wrapLucideIcon(Lucide.FolderOutput)
+export const FolderPen = wrapLucideIcon(Lucide.FolderPen)
+export const FolderPlus = wrapLucideIcon(Lucide.FolderPlus)
+export const FolderRoot = wrapLucideIcon(Lucide.FolderRoot)
+export const FolderSearch = wrapLucideIcon(Lucide.FolderSearch)
+export const FolderSearch2 = wrapLucideIcon(Lucide.FolderSearch2)
+export const FolderSymlink = wrapLucideIcon(Lucide.FolderSymlink)
+export const FolderSync = wrapLucideIcon(Lucide.FolderSync)
+export const FolderTree = wrapLucideIcon(Lucide.FolderTree)
+export const FolderUp = wrapLucideIcon(Lucide.FolderUp)
+export const FolderX = wrapLucideIcon(Lucide.FolderX)
+export const Folders = wrapLucideIcon(Lucide.Folders)
+export const Footprints = wrapLucideIcon(Lucide.Footprints)
+export const ForkKnife = wrapLucideIcon(Lucide.ForkKnife)
+export const ForkKnifeCrossed = wrapLucideIcon(Lucide.ForkKnifeCrossed)
+export const Forklift = wrapLucideIcon(Lucide.Forklift)
+export const FormInput = wrapLucideIcon(Lucide.FormInput)
+export const Forward = wrapLucideIcon(Lucide.Forward)
+export const Frame = wrapLucideIcon(Lucide.Frame)
+export const Framer = wrapLucideIcon(Lucide.Framer)
+export const Frown = wrapLucideIcon(Lucide.Frown)
+export const Fuel = wrapLucideIcon(Lucide.Fuel)
+export const Fullscreen = wrapLucideIcon(Lucide.Fullscreen)
+export const FunctionSquare = wrapLucideIcon(Lucide.FunctionSquare)
+export const GalleryHorizontal = wrapLucideIcon(Lucide.GalleryHorizontal)
+export const GalleryHorizontalEnd = wrapLucideIcon(Lucide.GalleryHorizontalEnd)
+export const GalleryThumbnails = wrapLucideIcon(Lucide.GalleryThumbnails)
+export const GalleryVertical = wrapLucideIcon(Lucide.GalleryVertical)
+export const GalleryVerticalEnd = wrapLucideIcon(Lucide.GalleryVerticalEnd)
+export const Gamepad = wrapLucideIcon(Lucide.Gamepad)
+export const Gamepad2 = wrapLucideIcon(Lucide.Gamepad2)
+export const GanttChart = wrapLucideIcon(Lucide.GanttChart)
+export const GanttChartSquare = wrapLucideIcon(Lucide.GanttChartSquare)
+export const Gauge = wrapLucideIcon(Lucide.Gauge)
+export const GaugeCircle = wrapLucideIcon(Lucide.GaugeCircle)
+export const Gavel = wrapLucideIcon(Lucide.Gavel)
+export const Gem = wrapLucideIcon(Lucide.Gem)
+export const Ghost = wrapLucideIcon(Lucide.Ghost)
+export const Gift = wrapLucideIcon(Lucide.Gift)
+export const GitBranch = wrapLucideIcon(Lucide.GitBranch)
+export const GitBranchPlus = wrapLucideIcon(Lucide.GitBranchPlus)
+export const GitCommit = wrapLucideIcon(Lucide.GitCommit)
+export const GitCommitHorizontal = wrapLucideIcon(Lucide.GitCommitHorizontal)
+export const GitCommitVertical = wrapLucideIcon(Lucide.GitCommitVertical)
+export const GitCompare = wrapLucideIcon(Lucide.GitCompare)
+export const GitCompareArrows = wrapLucideIcon(Lucide.GitCompareArrows)
+export const GitFork = wrapLucideIcon(Lucide.GitFork)
+export const GitGraph = wrapLucideIcon(Lucide.GitGraph)
+export const GitMerge = wrapLucideIcon(Lucide.GitMerge)
+export const GitPullRequest = wrapLucideIcon(Lucide.GitPullRequest)
+export const GitPullRequestArrow = wrapLucideIcon(Lucide.GitPullRequestArrow)
+export const GitPullRequestClosed = wrapLucideIcon(Lucide.GitPullRequestClosed)
+export const GitPullRequestCreate = wrapLucideIcon(Lucide.GitPullRequestCreate)
+export const GitPullRequestCreateArrow = wrapLucideIcon(
+  Lucide.GitPullRequestCreateArrow
+)
+export const GitPullRequestDraft = wrapLucideIcon(Lucide.GitPullRequestDraft)
+export const Github = wrapLucideIcon(Lucide.Github)
+export const Gitlab = wrapLucideIcon(Lucide.Gitlab)
+export const GlassWater = wrapLucideIcon(Lucide.GlassWater)
+export const Glasses = wrapLucideIcon(Lucide.Glasses)
+export const Globe = wrapLucideIcon(Lucide.Globe)
+export const Globe2 = wrapLucideIcon(Lucide.Globe2)
+export const GlobeLock = wrapLucideIcon(Lucide.GlobeLock)
+export const Goal = wrapLucideIcon(Lucide.Goal)
+export const Grab = wrapLucideIcon(Lucide.Grab)
+export const GraduationCap = wrapLucideIcon(Lucide.GraduationCap)
+export const Grape = wrapLucideIcon(Lucide.Grape)
+export const Grid = wrapLucideIcon(Lucide.Grid)
+export const Grid2X2 = wrapLucideIcon(Lucide.Grid2X2)
+export const Grid2X2Plus = wrapLucideIcon(Lucide.Grid2X2Plus)
+export const Grid2x2 = wrapLucideIcon(Lucide.Grid2x2)
+export const Grid2x2Check = wrapLucideIcon(Lucide.Grid2x2Check)
+export const Grid2x2Plus = wrapLucideIcon(Lucide.Grid2x2Plus)
+export const Grid2x2X = wrapLucideIcon(Lucide.Grid2x2X)
+export const Grid3X3 = wrapLucideIcon(Lucide.Grid3X3)
+export const Grid3x3 = wrapLucideIcon(Lucide.Grid3x3)
+export const Grip = wrapLucideIcon(Lucide.Grip)
+export const GripHorizontal = wrapLucideIcon(Lucide.GripHorizontal)
+export const GripVertical = wrapLucideIcon(Lucide.GripVertical)
+export const Group = wrapLucideIcon(Lucide.Group)
+export const Guitar = wrapLucideIcon(Lucide.Guitar)
+export const Ham = wrapLucideIcon(Lucide.Ham)
+export const Hammer = wrapLucideIcon(Lucide.Hammer)
+export const Hand = wrapLucideIcon(Lucide.Hand)
+export const HandCoins = wrapLucideIcon(Lucide.HandCoins)
+export const HandHeart = wrapLucideIcon(Lucide.HandHeart)
+export const HandHelping = wrapLucideIcon(Lucide.HandHelping)
+export const HandMetal = wrapLucideIcon(Lucide.HandMetal)
+export const HandPlatter = wrapLucideIcon(Lucide.HandPlatter)
+export const Handshake = wrapLucideIcon(Lucide.Handshake)
+export const HardDrive = wrapLucideIcon(Lucide.HardDrive)
+export const HardDriveDownload = wrapLucideIcon(Lucide.HardDriveDownload)
+export const HardDriveUpload = wrapLucideIcon(Lucide.HardDriveUpload)
+export const HardHat = wrapLucideIcon(Lucide.HardHat)
+export const Hash = wrapLucideIcon(Lucide.Hash)
+export const Haze = wrapLucideIcon(Lucide.Haze)
+export const HdmiPort = wrapLucideIcon(Lucide.HdmiPort)
+export const Heading = wrapLucideIcon(Lucide.Heading)
+export const Heading1 = wrapLucideIcon(Lucide.Heading1)
+export const Heading2 = wrapLucideIcon(Lucide.Heading2)
+export const Heading3 = wrapLucideIcon(Lucide.Heading3)
+export const Heading4 = wrapLucideIcon(Lucide.Heading4)
+export const Heading5 = wrapLucideIcon(Lucide.Heading5)
+export const Heading6 = wrapLucideIcon(Lucide.Heading6)
+export const HeadphoneOff = wrapLucideIcon(Lucide.HeadphoneOff)
+export const Headphones = wrapLucideIcon(Lucide.Headphones)
+export const Headset = wrapLucideIcon(Lucide.Headset)
+export const Heart = wrapLucideIcon(Lucide.Heart)
+export const HeartCrack = wrapLucideIcon(Lucide.HeartCrack)
+export const HeartHandshake = wrapLucideIcon(Lucide.HeartHandshake)
+export const HeartOff = wrapLucideIcon(Lucide.HeartOff)
+export const HeartPulse = wrapLucideIcon(Lucide.HeartPulse)
+export const Heater = wrapLucideIcon(Lucide.Heater)
+export const HelpCircle = wrapLucideIcon(Lucide.HelpCircle)
+export const HelpingHand = wrapLucideIcon(Lucide.HelpingHand)
+export const Hexagon = wrapLucideIcon(Lucide.Hexagon)
+export const Highlighter = wrapLucideIcon(Lucide.Highlighter)
+export const History = wrapLucideIcon(Lucide.History)
+export const Home = wrapLucideIcon(Lucide.Home)
+export const Hop = wrapLucideIcon(Lucide.Hop)
+export const HopOff = wrapLucideIcon(Lucide.HopOff)
+export const Hospital = wrapLucideIcon(Lucide.Hospital)
+export const Hotel = wrapLucideIcon(Lucide.Hotel)
+export const Hourglass = wrapLucideIcon(Lucide.Hourglass)
+export const House = wrapLucideIcon(Lucide.House)
+export const HousePlug = wrapLucideIcon(Lucide.HousePlug)
+export const HousePlus = wrapLucideIcon(Lucide.HousePlus)
+export const IceCream = wrapLucideIcon(Lucide.IceCream)
+export const IceCream2 = wrapLucideIcon(Lucide.IceCream2)
+export const IceCreamBowl = wrapLucideIcon(Lucide.IceCreamBowl)
+export const IceCreamCone = wrapLucideIcon(Lucide.IceCreamCone)
+export const IdCard = wrapLucideIcon(Lucide.IdCard)
+export const Image = wrapLucideIcon(Lucide.Image)
+export const ImageDown = wrapLucideIcon(Lucide.ImageDown)
+export const ImageMinus = wrapLucideIcon(Lucide.ImageMinus)
+export const ImageOff = wrapLucideIcon(Lucide.ImageOff)
+export const ImagePlay = wrapLucideIcon(Lucide.ImagePlay)
+export const ImagePlus = wrapLucideIcon(Lucide.ImagePlus)
+export const ImageUp = wrapLucideIcon(Lucide.ImageUp)
+export const Images = wrapLucideIcon(Lucide.Images)
+export const Import = wrapLucideIcon(Lucide.Import)
+export const Inbox = wrapLucideIcon(Lucide.Inbox)
+export const Indent = wrapLucideIcon(Lucide.Indent)
+export const IndentDecrease = wrapLucideIcon(Lucide.IndentDecrease)
+export const IndentIncrease = wrapLucideIcon(Lucide.IndentIncrease)
+export const IndianRupee = wrapLucideIcon(Lucide.IndianRupee)
+// Renamed from 'Infinity' to avoid conflict with JavaScript built-in
+export const IconInfinity = wrapLucideIcon(Lucide.Infinity)
+export const Info = wrapLucideIcon(Lucide.Info)
+export const Inspect = wrapLucideIcon(Lucide.Inspect)
+export const InspectionPanel = wrapLucideIcon(Lucide.InspectionPanel)
+export const Instagram = wrapLucideIcon(Lucide.Instagram)
+export const Italic = wrapLucideIcon(Lucide.Italic)
+export const IterationCcw = wrapLucideIcon(Lucide.IterationCcw)
+export const IterationCw = wrapLucideIcon(Lucide.IterationCw)
+export const JapaneseYen = wrapLucideIcon(Lucide.JapaneseYen)
+export const Joystick = wrapLucideIcon(Lucide.Joystick)
+export const Kanban = wrapLucideIcon(Lucide.Kanban)
+export const KanbanSquare = wrapLucideIcon(Lucide.KanbanSquare)
+export const KanbanSquareDashed = wrapLucideIcon(Lucide.KanbanSquareDashed)
+export const Key = wrapLucideIcon(Lucide.Key)
+export const KeyRound = wrapLucideIcon(Lucide.KeyRound)
+export const KeySquare = wrapLucideIcon(Lucide.KeySquare)
+export const Keyboard = wrapLucideIcon(Lucide.Keyboard)
+export const KeyboardMusic = wrapLucideIcon(Lucide.KeyboardMusic)
+export const KeyboardOff = wrapLucideIcon(Lucide.KeyboardOff)
+export const Lamp = wrapLucideIcon(Lucide.Lamp)
+export const LampCeiling = wrapLucideIcon(Lucide.LampCeiling)
+export const LampDesk = wrapLucideIcon(Lucide.LampDesk)
+export const LampFloor = wrapLucideIcon(Lucide.LampFloor)
+export const LampWallDown = wrapLucideIcon(Lucide.LampWallDown)
+export const LampWallUp = wrapLucideIcon(Lucide.LampWallUp)
+export const LandPlot = wrapLucideIcon(Lucide.LandPlot)
+export const Landmark = wrapLucideIcon(Lucide.Landmark)
+export const Languages = wrapLucideIcon(Lucide.Languages)
+export const Laptop = wrapLucideIcon(Lucide.Laptop)
+export const Laptop2 = wrapLucideIcon(Lucide.Laptop2)
+export const LaptopMinimal = wrapLucideIcon(Lucide.LaptopMinimal)
+export const LaptopMinimalCheck = wrapLucideIcon(Lucide.LaptopMinimalCheck)
+export const Lasso = wrapLucideIcon(Lucide.Lasso)
+export const LassoSelect = wrapLucideIcon(Lucide.LassoSelect)
+export const Laugh = wrapLucideIcon(Lucide.Laugh)
+export const Layers = wrapLucideIcon(Lucide.Layers)
+export const Layers2 = wrapLucideIcon(Lucide.Layers2)
+export const Layers3 = wrapLucideIcon(Lucide.Layers3)
+export const Layout = wrapLucideIcon(Lucide.Layout)
+export const LayoutDashboard = wrapLucideIcon(Lucide.LayoutDashboard)
+export const LayoutGrid = wrapLucideIcon(Lucide.LayoutGrid)
+export const LayoutList = wrapLucideIcon(Lucide.LayoutList)
+export const LayoutPanelLeft = wrapLucideIcon(Lucide.LayoutPanelLeft)
+export const LayoutPanelTop = wrapLucideIcon(Lucide.LayoutPanelTop)
+export const LayoutTemplate = wrapLucideIcon(Lucide.LayoutTemplate)
+export const Leaf = wrapLucideIcon(Lucide.Leaf)
+export const LeafyGreen = wrapLucideIcon(Lucide.LeafyGreen)
+export const Lectern = wrapLucideIcon(Lucide.Lectern)
+export const LetterText = wrapLucideIcon(Lucide.LetterText)
+export const Library = wrapLucideIcon(Lucide.Library)
+export const LibraryBig = wrapLucideIcon(Lucide.LibraryBig)
+export const LibrarySquare = wrapLucideIcon(Lucide.LibrarySquare)
+export const LifeBuoy = wrapLucideIcon(Lucide.LifeBuoy)
+export const Ligature = wrapLucideIcon(Lucide.Ligature)
+export const Lightbulb = wrapLucideIcon(Lucide.Lightbulb)
+export const LightbulbOff = wrapLucideIcon(Lucide.LightbulbOff)
+export const LineChart = wrapLucideIcon(Lucide.LineChart)
+export const Link = wrapLucideIcon(Lucide.Link)
+export const Link2 = wrapLucideIcon(Lucide.Link2)
+export const Link2Off = wrapLucideIcon(Lucide.Link2Off)
+export const Linkedin = wrapLucideIcon(Lucide.Linkedin)
+export const List = wrapLucideIcon(Lucide.List)
+export const ListCheck = wrapLucideIcon(Lucide.ListCheck)
+export const ListChecks = wrapLucideIcon(Lucide.ListChecks)
+export const ListCollapse = wrapLucideIcon(Lucide.ListCollapse)
+export const ListEnd = wrapLucideIcon(Lucide.ListEnd)
+export const ListFilter = wrapLucideIcon(Lucide.ListFilter)
+export const ListMinus = wrapLucideIcon(Lucide.ListMinus)
+export const ListMusic = wrapLucideIcon(Lucide.ListMusic)
+export const ListOrdered = wrapLucideIcon(Lucide.ListOrdered)
+export const ListPlus = wrapLucideIcon(Lucide.ListPlus)
+export const ListRestart = wrapLucideIcon(Lucide.ListRestart)
+export const ListStart = wrapLucideIcon(Lucide.ListStart)
+export const ListTodo = wrapLucideIcon(Lucide.ListTodo)
+export const ListTree = wrapLucideIcon(Lucide.ListTree)
+export const ListVideo = wrapLucideIcon(Lucide.ListVideo)
+export const ListX = wrapLucideIcon(Lucide.ListX)
+export const Loader = wrapLucideIcon(Lucide.Loader)
+export const Loader2 = wrapLucideIcon(Lucide.Loader2)
+export const LoaderCircle = wrapLucideIcon(Lucide.LoaderCircle)
+export const LoaderPinwheel = wrapLucideIcon(Lucide.LoaderPinwheel)
+export const Locate = wrapLucideIcon(Lucide.Locate)
+export const LocateFixed = wrapLucideIcon(Lucide.LocateFixed)
+export const LocateOff = wrapLucideIcon(Lucide.LocateOff)
+export const Lock = wrapLucideIcon(Lucide.Lock)
+export const LockKeyhole = wrapLucideIcon(Lucide.LockKeyhole)
+export const LockKeyholeOpen = wrapLucideIcon(Lucide.LockKeyholeOpen)
+export const LockOpen = wrapLucideIcon(Lucide.LockOpen)
+export const LogIn = wrapLucideIcon(Lucide.LogIn)
+export const LogOut = wrapLucideIcon(Lucide.LogOut)
+export const Logs = wrapLucideIcon(Lucide.Logs)
+export const Lollipop = wrapLucideIcon(Lucide.Lollipop)
+export const Luggage = wrapLucideIcon(Lucide.Luggage)
+export const MSquare = wrapLucideIcon(Lucide.MSquare)
+export const Magnet = wrapLucideIcon(Lucide.Magnet)
+export const Mail = wrapLucideIcon(Lucide.Mail)
+export const MailCheck = wrapLucideIcon(Lucide.MailCheck)
+export const MailMinus = wrapLucideIcon(Lucide.MailMinus)
+export const MailOpen = wrapLucideIcon(Lucide.MailOpen)
+export const MailPlus = wrapLucideIcon(Lucide.MailPlus)
+export const MailQuestion = wrapLucideIcon(Lucide.MailQuestion)
+export const MailSearch = wrapLucideIcon(Lucide.MailSearch)
+export const MailWarning = wrapLucideIcon(Lucide.MailWarning)
+export const MailX = wrapLucideIcon(Lucide.MailX)
+export const Mailbox = wrapLucideIcon(Lucide.Mailbox)
+export const Mails = wrapLucideIcon(Lucide.Mails)
+// Renamed from 'Map' to avoid conflict with JavaScript built-in
+export const IconMap = wrapLucideIcon(Lucide.Map)
+export const MapPin = wrapLucideIcon(Lucide.MapPin)
+export const MapPinCheck = wrapLucideIcon(Lucide.MapPinCheck)
+export const MapPinCheckInside = wrapLucideIcon(Lucide.MapPinCheckInside)
+export const MapPinHouse = wrapLucideIcon(Lucide.MapPinHouse)
+export const MapPinMinus = wrapLucideIcon(Lucide.MapPinMinus)
+export const MapPinMinusInside = wrapLucideIcon(Lucide.MapPinMinusInside)
+export const MapPinOff = wrapLucideIcon(Lucide.MapPinOff)
+export const MapPinPlus = wrapLucideIcon(Lucide.MapPinPlus)
+export const MapPinPlusInside = wrapLucideIcon(Lucide.MapPinPlusInside)
+export const MapPinX = wrapLucideIcon(Lucide.MapPinX)
+export const MapPinXInside = wrapLucideIcon(Lucide.MapPinXInside)
+export const MapPinned = wrapLucideIcon(Lucide.MapPinned)
+export const Martini = wrapLucideIcon(Lucide.Martini)
+export const Maximize = wrapLucideIcon(Lucide.Maximize)
+export const Maximize2 = wrapLucideIcon(Lucide.Maximize2)
+export const Medal = wrapLucideIcon(Lucide.Medal)
+export const Megaphone = wrapLucideIcon(Lucide.Megaphone)
+export const MegaphoneOff = wrapLucideIcon(Lucide.MegaphoneOff)
+export const Meh = wrapLucideIcon(Lucide.Meh)
+export const MemoryStick = wrapLucideIcon(Lucide.MemoryStick)
+export const Menu = wrapLucideIcon(Lucide.Menu)
+export const MenuSquare = wrapLucideIcon(Lucide.MenuSquare)
+export const Merge = wrapLucideIcon(Lucide.Merge)
+export const MessageCircle = wrapLucideIcon(Lucide.MessageCircle)
+export const MessageCircleCode = wrapLucideIcon(Lucide.MessageCircleCode)
+export const MessageCircleDashed = wrapLucideIcon(Lucide.MessageCircleDashed)
+export const MessageCircleHeart = wrapLucideIcon(Lucide.MessageCircleHeart)
+export const MessageCircleMore = wrapLucideIcon(Lucide.MessageCircleMore)
+export const MessageCircleOff = wrapLucideIcon(Lucide.MessageCircleOff)
+export const MessageCirclePlus = wrapLucideIcon(Lucide.MessageCirclePlus)
+export const MessageCircleQuestion = wrapLucideIcon(
+  Lucide.MessageCircleQuestion
+)
+export const MessageCircleReply = wrapLucideIcon(Lucide.MessageCircleReply)
+export const MessageCircleWarning = wrapLucideIcon(Lucide.MessageCircleWarning)
+export const MessageCircleX = wrapLucideIcon(Lucide.MessageCircleX)
+export const MessageSquare = wrapLucideIcon(Lucide.MessageSquare)
+export const MessageSquareCode = wrapLucideIcon(Lucide.MessageSquareCode)
+export const MessageSquareDashed = wrapLucideIcon(Lucide.MessageSquareDashed)
+export const MessageSquareDiff = wrapLucideIcon(Lucide.MessageSquareDiff)
+export const MessageSquareDot = wrapLucideIcon(Lucide.MessageSquareDot)
+export const MessageSquareHeart = wrapLucideIcon(Lucide.MessageSquareHeart)
+export const MessageSquareLock = wrapLucideIcon(Lucide.MessageSquareLock)
+export const MessageSquareMore = wrapLucideIcon(Lucide.MessageSquareMore)
+export const MessageSquareOff = wrapLucideIcon(Lucide.MessageSquareOff)
+export const MessageSquarePlus = wrapLucideIcon(Lucide.MessageSquarePlus)
+export const MessageSquareQuote = wrapLucideIcon(Lucide.MessageSquareQuote)
+export const MessageSquareReply = wrapLucideIcon(Lucide.MessageSquareReply)
+export const MessageSquareShare = wrapLucideIcon(Lucide.MessageSquareShare)
+export const MessageSquareText = wrapLucideIcon(Lucide.MessageSquareText)
+export const MessageSquareWarning = wrapLucideIcon(Lucide.MessageSquareWarning)
+export const MessageSquareX = wrapLucideIcon(Lucide.MessageSquareX)
+export const MessagesSquare = wrapLucideIcon(Lucide.MessagesSquare)
+export const Mic = wrapLucideIcon(Lucide.Mic)
+export const Mic2 = wrapLucideIcon(Lucide.Mic2)
+export const MicOff = wrapLucideIcon(Lucide.MicOff)
+export const MicVocal = wrapLucideIcon(Lucide.MicVocal)
+export const Microchip = wrapLucideIcon(Lucide.Microchip)
+export const Microscope = wrapLucideIcon(Lucide.Microscope)
+export const Microwave = wrapLucideIcon(Lucide.Microwave)
+export const Milestone = wrapLucideIcon(Lucide.Milestone)
+export const Milk = wrapLucideIcon(Lucide.Milk)
+export const MilkOff = wrapLucideIcon(Lucide.MilkOff)
+export const Minimize = wrapLucideIcon(Lucide.Minimize)
+export const Minimize2 = wrapLucideIcon(Lucide.Minimize2)
+export const Minus = wrapLucideIcon(Lucide.Minus)
+export const MinusCircle = wrapLucideIcon(Lucide.MinusCircle)
+export const MinusSquare = wrapLucideIcon(Lucide.MinusSquare)
+export const Monitor = wrapLucideIcon(Lucide.Monitor)
+export const MonitorCheck = wrapLucideIcon(Lucide.MonitorCheck)
+export const MonitorCog = wrapLucideIcon(Lucide.MonitorCog)
+export const MonitorDot = wrapLucideIcon(Lucide.MonitorDot)
+export const MonitorDown = wrapLucideIcon(Lucide.MonitorDown)
+export const MonitorOff = wrapLucideIcon(Lucide.MonitorOff)
+export const MonitorPause = wrapLucideIcon(Lucide.MonitorPause)
+export const MonitorPlay = wrapLucideIcon(Lucide.MonitorPlay)
+export const MonitorSmartphone = wrapLucideIcon(Lucide.MonitorSmartphone)
+export const MonitorSpeaker = wrapLucideIcon(Lucide.MonitorSpeaker)
+export const MonitorStop = wrapLucideIcon(Lucide.MonitorStop)
+export const MonitorUp = wrapLucideIcon(Lucide.MonitorUp)
+export const MonitorX = wrapLucideIcon(Lucide.MonitorX)
+export const Moon = wrapLucideIcon(Lucide.Moon)
+export const MoonStar = wrapLucideIcon(Lucide.MoonStar)
+export const MoreHorizontal = wrapLucideIcon(Lucide.MoreHorizontal)
+export const MoreVertical = wrapLucideIcon(Lucide.MoreVertical)
+export const Mountain = wrapLucideIcon(Lucide.Mountain)
+export const MountainSnow = wrapLucideIcon(Lucide.MountainSnow)
+export const Mouse = wrapLucideIcon(Lucide.Mouse)
+export const MouseOff = wrapLucideIcon(Lucide.MouseOff)
+export const MousePointer = wrapLucideIcon(Lucide.MousePointer)
+export const MousePointer2 = wrapLucideIcon(Lucide.MousePointer2)
+export const MousePointerBan = wrapLucideIcon(Lucide.MousePointerBan)
+export const MousePointerClick = wrapLucideIcon(Lucide.MousePointerClick)
+export const MousePointerSquareDashed = wrapLucideIcon(
+  Lucide.MousePointerSquareDashed
+)
+export const Move = wrapLucideIcon(Lucide.Move)
+export const Move3D = wrapLucideIcon(Lucide.Move3D)
+export const Move3d = wrapLucideIcon(Lucide.Move3d)
+export const MoveDiagonal = wrapLucideIcon(Lucide.MoveDiagonal)
+export const MoveDiagonal2 = wrapLucideIcon(Lucide.MoveDiagonal2)
+export const MoveDown = wrapLucideIcon(Lucide.MoveDown)
+export const MoveDownLeft = wrapLucideIcon(Lucide.MoveDownLeft)
+export const MoveDownRight = wrapLucideIcon(Lucide.MoveDownRight)
+export const MoveHorizontal = wrapLucideIcon(Lucide.MoveHorizontal)
+export const MoveLeft = wrapLucideIcon(Lucide.MoveLeft)
+export const MoveRight = wrapLucideIcon(Lucide.MoveRight)
+export const MoveUp = wrapLucideIcon(Lucide.MoveUp)
+export const MoveUpLeft = wrapLucideIcon(Lucide.MoveUpLeft)
+export const MoveUpRight = wrapLucideIcon(Lucide.MoveUpRight)
+export const MoveVertical = wrapLucideIcon(Lucide.MoveVertical)
+export const Music = wrapLucideIcon(Lucide.Music)
+export const Music2 = wrapLucideIcon(Lucide.Music2)
+export const Music3 = wrapLucideIcon(Lucide.Music3)
+export const Music4 = wrapLucideIcon(Lucide.Music4)
+export const Navigation = wrapLucideIcon(Lucide.Navigation)
+export const Navigation2 = wrapLucideIcon(Lucide.Navigation2)
+export const Navigation2Off = wrapLucideIcon(Lucide.Navigation2Off)
+export const NavigationOff = wrapLucideIcon(Lucide.NavigationOff)
+export const Network = wrapLucideIcon(Lucide.Network)
+export const Newspaper = wrapLucideIcon(Lucide.Newspaper)
+export const Nfc = wrapLucideIcon(Lucide.Nfc)
+export const Notebook = wrapLucideIcon(Lucide.Notebook)
+export const NotebookPen = wrapLucideIcon(Lucide.NotebookPen)
+export const NotebookTabs = wrapLucideIcon(Lucide.NotebookTabs)
+export const NotebookText = wrapLucideIcon(Lucide.NotebookText)
+export const NotepadText = wrapLucideIcon(Lucide.NotepadText)
+export const NotepadTextDashed = wrapLucideIcon(Lucide.NotepadTextDashed)
+export const Nut = wrapLucideIcon(Lucide.Nut)
+export const NutOff = wrapLucideIcon(Lucide.NutOff)
+export const Octagon = wrapLucideIcon(Lucide.Octagon)
+export const OctagonAlert = wrapLucideIcon(Lucide.OctagonAlert)
+export const OctagonMinus = wrapLucideIcon(Lucide.OctagonMinus)
+export const OctagonPause = wrapLucideIcon(Lucide.OctagonPause)
+export const OctagonX = wrapLucideIcon(Lucide.OctagonX)
+export const Omega = wrapLucideIcon(Lucide.Omega)
+export const Option = wrapLucideIcon(Lucide.Option)
+export const Orbit = wrapLucideIcon(Lucide.Orbit)
+export const Origami = wrapLucideIcon(Lucide.Origami)
+export const Outdent = wrapLucideIcon(Lucide.Outdent)
+export const Package = wrapLucideIcon(Lucide.Package)
+export const Package2 = wrapLucideIcon(Lucide.Package2)
+export const PackageCheck = wrapLucideIcon(Lucide.PackageCheck)
+export const PackageMinus = wrapLucideIcon(Lucide.PackageMinus)
+export const PackageOpen = wrapLucideIcon(Lucide.PackageOpen)
+export const PackagePlus = wrapLucideIcon(Lucide.PackagePlus)
+export const PackageSearch = wrapLucideIcon(Lucide.PackageSearch)
+export const PackageX = wrapLucideIcon(Lucide.PackageX)
+export const PaintBucket = wrapLucideIcon(Lucide.PaintBucket)
+export const PaintRoller = wrapLucideIcon(Lucide.PaintRoller)
+export const Paintbrush = wrapLucideIcon(Lucide.Paintbrush)
+export const Paintbrush2 = wrapLucideIcon(Lucide.Paintbrush2)
+export const PaintbrushVertical = wrapLucideIcon(Lucide.PaintbrushVertical)
+export const Palette = wrapLucideIcon(Lucide.Palette)
+export const Palmtree = wrapLucideIcon(Lucide.Palmtree)
+export const PanelBottom = wrapLucideIcon(Lucide.PanelBottom)
+export const PanelBottomClose = wrapLucideIcon(Lucide.PanelBottomClose)
+export const PanelBottomDashed = wrapLucideIcon(Lucide.PanelBottomDashed)
+export const PanelBottomInactive = wrapLucideIcon(Lucide.PanelBottomInactive)
+export const PanelBottomOpen = wrapLucideIcon(Lucide.PanelBottomOpen)
+export const PanelLeft = wrapLucideIcon(Lucide.PanelLeft)
+export const PanelLeftClose = wrapLucideIcon(Lucide.PanelLeftClose)
+export const PanelLeftDashed = wrapLucideIcon(Lucide.PanelLeftDashed)
+export const PanelLeftInactive = wrapLucideIcon(Lucide.PanelLeftInactive)
+export const PanelLeftOpen = wrapLucideIcon(Lucide.PanelLeftOpen)
+export const PanelRight = wrapLucideIcon(Lucide.PanelRight)
+export const PanelRightClose = wrapLucideIcon(Lucide.PanelRightClose)
+export const PanelRightDashed = wrapLucideIcon(Lucide.PanelRightDashed)
+export const PanelRightInactive = wrapLucideIcon(Lucide.PanelRightInactive)
+export const PanelRightOpen = wrapLucideIcon(Lucide.PanelRightOpen)
+export const PanelTop = wrapLucideIcon(Lucide.PanelTop)
+export const PanelTopClose = wrapLucideIcon(Lucide.PanelTopClose)
+export const PanelTopDashed = wrapLucideIcon(Lucide.PanelTopDashed)
+export const PanelTopInactive = wrapLucideIcon(Lucide.PanelTopInactive)
+export const PanelTopOpen = wrapLucideIcon(Lucide.PanelTopOpen)
+export const PanelsLeftBottom = wrapLucideIcon(Lucide.PanelsLeftBottom)
+export const PanelsLeftRight = wrapLucideIcon(Lucide.PanelsLeftRight)
+export const PanelsRightBottom = wrapLucideIcon(Lucide.PanelsRightBottom)
+export const PanelsTopBottom = wrapLucideIcon(Lucide.PanelsTopBottom)
+export const PanelsTopLeft = wrapLucideIcon(Lucide.PanelsTopLeft)
+export const Paperclip = wrapLucideIcon(Lucide.Paperclip)
+export const Parentheses = wrapLucideIcon(Lucide.Parentheses)
+export const ParkingCircle = wrapLucideIcon(Lucide.ParkingCircle)
+export const ParkingCircleOff = wrapLucideIcon(Lucide.ParkingCircleOff)
+export const ParkingMeter = wrapLucideIcon(Lucide.ParkingMeter)
+export const ParkingSquare = wrapLucideIcon(Lucide.ParkingSquare)
+export const ParkingSquareOff = wrapLucideIcon(Lucide.ParkingSquareOff)
+export const PartyPopper = wrapLucideIcon(Lucide.PartyPopper)
+export const Pause = wrapLucideIcon(Lucide.Pause)
+export const PauseCircle = wrapLucideIcon(Lucide.PauseCircle)
+export const PauseOctagon = wrapLucideIcon(Lucide.PauseOctagon)
+export const PawPrint = wrapLucideIcon(Lucide.PawPrint)
+export const PcCase = wrapLucideIcon(Lucide.PcCase)
+export const Pen = wrapLucideIcon(Lucide.Pen)
+export const PenBox = wrapLucideIcon(Lucide.PenBox)
+export const PenLine = wrapLucideIcon(Lucide.PenLine)
+export const PenOff = wrapLucideIcon(Lucide.PenOff)
+export const PenSquare = wrapLucideIcon(Lucide.PenSquare)
+export const PenTool = wrapLucideIcon(Lucide.PenTool)
+export const Pencil = wrapLucideIcon(Lucide.Pencil)
+export const PencilLine = wrapLucideIcon(Lucide.PencilLine)
+export const PencilOff = wrapLucideIcon(Lucide.PencilOff)
+export const PencilRuler = wrapLucideIcon(Lucide.PencilRuler)
+export const Pentagon = wrapLucideIcon(Lucide.Pentagon)
+export const Percent = wrapLucideIcon(Lucide.Percent)
+export const PercentCircle = wrapLucideIcon(Lucide.PercentCircle)
+export const PercentDiamond = wrapLucideIcon(Lucide.PercentDiamond)
+export const PercentSquare = wrapLucideIcon(Lucide.PercentSquare)
+export const PersonStanding = wrapLucideIcon(Lucide.PersonStanding)
+export const PhilippinePeso = wrapLucideIcon(Lucide.PhilippinePeso)
+export const Phone = wrapLucideIcon(Lucide.Phone)
+export const PhoneCall = wrapLucideIcon(Lucide.PhoneCall)
+export const PhoneForwarded = wrapLucideIcon(Lucide.PhoneForwarded)
+export const PhoneIncoming = wrapLucideIcon(Lucide.PhoneIncoming)
+export const PhoneMissed = wrapLucideIcon(Lucide.PhoneMissed)
+export const PhoneOff = wrapLucideIcon(Lucide.PhoneOff)
+export const PhoneOutgoing = wrapLucideIcon(Lucide.PhoneOutgoing)
+export const Pi = wrapLucideIcon(Lucide.Pi)
+export const PiSquare = wrapLucideIcon(Lucide.PiSquare)
+export const Piano = wrapLucideIcon(Lucide.Piano)
+export const Pickaxe = wrapLucideIcon(Lucide.Pickaxe)
+export const PictureInPicture = wrapLucideIcon(Lucide.PictureInPicture)
+export const PictureInPicture2 = wrapLucideIcon(Lucide.PictureInPicture2)
+export const PieChart = wrapLucideIcon(Lucide.PieChart)
+export const PiggyBank = wrapLucideIcon(Lucide.PiggyBank)
+export const Pilcrow = wrapLucideIcon(Lucide.Pilcrow)
+export const PilcrowLeft = wrapLucideIcon(Lucide.PilcrowLeft)
+export const PilcrowRight = wrapLucideIcon(Lucide.PilcrowRight)
+export const PilcrowSquare = wrapLucideIcon(Lucide.PilcrowSquare)
+export const Pill = wrapLucideIcon(Lucide.Pill)
+export const PillBottle = wrapLucideIcon(Lucide.PillBottle)
+export const Pin = wrapLucideIcon(Lucide.Pin)
+export const PinOff = wrapLucideIcon(Lucide.PinOff)
+export const Pipette = wrapLucideIcon(Lucide.Pipette)
+export const Pizza = wrapLucideIcon(Lucide.Pizza)
+export const Plane = wrapLucideIcon(Lucide.Plane)
+export const PlaneLanding = wrapLucideIcon(Lucide.PlaneLanding)
+export const PlaneTakeoff = wrapLucideIcon(Lucide.PlaneTakeoff)
+export const Play = wrapLucideIcon(Lucide.Play)
+export const PlayCircle = wrapLucideIcon(Lucide.PlayCircle)
+export const PlaySquare = wrapLucideIcon(Lucide.PlaySquare)
+export const Plug = wrapLucideIcon(Lucide.Plug)
+export const Plug2 = wrapLucideIcon(Lucide.Plug2)
+export const PlugZap = wrapLucideIcon(Lucide.PlugZap)
+export const PlugZap2 = wrapLucideIcon(Lucide.PlugZap2)
+export const Plus = wrapLucideIcon(Lucide.Plus)
+export const PlusCircle = wrapLucideIcon(Lucide.PlusCircle)
+export const PlusSquare = wrapLucideIcon(Lucide.PlusSquare)
+export const Pocket = wrapLucideIcon(Lucide.Pocket)
+export const PocketKnife = wrapLucideIcon(Lucide.PocketKnife)
+export const Podcast = wrapLucideIcon(Lucide.Podcast)
+export const Pointer = wrapLucideIcon(Lucide.Pointer)
+export const PointerOff = wrapLucideIcon(Lucide.PointerOff)
+export const Popcorn = wrapLucideIcon(Lucide.Popcorn)
+export const Popsicle = wrapLucideIcon(Lucide.Popsicle)
+export const PoundSterling = wrapLucideIcon(Lucide.PoundSterling)
+export const Power = wrapLucideIcon(Lucide.Power)
+export const PowerCircle = wrapLucideIcon(Lucide.PowerCircle)
+export const PowerOff = wrapLucideIcon(Lucide.PowerOff)
+export const PowerSquare = wrapLucideIcon(Lucide.PowerSquare)
+export const Presentation = wrapLucideIcon(Lucide.Presentation)
+export const Printer = wrapLucideIcon(Lucide.Printer)
+export const PrinterCheck = wrapLucideIcon(Lucide.PrinterCheck)
+export const Projector = wrapLucideIcon(Lucide.Projector)
+export const Proportions = wrapLucideIcon(Lucide.Proportions)
+export const Puzzle = wrapLucideIcon(Lucide.Puzzle)
+export const Pyramid = wrapLucideIcon(Lucide.Pyramid)
+export const QrCode = wrapLucideIcon(Lucide.QrCode)
+export const Quote = wrapLucideIcon(Lucide.Quote)
+export const Rabbit = wrapLucideIcon(Lucide.Rabbit)
+export const Radar = wrapLucideIcon(Lucide.Radar)
+export const Radiation = wrapLucideIcon(Lucide.Radiation)
+export const Radical = wrapLucideIcon(Lucide.Radical)
+export const Radio = wrapLucideIcon(Lucide.Radio)
+export const RadioReceiver = wrapLucideIcon(Lucide.RadioReceiver)
+export const RadioTower = wrapLucideIcon(Lucide.RadioTower)
+export const Radius = wrapLucideIcon(Lucide.Radius)
+export const RailSymbol = wrapLucideIcon(Lucide.RailSymbol)
+export const Rainbow = wrapLucideIcon(Lucide.Rainbow)
+export const Rat = wrapLucideIcon(Lucide.Rat)
+export const Ratio = wrapLucideIcon(Lucide.Ratio)
+export const Receipt = wrapLucideIcon(Lucide.Receipt)
+export const ReceiptCent = wrapLucideIcon(Lucide.ReceiptCent)
+export const ReceiptEuro = wrapLucideIcon(Lucide.ReceiptEuro)
+export const ReceiptIndianRupee = wrapLucideIcon(Lucide.ReceiptIndianRupee)
+export const ReceiptJapaneseYen = wrapLucideIcon(Lucide.ReceiptJapaneseYen)
+export const ReceiptPoundSterling = wrapLucideIcon(Lucide.ReceiptPoundSterling)
+export const ReceiptRussianRuble = wrapLucideIcon(Lucide.ReceiptRussianRuble)
+export const ReceiptSwissFranc = wrapLucideIcon(Lucide.ReceiptSwissFranc)
+export const ReceiptText = wrapLucideIcon(Lucide.ReceiptText)
+export const RectangleEllipsis = wrapLucideIcon(Lucide.RectangleEllipsis)
+export const RectangleHorizontal = wrapLucideIcon(Lucide.RectangleHorizontal)
+export const RectangleVertical = wrapLucideIcon(Lucide.RectangleVertical)
+export const Recycle = wrapLucideIcon(Lucide.Recycle)
+export const Redo = wrapLucideIcon(Lucide.Redo)
+export const Redo2 = wrapLucideIcon(Lucide.Redo2)
+export const RedoDot = wrapLucideIcon(Lucide.RedoDot)
+export const RefreshCcw = wrapLucideIcon(Lucide.RefreshCcw)
+export const RefreshCcwDot = wrapLucideIcon(Lucide.RefreshCcwDot)
+export const RefreshCw = wrapLucideIcon(Lucide.RefreshCw)
+export const RefreshCwOff = wrapLucideIcon(Lucide.RefreshCwOff)
+export const Refrigerator = wrapLucideIcon(Lucide.Refrigerator)
+export const Regex = wrapLucideIcon(Lucide.Regex)
+export const RemoveFormatting = wrapLucideIcon(Lucide.RemoveFormatting)
+export const Repeat = wrapLucideIcon(Lucide.Repeat)
+export const Repeat1 = wrapLucideIcon(Lucide.Repeat1)
+export const Repeat2 = wrapLucideIcon(Lucide.Repeat2)
+export const Replace = wrapLucideIcon(Lucide.Replace)
+export const ReplaceAll = wrapLucideIcon(Lucide.ReplaceAll)
+export const Reply = wrapLucideIcon(Lucide.Reply)
+export const ReplyAll = wrapLucideIcon(Lucide.ReplyAll)
+export const Rewind = wrapLucideIcon(Lucide.Rewind)
+export const Ribbon = wrapLucideIcon(Lucide.Ribbon)
+export const Rocket = wrapLucideIcon(Lucide.Rocket)
+export const RockingChair = wrapLucideIcon(Lucide.RockingChair)
+export const RollerCoaster = wrapLucideIcon(Lucide.RollerCoaster)
+export const Rotate3D = wrapLucideIcon(Lucide.Rotate3D)
+export const Rotate3d = wrapLucideIcon(Lucide.Rotate3d)
+export const RotateCcw = wrapLucideIcon(Lucide.RotateCcw)
+export const RotateCcwSquare = wrapLucideIcon(Lucide.RotateCcwSquare)
+export const RotateCw = wrapLucideIcon(Lucide.RotateCw)
+export const RotateCwSquare = wrapLucideIcon(Lucide.RotateCwSquare)
+export const Route = wrapLucideIcon(Lucide.Route)
+export const RouteOff = wrapLucideIcon(Lucide.RouteOff)
+export const Router = wrapLucideIcon(Lucide.Router)
+export const Rows = wrapLucideIcon(Lucide.Rows)
+export const Rows2 = wrapLucideIcon(Lucide.Rows2)
+export const Rows3 = wrapLucideIcon(Lucide.Rows3)
+export const Rows4 = wrapLucideIcon(Lucide.Rows4)
+export const Rss = wrapLucideIcon(Lucide.Rss)
+export const Ruler = wrapLucideIcon(Lucide.Ruler)
+export const RussianRuble = wrapLucideIcon(Lucide.RussianRuble)
+export const Sailboat = wrapLucideIcon(Lucide.Sailboat)
+export const Salad = wrapLucideIcon(Lucide.Salad)
+export const Sandwich = wrapLucideIcon(Lucide.Sandwich)
+export const Satellite = wrapLucideIcon(Lucide.Satellite)
+export const SatelliteDish = wrapLucideIcon(Lucide.SatelliteDish)
+export const Save = wrapLucideIcon(Lucide.Save)
+export const SaveAll = wrapLucideIcon(Lucide.SaveAll)
+export const SaveOff = wrapLucideIcon(Lucide.SaveOff)
+export const Scale = wrapLucideIcon(Lucide.Scale)
+export const Scale3D = wrapLucideIcon(Lucide.Scale3D)
+export const Scale3d = wrapLucideIcon(Lucide.Scale3d)
+export const Scaling = wrapLucideIcon(Lucide.Scaling)
+export const Scan = wrapLucideIcon(Lucide.Scan)
+export const ScanBarcode = wrapLucideIcon(Lucide.ScanBarcode)
+export const ScanEye = wrapLucideIcon(Lucide.ScanEye)
+export const ScanFace = wrapLucideIcon(Lucide.ScanFace)
+export const ScanLine = wrapLucideIcon(Lucide.ScanLine)
+export const ScanQrCode = wrapLucideIcon(Lucide.ScanQrCode)
+export const ScanSearch = wrapLucideIcon(Lucide.ScanSearch)
+export const ScanText = wrapLucideIcon(Lucide.ScanText)
+export const ScatterChart = wrapLucideIcon(Lucide.ScatterChart)
+export const School = wrapLucideIcon(Lucide.School)
+export const School2 = wrapLucideIcon(Lucide.School2)
+export const Scissors = wrapLucideIcon(Lucide.Scissors)
+export const ScissorsLineDashed = wrapLucideIcon(Lucide.ScissorsLineDashed)
+export const ScissorsSquare = wrapLucideIcon(Lucide.ScissorsSquare)
+export const ScissorsSquareDashedBottom = wrapLucideIcon(
+  Lucide.ScissorsSquareDashedBottom
+)
+export const ScreenShare = wrapLucideIcon(Lucide.ScreenShare)
+export const ScreenShareOff = wrapLucideIcon(Lucide.ScreenShareOff)
+export const Scroll = wrapLucideIcon(Lucide.Scroll)
+export const ScrollText = wrapLucideIcon(Lucide.ScrollText)
+export const Search = wrapLucideIcon(Lucide.Search)
+export const SearchCheck = wrapLucideIcon(Lucide.SearchCheck)
+export const SearchCode = wrapLucideIcon(Lucide.SearchCode)
+export const SearchSlash = wrapLucideIcon(Lucide.SearchSlash)
+export const SearchX = wrapLucideIcon(Lucide.SearchX)
+export const Section = wrapLucideIcon(Lucide.Section)
+export const Send = wrapLucideIcon(Lucide.Send)
+export const SendHorizonal = wrapLucideIcon(Lucide.SendHorizonal)
+export const SendHorizontal = wrapLucideIcon(Lucide.SendHorizontal)
+export const SendToBack = wrapLucideIcon(Lucide.SendToBack)
+export const SeparatorHorizontal = wrapLucideIcon(Lucide.SeparatorHorizontal)
+export const SeparatorVertical = wrapLucideIcon(Lucide.SeparatorVertical)
+export const Server = wrapLucideIcon(Lucide.Server)
+export const ServerCog = wrapLucideIcon(Lucide.ServerCog)
+export const ServerCrash = wrapLucideIcon(Lucide.ServerCrash)
+export const ServerOff = wrapLucideIcon(Lucide.ServerOff)
+export const Settings = wrapLucideIcon(Lucide.Settings)
+export const Settings2 = wrapLucideIcon(Lucide.Settings2)
+export const Shapes = wrapLucideIcon(Lucide.Shapes)
+export const Share = wrapLucideIcon(Lucide.Share)
+export const Share2 = wrapLucideIcon(Lucide.Share2)
+export const Sheet = wrapLucideIcon(Lucide.Sheet)
+export const Shell = wrapLucideIcon(Lucide.Shell)
+export const Shield = wrapLucideIcon(Lucide.Shield)
+export const ShieldAlert = wrapLucideIcon(Lucide.ShieldAlert)
+export const ShieldBan = wrapLucideIcon(Lucide.ShieldBan)
+export const ShieldCheck = wrapLucideIcon(Lucide.ShieldCheck)
+export const ShieldClose = wrapLucideIcon(Lucide.ShieldClose)
+export const ShieldEllipsis = wrapLucideIcon(Lucide.ShieldEllipsis)
+export const ShieldHalf = wrapLucideIcon(Lucide.ShieldHalf)
+export const ShieldMinus = wrapLucideIcon(Lucide.ShieldMinus)
+export const ShieldOff = wrapLucideIcon(Lucide.ShieldOff)
+export const ShieldPlus = wrapLucideIcon(Lucide.ShieldPlus)
+export const ShieldQuestion = wrapLucideIcon(Lucide.ShieldQuestion)
+export const ShieldX = wrapLucideIcon(Lucide.ShieldX)
+export const Ship = wrapLucideIcon(Lucide.Ship)
+export const ShipWheel = wrapLucideIcon(Lucide.ShipWheel)
+export const Shirt = wrapLucideIcon(Lucide.Shirt)
+export const ShoppingBag = wrapLucideIcon(Lucide.ShoppingBag)
+export const ShoppingBasket = wrapLucideIcon(Lucide.ShoppingBasket)
+export const ShoppingCart = wrapLucideIcon(Lucide.ShoppingCart)
+export const Shovel = wrapLucideIcon(Lucide.Shovel)
+export const ShowerHead = wrapLucideIcon(Lucide.ShowerHead)
+export const Shrink = wrapLucideIcon(Lucide.Shrink)
+export const Shrub = wrapLucideIcon(Lucide.Shrub)
+export const Shuffle = wrapLucideIcon(Lucide.Shuffle)
+export const Sidebar = wrapLucideIcon(Lucide.Sidebar)
+export const SidebarClose = wrapLucideIcon(Lucide.SidebarClose)
+export const SidebarOpen = wrapLucideIcon(Lucide.SidebarOpen)
+export const Sigma = wrapLucideIcon(Lucide.Sigma)
+export const SigmaSquare = wrapLucideIcon(Lucide.SigmaSquare)
+export const Signal = wrapLucideIcon(Lucide.Signal)
+export const SignalHigh = wrapLucideIcon(Lucide.SignalHigh)
+export const SignalLow = wrapLucideIcon(Lucide.SignalLow)
+export const SignalMedium = wrapLucideIcon(Lucide.SignalMedium)
+export const SignalZero = wrapLucideIcon(Lucide.SignalZero)
+export const Signature = wrapLucideIcon(Lucide.Signature)
+export const Signpost = wrapLucideIcon(Lucide.Signpost)
+export const SignpostBig = wrapLucideIcon(Lucide.SignpostBig)
+export const Siren = wrapLucideIcon(Lucide.Siren)
+export const SkipBack = wrapLucideIcon(Lucide.SkipBack)
+export const SkipForward = wrapLucideIcon(Lucide.SkipForward)
+export const Skull = wrapLucideIcon(Lucide.Skull)
+export const Slack = wrapLucideIcon(Lucide.Slack)
+export const Slash = wrapLucideIcon(Lucide.Slash)
+export const SlashSquare = wrapLucideIcon(Lucide.SlashSquare)
+export const Slice = wrapLucideIcon(Lucide.Slice)
+export const Sliders = wrapLucideIcon(Lucide.Sliders)
+export const SlidersHorizontal = wrapLucideIcon(Lucide.SlidersHorizontal)
+export const SlidersVertical = wrapLucideIcon(Lucide.SlidersVertical)
+export const Smartphone = wrapLucideIcon(Lucide.Smartphone)
+export const SmartphoneCharging = wrapLucideIcon(Lucide.SmartphoneCharging)
+export const SmartphoneNfc = wrapLucideIcon(Lucide.SmartphoneNfc)
+export const Smile = wrapLucideIcon(Lucide.Smile)
+export const SmilePlus = wrapLucideIcon(Lucide.SmilePlus)
+export const Snail = wrapLucideIcon(Lucide.Snail)
+export const Snowflake = wrapLucideIcon(Lucide.Snowflake)
+export const Sofa = wrapLucideIcon(Lucide.Sofa)
+export const SortAsc = wrapLucideIcon(Lucide.SortAsc)
+export const SortDesc = wrapLucideIcon(Lucide.SortDesc)
+export const Soup = wrapLucideIcon(Lucide.Soup)
+export const Space = wrapLucideIcon(Lucide.Space)
+export const Spade = wrapLucideIcon(Lucide.Spade)
+export const Sparkle = wrapLucideIcon(Lucide.Sparkle)
+export const Sparkles = wrapLucideIcon(Lucide.Sparkles)
+export const Speaker = wrapLucideIcon(Lucide.Speaker)
+export const Speech = wrapLucideIcon(Lucide.Speech)
+export const SpellCheck = wrapLucideIcon(Lucide.SpellCheck)
+export const SpellCheck2 = wrapLucideIcon(Lucide.SpellCheck2)
+export const Spline = wrapLucideIcon(Lucide.Spline)
+export const Split = wrapLucideIcon(Lucide.Split)
+export const SplitSquareHorizontal = wrapLucideIcon(
+  Lucide.SplitSquareHorizontal
+)
+export const SplitSquareVertical = wrapLucideIcon(Lucide.SplitSquareVertical)
+export const SprayCan = wrapLucideIcon(Lucide.SprayCan)
+export const Sprout = wrapLucideIcon(Lucide.Sprout)
+export const Square = wrapLucideIcon(Lucide.Square)
+export const SquareActivity = wrapLucideIcon(Lucide.SquareActivity)
+export const SquareArrowDown = wrapLucideIcon(Lucide.SquareArrowDown)
+export const SquareArrowDownLeft = wrapLucideIcon(Lucide.SquareArrowDownLeft)
+export const SquareArrowDownRight = wrapLucideIcon(Lucide.SquareArrowDownRight)
+export const SquareArrowLeft = wrapLucideIcon(Lucide.SquareArrowLeft)
+export const SquareArrowOutDownLeft = wrapLucideIcon(
+  Lucide.SquareArrowOutDownLeft
+)
+export const SquareArrowOutDownRight = wrapLucideIcon(
+  Lucide.SquareArrowOutDownRight
+)
+export const SquareArrowOutUpLeft = wrapLucideIcon(Lucide.SquareArrowOutUpLeft)
+export const SquareArrowOutUpRight = wrapLucideIcon(
+  Lucide.SquareArrowOutUpRight
+)
+export const SquareArrowRight = wrapLucideIcon(Lucide.SquareArrowRight)
+export const SquareArrowUp = wrapLucideIcon(Lucide.SquareArrowUp)
+export const SquareArrowUpLeft = wrapLucideIcon(Lucide.SquareArrowUpLeft)
+export const SquareArrowUpRight = wrapLucideIcon(Lucide.SquareArrowUpRight)
+export const SquareAsterisk = wrapLucideIcon(Lucide.SquareAsterisk)
+export const SquareBottomDashedScissors = wrapLucideIcon(
+  Lucide.SquareBottomDashedScissors
+)
+export const SquareChartGantt = wrapLucideIcon(Lucide.SquareChartGantt)
+export const SquareCheck = wrapLucideIcon(Lucide.SquareCheck)
+export const SquareCheckBig = wrapLucideIcon(Lucide.SquareCheckBig)
+export const SquareChevronDown = wrapLucideIcon(Lucide.SquareChevronDown)
+export const SquareChevronLeft = wrapLucideIcon(Lucide.SquareChevronLeft)
+export const SquareChevronRight = wrapLucideIcon(Lucide.SquareChevronRight)
+export const SquareChevronUp = wrapLucideIcon(Lucide.SquareChevronUp)
+export const SquareCode = wrapLucideIcon(Lucide.SquareCode)
+export const SquareDashed = wrapLucideIcon(Lucide.SquareDashed)
+export const SquareDashedBottom = wrapLucideIcon(Lucide.SquareDashedBottom)
+export const SquareDashedBottomCode = wrapLucideIcon(
+  Lucide.SquareDashedBottomCode
+)
+export const SquareDashedKanban = wrapLucideIcon(Lucide.SquareDashedKanban)
+export const SquareDashedMousePointer = wrapLucideIcon(
+  Lucide.SquareDashedMousePointer
+)
+export const SquareDivide = wrapLucideIcon(Lucide.SquareDivide)
+export const SquareDot = wrapLucideIcon(Lucide.SquareDot)
+export const SquareEqual = wrapLucideIcon(Lucide.SquareEqual)
+export const SquareFunction = wrapLucideIcon(Lucide.SquareFunction)
+export const SquareGanttChart = wrapLucideIcon(Lucide.SquareGanttChart)
+export const SquareKanban = wrapLucideIcon(Lucide.SquareKanban)
+export const SquareLibrary = wrapLucideIcon(Lucide.SquareLibrary)
+export const SquareM = wrapLucideIcon(Lucide.SquareM)
+export const SquareMenu = wrapLucideIcon(Lucide.SquareMenu)
+export const SquareMinus = wrapLucideIcon(Lucide.SquareMinus)
+export const SquareMousePointer = wrapLucideIcon(Lucide.SquareMousePointer)
+export const SquareParking = wrapLucideIcon(Lucide.SquareParking)
+export const SquareParkingOff = wrapLucideIcon(Lucide.SquareParkingOff)
+export const SquarePen = wrapLucideIcon(Lucide.SquarePen)
+export const SquarePercent = wrapLucideIcon(Lucide.SquarePercent)
+export const SquarePi = wrapLucideIcon(Lucide.SquarePi)
+export const SquarePilcrow = wrapLucideIcon(Lucide.SquarePilcrow)
+export const SquarePlay = wrapLucideIcon(Lucide.SquarePlay)
+export const SquarePlus = wrapLucideIcon(Lucide.SquarePlus)
+export const SquarePower = wrapLucideIcon(Lucide.SquarePower)
+export const SquareRadical = wrapLucideIcon(Lucide.SquareRadical)
+export const SquareScissors = wrapLucideIcon(Lucide.SquareScissors)
+export const SquareSigma = wrapLucideIcon(Lucide.SquareSigma)
+export const SquareSlash = wrapLucideIcon(Lucide.SquareSlash)
+export const SquareSplitHorizontal = wrapLucideIcon(
+  Lucide.SquareSplitHorizontal
+)
+export const SquareSplitVertical = wrapLucideIcon(Lucide.SquareSplitVertical)
+export const SquareSquare = wrapLucideIcon(Lucide.SquareSquare)
+export const SquareStack = wrapLucideIcon(Lucide.SquareStack)
+export const SquareTerminal = wrapLucideIcon(Lucide.SquareTerminal)
+export const SquareUser = wrapLucideIcon(Lucide.SquareUser)
+export const SquareUserRound = wrapLucideIcon(Lucide.SquareUserRound)
+export const SquareX = wrapLucideIcon(Lucide.SquareX)
+export const Squircle = wrapLucideIcon(Lucide.Squircle)
+export const Squirrel = wrapLucideIcon(Lucide.Squirrel)
+export const Stamp = wrapLucideIcon(Lucide.Stamp)
+export const Star = wrapLucideIcon(Lucide.Star)
+export const StarHalf = wrapLucideIcon(Lucide.StarHalf)
+export const StarOff = wrapLucideIcon(Lucide.StarOff)
+export const Stars = wrapLucideIcon(Lucide.Stars)
+export const StepBack = wrapLucideIcon(Lucide.StepBack)
+export const StepForward = wrapLucideIcon(Lucide.StepForward)
+export const Stethoscope = wrapLucideIcon(Lucide.Stethoscope)
+export const Sticker = wrapLucideIcon(Lucide.Sticker)
+export const StickyNote = wrapLucideIcon(Lucide.StickyNote)
+export const StopCircle = wrapLucideIcon(Lucide.StopCircle)
+export const Store = wrapLucideIcon(Lucide.Store)
+export const StretchHorizontal = wrapLucideIcon(Lucide.StretchHorizontal)
+export const StretchVertical = wrapLucideIcon(Lucide.StretchVertical)
+export const Strikethrough = wrapLucideIcon(Lucide.Strikethrough)
+export const Subscript = wrapLucideIcon(Lucide.Subscript)
+export const Subtitles = wrapLucideIcon(Lucide.Subtitles)
+export const Sun = wrapLucideIcon(Lucide.Sun)
+export const SunDim = wrapLucideIcon(Lucide.SunDim)
+export const SunMedium = wrapLucideIcon(Lucide.SunMedium)
+export const SunMoon = wrapLucideIcon(Lucide.SunMoon)
+export const SunSnow = wrapLucideIcon(Lucide.SunSnow)
+export const Sunrise = wrapLucideIcon(Lucide.Sunrise)
+export const Sunset = wrapLucideIcon(Lucide.Sunset)
+export const Superscript = wrapLucideIcon(Lucide.Superscript)
+export const SwatchBook = wrapLucideIcon(Lucide.SwatchBook)
+export const SwissFranc = wrapLucideIcon(Lucide.SwissFranc)
+export const SwitchCamera = wrapLucideIcon(Lucide.SwitchCamera)
+export const Sword = wrapLucideIcon(Lucide.Sword)
+export const Swords = wrapLucideIcon(Lucide.Swords)
+export const Syringe = wrapLucideIcon(Lucide.Syringe)
+export const Table = wrapLucideIcon(Lucide.Table)
+export const Table2 = wrapLucideIcon(Lucide.Table2)
+export const TableCellsMerge = wrapLucideIcon(Lucide.TableCellsMerge)
+export const TableCellsSplit = wrapLucideIcon(Lucide.TableCellsSplit)
+export const TableColumnsSplit = wrapLucideIcon(Lucide.TableColumnsSplit)
+export const TableOfContents = wrapLucideIcon(Lucide.TableOfContents)
+export const TableProperties = wrapLucideIcon(Lucide.TableProperties)
+export const TableRowsSplit = wrapLucideIcon(Lucide.TableRowsSplit)
+export const Tablet = wrapLucideIcon(Lucide.Tablet)
+export const TabletSmartphone = wrapLucideIcon(Lucide.TabletSmartphone)
+export const Tablets = wrapLucideIcon(Lucide.Tablets)
+export const Tag = wrapLucideIcon(Lucide.Tag)
+export const Tags = wrapLucideIcon(Lucide.Tags)
+export const Tally1 = wrapLucideIcon(Lucide.Tally1)
+export const Tally2 = wrapLucideIcon(Lucide.Tally2)
+export const Tally3 = wrapLucideIcon(Lucide.Tally3)
+export const Tally4 = wrapLucideIcon(Lucide.Tally4)
+export const Tally5 = wrapLucideIcon(Lucide.Tally5)
+export const Tangent = wrapLucideIcon(Lucide.Tangent)
+export const Target = wrapLucideIcon(Lucide.Target)
+export const Telescope = wrapLucideIcon(Lucide.Telescope)
+export const Tent = wrapLucideIcon(Lucide.Tent)
+export const TentTree = wrapLucideIcon(Lucide.TentTree)
+export const Terminal = wrapLucideIcon(Lucide.Terminal)
+export const TerminalSquare = wrapLucideIcon(Lucide.TerminalSquare)
+export const TestTube = wrapLucideIcon(Lucide.TestTube)
+export const TestTube2 = wrapLucideIcon(Lucide.TestTube2)
+export const TestTubeDiagonal = wrapLucideIcon(Lucide.TestTubeDiagonal)
+export const TestTubes = wrapLucideIcon(Lucide.TestTubes)
+export const Text = wrapLucideIcon(Lucide.Text)
+export const TextCursor = wrapLucideIcon(Lucide.TextCursor)
+export const TextCursorInput = wrapLucideIcon(Lucide.TextCursorInput)
+export const TextQuote = wrapLucideIcon(Lucide.TextQuote)
+export const TextSearch = wrapLucideIcon(Lucide.TextSearch)
+export const TextSelect = wrapLucideIcon(Lucide.TextSelect)
+export const TextSelection = wrapLucideIcon(Lucide.TextSelection)
+export const Theater = wrapLucideIcon(Lucide.Theater)
+export const Thermometer = wrapLucideIcon(Lucide.Thermometer)
+export const ThermometerSnowflake = wrapLucideIcon(Lucide.ThermometerSnowflake)
+export const ThermometerSun = wrapLucideIcon(Lucide.ThermometerSun)
+export const ThumbsDown = wrapLucideIcon(Lucide.ThumbsDown)
+export const ThumbsUp = wrapLucideIcon(Lucide.ThumbsUp)
+export const Ticket = wrapLucideIcon(Lucide.Ticket)
+export const TicketCheck = wrapLucideIcon(Lucide.TicketCheck)
+export const TicketMinus = wrapLucideIcon(Lucide.TicketMinus)
+export const TicketPercent = wrapLucideIcon(Lucide.TicketPercent)
+export const TicketPlus = wrapLucideIcon(Lucide.TicketPlus)
+export const TicketSlash = wrapLucideIcon(Lucide.TicketSlash)
+export const TicketX = wrapLucideIcon(Lucide.TicketX)
+export const Tickets = wrapLucideIcon(Lucide.Tickets)
+export const TicketsPlane = wrapLucideIcon(Lucide.TicketsPlane)
+export const Timer = wrapLucideIcon(Lucide.Timer)
+export const TimerOff = wrapLucideIcon(Lucide.TimerOff)
+export const TimerReset = wrapLucideIcon(Lucide.TimerReset)
+export const ToggleLeft = wrapLucideIcon(Lucide.ToggleLeft)
+export const ToggleRight = wrapLucideIcon(Lucide.ToggleRight)
+export const Toilet = wrapLucideIcon(Lucide.Toilet)
+export const Tornado = wrapLucideIcon(Lucide.Tornado)
+export const Torus = wrapLucideIcon(Lucide.Torus)
+export const Touchpad = wrapLucideIcon(Lucide.Touchpad)
+export const TouchpadOff = wrapLucideIcon(Lucide.TouchpadOff)
+export const TowerControl = wrapLucideIcon(Lucide.TowerControl)
+export const ToyBrick = wrapLucideIcon(Lucide.ToyBrick)
+export const Tractor = wrapLucideIcon(Lucide.Tractor)
+export const TrafficCone = wrapLucideIcon(Lucide.TrafficCone)
+export const Train = wrapLucideIcon(Lucide.Train)
+export const TrainFront = wrapLucideIcon(Lucide.TrainFront)
+export const TrainFrontTunnel = wrapLucideIcon(Lucide.TrainFrontTunnel)
+export const TrainTrack = wrapLucideIcon(Lucide.TrainTrack)
+export const TramFront = wrapLucideIcon(Lucide.TramFront)
+export const Trash = wrapLucideIcon(Lucide.Trash)
+export const Trash2 = wrapLucideIcon(Lucide.Trash2)
+export const TreeDeciduous = wrapLucideIcon(Lucide.TreeDeciduous)
+export const TreePalm = wrapLucideIcon(Lucide.TreePalm)
+export const TreePine = wrapLucideIcon(Lucide.TreePine)
+export const Trees = wrapLucideIcon(Lucide.Trees)
+export const Trello = wrapLucideIcon(Lucide.Trello)
+export const TrendingDown = wrapLucideIcon(Lucide.TrendingDown)
+export const TrendingUp = wrapLucideIcon(Lucide.TrendingUp)
+export const TrendingUpDown = wrapLucideIcon(Lucide.TrendingUpDown)
+export const Triangle = wrapLucideIcon(Lucide.Triangle)
+export const TriangleAlert = wrapLucideIcon(Lucide.TriangleAlert)
+export const TriangleRight = wrapLucideIcon(Lucide.TriangleRight)
+export const Trophy = wrapLucideIcon(Lucide.Trophy)
+export const Truck = wrapLucideIcon(Lucide.Truck)
+export const Turtle = wrapLucideIcon(Lucide.Turtle)
+export const Tv = wrapLucideIcon(Lucide.Tv)
+export const Tv2 = wrapLucideIcon(Lucide.Tv2)
+export const TvMinimal = wrapLucideIcon(Lucide.TvMinimal)
+export const TvMinimalPlay = wrapLucideIcon(Lucide.TvMinimalPlay)
+export const Twitch = wrapLucideIcon(Lucide.Twitch)
+export const Twitter = wrapLucideIcon(Lucide.Twitter)
+export const Type = wrapLucideIcon(Lucide.Type)
+export const TypeOutline = wrapLucideIcon(Lucide.TypeOutline)
+export const Umbrella = wrapLucideIcon(Lucide.Umbrella)
+export const UmbrellaOff = wrapLucideIcon(Lucide.UmbrellaOff)
+export const Underline = wrapLucideIcon(Lucide.Underline)
+export const Undo = wrapLucideIcon(Lucide.Undo)
+export const Undo2 = wrapLucideIcon(Lucide.Undo2)
+export const UndoDot = wrapLucideIcon(Lucide.UndoDot)
+export const UnfoldHorizontal = wrapLucideIcon(Lucide.UnfoldHorizontal)
+export const UnfoldVertical = wrapLucideIcon(Lucide.UnfoldVertical)
+export const Ungroup = wrapLucideIcon(Lucide.Ungroup)
+export const University = wrapLucideIcon(Lucide.University)
+export const Unlink = wrapLucideIcon(Lucide.Unlink)
+export const Unlink2 = wrapLucideIcon(Lucide.Unlink2)
+export const Unlock = wrapLucideIcon(Lucide.Unlock)
+export const UnlockKeyhole = wrapLucideIcon(Lucide.UnlockKeyhole)
+export const Unplug = wrapLucideIcon(Lucide.Unplug)
+export const Upload = wrapLucideIcon(Lucide.Upload)
+export const UploadCloud = wrapLucideIcon(Lucide.UploadCloud)
+export const Usb = wrapLucideIcon(Lucide.Usb)
+export const User = wrapLucideIcon(Lucide.User)
+export const User2 = wrapLucideIcon(Lucide.User2)
+export const UserCheck = wrapLucideIcon(Lucide.UserCheck)
+export const UserCheck2 = wrapLucideIcon(Lucide.UserCheck2)
+export const UserCircle = wrapLucideIcon(Lucide.UserCircle)
+export const UserCircle2 = wrapLucideIcon(Lucide.UserCircle2)
+export const UserCog = wrapLucideIcon(Lucide.UserCog)
+export const UserCog2 = wrapLucideIcon(Lucide.UserCog2)
+export const UserMinus = wrapLucideIcon(Lucide.UserMinus)
+export const UserMinus2 = wrapLucideIcon(Lucide.UserMinus2)
+export const UserPen = wrapLucideIcon(Lucide.UserPen)
+export const UserPlus = wrapLucideIcon(Lucide.UserPlus)
+export const UserPlus2 = wrapLucideIcon(Lucide.UserPlus2)
+export const UserRound = wrapLucideIcon(Lucide.UserRound)
+export const UserRoundCheck = wrapLucideIcon(Lucide.UserRoundCheck)
+export const UserRoundCog = wrapLucideIcon(Lucide.UserRoundCog)
+export const UserRoundMinus = wrapLucideIcon(Lucide.UserRoundMinus)
+export const UserRoundPen = wrapLucideIcon(Lucide.UserRoundPen)
+export const UserRoundPlus = wrapLucideIcon(Lucide.UserRoundPlus)
+export const UserRoundSearch = wrapLucideIcon(Lucide.UserRoundSearch)
+export const UserRoundX = wrapLucideIcon(Lucide.UserRoundX)
+export const UserSearch = wrapLucideIcon(Lucide.UserSearch)
+export const UserSquare = wrapLucideIcon(Lucide.UserSquare)
+export const UserSquare2 = wrapLucideIcon(Lucide.UserSquare2)
+export const UserX = wrapLucideIcon(Lucide.UserX)
+export const UserX2 = wrapLucideIcon(Lucide.UserX2)
+export const Users = wrapLucideIcon(Lucide.Users)
+export const Users2 = wrapLucideIcon(Lucide.Users2)
+export const UsersRound = wrapLucideIcon(Lucide.UsersRound)
+export const Utensils = wrapLucideIcon(Lucide.Utensils)
+export const UtensilsCrossed = wrapLucideIcon(Lucide.UtensilsCrossed)
+export const UtilityPole = wrapLucideIcon(Lucide.UtilityPole)
+export const Variable = wrapLucideIcon(Lucide.Variable)
+export const Vault = wrapLucideIcon(Lucide.Vault)
+export const Vegan = wrapLucideIcon(Lucide.Vegan)
+export const VenetianMask = wrapLucideIcon(Lucide.VenetianMask)
+export const Verified = wrapLucideIcon(Lucide.Verified)
+export const Vibrate = wrapLucideIcon(Lucide.Vibrate)
+export const VibrateOff = wrapLucideIcon(Lucide.VibrateOff)
+export const Video = wrapLucideIcon(Lucide.Video)
+export const VideoOff = wrapLucideIcon(Lucide.VideoOff)
+export const Videotape = wrapLucideIcon(Lucide.Videotape)
+export const View = wrapLucideIcon(Lucide.View)
+export const Voicemail = wrapLucideIcon(Lucide.Voicemail)
+export const Volleyball = wrapLucideIcon(Lucide.Volleyball)
+export const Volume = wrapLucideIcon(Lucide.Volume)
+export const Volume1 = wrapLucideIcon(Lucide.Volume1)
+export const Volume2 = wrapLucideIcon(Lucide.Volume2)
+export const VolumeOff = wrapLucideIcon(Lucide.VolumeOff)
+export const VolumeX = wrapLucideIcon(Lucide.VolumeX)
+export const Vote = wrapLucideIcon(Lucide.Vote)
+export const Wallet = wrapLucideIcon(Lucide.Wallet)
+export const Wallet2 = wrapLucideIcon(Lucide.Wallet2)
+export const WalletCards = wrapLucideIcon(Lucide.WalletCards)
+export const WalletMinimal = wrapLucideIcon(Lucide.WalletMinimal)
+export const Wallpaper = wrapLucideIcon(Lucide.Wallpaper)
+export const Wand = wrapLucideIcon(Lucide.Wand)
+export const Wand2 = wrapLucideIcon(Lucide.Wand2)
+export const WandSparkles = wrapLucideIcon(Lucide.WandSparkles)
+export const Warehouse = wrapLucideIcon(Lucide.Warehouse)
+export const WashingMachine = wrapLucideIcon(Lucide.WashingMachine)
+export const Watch = wrapLucideIcon(Lucide.Watch)
+export const Waves = wrapLucideIcon(Lucide.Waves)
+export const Waypoints = wrapLucideIcon(Lucide.Waypoints)
+export const Webcam = wrapLucideIcon(Lucide.Webcam)
+export const Webhook = wrapLucideIcon(Lucide.Webhook)
+export const WebhookOff = wrapLucideIcon(Lucide.WebhookOff)
+export const Weight = wrapLucideIcon(Lucide.Weight)
+export const Wheat = wrapLucideIcon(Lucide.Wheat)
+export const WheatOff = wrapLucideIcon(Lucide.WheatOff)
+export const WholeWord = wrapLucideIcon(Lucide.WholeWord)
+export const Wifi = wrapLucideIcon(Lucide.Wifi)
+export const WifiHigh = wrapLucideIcon(Lucide.WifiHigh)
+export const WifiLow = wrapLucideIcon(Lucide.WifiLow)
+export const WifiOff = wrapLucideIcon(Lucide.WifiOff)
+export const WifiZero = wrapLucideIcon(Lucide.WifiZero)
+export const Wind = wrapLucideIcon(Lucide.Wind)
+export const WindArrowDown = wrapLucideIcon(Lucide.WindArrowDown)
+export const Wine = wrapLucideIcon(Lucide.Wine)
+export const WineOff = wrapLucideIcon(Lucide.WineOff)
+export const Workflow = wrapLucideIcon(Lucide.Workflow)
+export const Worm = wrapLucideIcon(Lucide.Worm)
+export const WrapText = wrapLucideIcon(Lucide.WrapText)
+export const Wrench = wrapLucideIcon(Lucide.Wrench)
+export const X = wrapLucideIcon(Lucide.X)
+export const XCircle = wrapLucideIcon(Lucide.XCircle)
+export const XOctagon = wrapLucideIcon(Lucide.XOctagon)
+export const XSquare = wrapLucideIcon(Lucide.XSquare)
+export const Youtube = wrapLucideIcon(Lucide.Youtube)
+export const Zap = wrapLucideIcon(Lucide.Zap)
+export const ZapOff = wrapLucideIcon(Lucide.ZapOff)
+export const ZoomIn = wrapLucideIcon(Lucide.ZoomIn)
+export const ZoomOut = wrapLucideIcon(Lucide.ZoomOut)
diff --git a/packages/ui-icons-lucide/src/mapping.json b/packages/ui-icons-lucide/src/mapping.json
new file mode 100644
index 0000000000..0f8ad905a7
--- /dev/null
+++ b/packages/ui-icons-lucide/src/mapping.json
@@ -0,0 +1,134 @@
+{
+  "version": "1.0",
+  "lastUpdated": "2025-11-07",
+  "mappings": [
+    {
+      "instUI": {
+        "line": "IconAddLine",
+        "solid": "IconAddSolid"
+      },
+      "lucide": {
+        "name": "Plus"
+      },
+      "bidirectional": false,
+      "notes": "Add/plus icon"
+    },
+    {
+      "instUI": {
+        "line": "IconCheckLine",
+        "solid": "IconCheckSolid"
+      },
+      "lucide": {
+        "name": "Check"
+      },
+      "bidirectional": false,
+      "notes": "Checkmark icon"
+    },
+    {
+      "instUI": {
+        "line": "IconSearchLine",
+        "solid": "IconSearchSolid"
+      },
+      "lucide": {
+        "name": "Search"
+      },
+      "bidirectional": false,
+      "notes": "Search icon"
+    },
+    {
+      "instUI": {
+        "line": "IconCloseLine",
+        "solid": "IconCloseSolid"
+      },
+      "lucide": {
+        "name": "X"
+      },
+      "bidirectional": false,
+      "notes": "Close/dismiss icon"
+    },
+    {
+      "instUI": {
+        "line": "IconArrowStartLine",
+        "solid": "IconArrowStartSolid"
+      },
+      "lucide": {
+        "name": "ArrowLeft"
+      },
+      "bidirectional": true,
+      "notes": "Bidirectional arrow - flips in RTL (left becomes right)"
+    },
+    {
+      "instUI": {
+        "line": "IconArrowEndLine",
+        "solid": "IconArrowEndSolid"
+      },
+      "lucide": {
+        "name": "ArrowRight"
+      },
+      "bidirectional": true,
+      "notes": "Bidirectional arrow - flips in RTL (right becomes left)"
+    },
+    {
+      "instUI": {
+        "line": "IconSettingsLine",
+        "solid": "IconSettingsSolid"
+      },
+      "lucide": {
+        "name": "Settings"
+      },
+      "bidirectional": false,
+      "notes": "Settings/configuration icon"
+    },
+    {
+      "instUI": {
+        "line": "IconHomeLine",
+        "solid": "IconHomeSolid"
+      },
+      "lucide": {
+        "name": "Home"
+      },
+      "bidirectional": false,
+      "notes": "Home icon"
+    },
+    {
+      "instUI": {
+        "line": "IconUserLine",
+        "solid": "IconUserSolid"
+      },
+      "lucide": {
+        "name": "User"
+      },
+      "bidirectional": false,
+      "notes": "User/profile icon"
+    },
+    {
+      "instUI": {
+        "line": "IconTrashLine",
+        "solid": "IconTrashSolid"
+      },
+      "lucide": {
+        "name": "Trash2"
+      },
+      "bidirectional": false,
+      "notes": "Delete/trash icon"
+    }
+  ],
+  "unmapped": [
+    {
+      "instUI": {
+        "line": "IconCanvasLogoLine",
+        "solid": "IconCanvasLogoSolid"
+      },
+      "reason": "Product-specific logo, no Lucide equivalent",
+      "action": "Keep in @instructure/ui-icons"
+    },
+    {
+      "instUI": {
+        "line": "IconInstructureLogoLine",
+        "solid": "IconInstructureLogoSolid"
+      },
+      "reason": "Product-specific logo, no Lucide equivalent",
+      "action": "Keep in @instructure/ui-icons"
+    }
+  ]
+}
diff --git a/packages/ui-icons-lucide/src/wrapLucideIcon/index.tsx b/packages/ui-icons-lucide/src/wrapLucideIcon/index.tsx
new file mode 100644
index 0000000000..17993d984c
--- /dev/null
+++ b/packages/ui-icons-lucide/src/wrapLucideIcon/index.tsx
@@ -0,0 +1,245 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import React, { forwardRef } from 'react'
+import type { LucideIcon } from 'lucide-react'
+import { useStyle, useTheme } from '@instructure/emotion'
+import { px } from '@instructure/ui-utils'
+
+import generateStyle from './styles'
+import generateComponentTheme from './theme'
+import type {
+  LucideIconWrapperProps,
+  InstUIIconProps,
+  LucideIconTheme
+} from './props'
+
+/**
+ * Wraps a Lucide icon component with InstUI theming and RTL support.
+ *
+ * This HOC transforms a Lucide icon into an InstUI-compatible component with:
+ * - Semantic sizing (x-small through x-large)
+ * - Theme-aware colors (primary, secondary, success, error, etc.)
+ * - Automatic RTL flipping (bidirectional by default)
+ * - Rotation support (0°, 90°, 180°, 270°)
+ * - Accessibility features (title, description)
+ * - Full Lucide props compatibility
+ * - Themeable via InstUI emotion system with useStyle hook
+ *
+ * @param Icon - The Lucide icon component to wrap
+ * @returns A themed, RTL-aware icon component
+ *
+ * @example
+ * Basic usage (automatic in generated index.ts):
+ * ```tsx
+ * import { ArrowLeft } from 'lucide-react'
+ * import { wrapLucideIcon } from './wrapLucideIcon'
+ *
+ * const IconArrowLeft = wrapLucideIcon(ArrowLeft)
+ * ```
+ *
+ * @example
+ * InstUI-style props:
+ * ```tsx
+ * import { ArrowLeft } from '@instructure/ui-icons-lucide'
+ *
+ * <ArrowLeft
+ *   size="large"
+ *   color="primary"
+ *   rotate="90"
+ *   title="Navigate left"
+ * />
+ * ```
+ *
+ * @example
+ * Lucide-style props (still supported):
+ * ```tsx
+ * <ArrowLeft
+ *   size={24}
+ *   strokeWidth={2}
+ *   color="#ff0000"
+ * />
+ * ```
+ *
+ * @example
+ * Disable RTL flipping:
+ * ```tsx
+ * <ArrowLeft bidirectional={false} />
+ * ```
+ *
+ * @example
+ * With accessibility:
+ * ```tsx
+ * <ArrowLeft
+ *   title="Previous page"
+ *   description="Navigate to the previous page in the sequence"
+ * />
+ * ```
+ */
+export function wrapLucideIcon(Icon: LucideIcon): LucideIcon {
+  const WrappedIcon = forwardRef<SVGSVGElement, LucideIconWrapperProps>(
+    (props, ref) => {
+      const {
+        // Extract InstUI props
+        size: instUISize,
+        color: instUIColor,
+        rotate = '0',
+        bidirectional = true,
+        inline = true,
+        title,
+        description,
+        elementRef,
+        themeOverride,
+
+        // Lucide native props
+        strokeWidth,
+        absoluteStrokeWidth,
+        className,
+        style,
+
+        ...rest
+      } = props
+
+      // Get theme to convert semantic sizes to pixels
+      const theme = useTheme()
+      const componentTheme = generateComponentTheme(theme as any)
+
+      // Determine if using InstUI semantic size or Lucide numeric size
+      const isSemanticSize = typeof instUISize === 'string'
+      const semanticSize = isSemanticSize ? instUISize : undefined
+
+      // Convert semantic size to pixels for Lucide, or use numeric size directly
+      // Lucide doesn't inherit fontSize, so we need explicit pixel values
+      let numericSize: number | undefined
+      if (isSemanticSize) {
+        const sizeMap = {
+          'x-small': componentTheme.sizeXSmall,
+          small: componentTheme.sizeSmall,
+          medium: componentTheme.sizeMedium,
+          large: componentTheme.sizeLarge,
+          'x-large': componentTheme.sizeXLarge
+        }
+        const themeSizeValue = sizeMap[instUISize as keyof typeof sizeMap]
+        // Use InstUI's px utility to convert rem/em to pixels
+        numericSize = px(themeSizeValue)
+      } else {
+        numericSize = instUISize
+      }
+
+      // Determine if using InstUI semantic color or custom color
+      const semanticColors = [
+        'inherit',
+        'primary',
+        'secondary',
+        'primary-inverse',
+        'secondary-inverse',
+        'success',
+        'error',
+        'warning',
+        'alert',
+        'brand'
+      ]
+      const isSemanticColor = instUIColor
+        ? semanticColors.includes(instUIColor)
+        : false
+      const colorValue = isSemanticColor ? instUIColor : undefined
+      const customColor = isSemanticColor ? undefined : instUIColor
+
+      // Using useStyle hook for functional component theming
+      const styles = useStyle({
+        generateStyle,
+        generateComponentTheme,
+        params: {
+          size: semanticSize,
+          color: colorValue,
+          rotate,
+          bidirectional,
+          inline,
+          themeOverride
+        },
+        componentId: 'LucideIcon',
+        displayName: `LucideIcon(${Icon.displayName || Icon.name})`
+      })
+
+      // Merge refs (both ref and elementRef)
+      const iconRef = (node: SVGSVGElement | null) => {
+        if (ref) {
+          if (typeof ref === 'function') {
+            ref(node)
+          } else if (ref && 'current' in ref) {
+            // eslint-disable-next-line no-param-reassign
+            ref.current = node
+          }
+        }
+        if (elementRef) {
+          if (typeof elementRef === 'function') {
+            elementRef(node)
+          } else if (
+            elementRef &&
+            typeof elementRef === 'object' &&
+            'current' in elementRef
+          ) {
+            ;(
+              elementRef as React.MutableRefObject<SVGSVGElement | null>
+            ).current = node
+          }
+        }
+      }
+
+      // Build accessibility props
+      const accessibilityProps: Record<string, any> = {}
+      if (title) {
+        accessibilityProps['aria-label'] = description
+          ? `${title}: ${description}`
+          : title
+        accessibilityProps['role'] = 'img'
+      } else {
+        accessibilityProps['aria-hidden'] = 'true'
+        accessibilityProps['role'] = 'presentation'
+      }
+
+      return (
+        <span css={styles?.lucideIcon} className={className} style={style}>
+          <Icon
+            ref={iconRef}
+            size={numericSize}
+            color={customColor || 'currentColor'}
+            strokeWidth={strokeWidth}
+            absoluteStrokeWidth={absoluteStrokeWidth}
+            {...accessibilityProps}
+            {...rest}
+          />
+        </span>
+      )
+    }
+  )
+
+  WrappedIcon.displayName = `wrapLucideIcon(${Icon.displayName || Icon.name})`
+
+  return WrappedIcon as LucideIcon
+}
+
+export type { LucideIconWrapperProps, InstUIIconProps, LucideIconTheme }
+export { default as generateComponentTheme } from './theme'
+export { default as generateStyle } from './styles'
diff --git a/packages/ui-icons-lucide/src/wrapLucideIcon/props.ts b/packages/ui-icons-lucide/src/wrapLucideIcon/props.ts
new file mode 100644
index 0000000000..f110f157f6
--- /dev/null
+++ b/packages/ui-icons-lucide/src/wrapLucideIcon/props.ts
@@ -0,0 +1,139 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import type { LucideProps } from 'lucide-react'
+import type { ComponentStyle } from '@instructure/emotion'
+import type { LucideIconTheme } from './theme'
+
+/**
+ * InstUI-specific props added to Lucide icons.
+ *
+ * These props provide InstUI-style API for icons, including semantic sizing,
+ * theme-aware colors, rotation, RTL support, and accessibility features.
+ */
+export interface InstUIIconProps {
+  /**
+   * Size of the icon.
+   * Can be a semantic size name (uses theme-based sizing) or a numeric pixel value.
+   *
+   * - Semantic sizes: 'x-small' (18px), 'small' (32px), 'medium' (48px), 'large' (80px), 'x-large' (160px)
+   * - Numeric: Any number for pixel-based sizing (e.g., 24)
+   */
+  size?: 'x-small' | 'small' | 'medium' | 'large' | 'x-large' | number
+
+  /**
+   * Color of the icon.
+   * Can be a semantic color name (uses theme colors) or any valid CSS color string.
+   *
+   * - Semantic colors: 'primary', 'secondary', 'success', 'error', 'warning', 'alert', 'brand'
+   * - CSS colors: Any valid CSS color (e.g., '#ff0000', 'rgb(255, 0, 0)', 'currentColor')
+   */
+  color?:
+    | 'inherit'
+    | 'primary'
+    | 'secondary'
+    | 'primary-inverse'
+    | 'secondary-inverse'
+    | 'success'
+    | 'error'
+    | 'warning'
+    | 'alert'
+    | 'brand'
+    | string
+
+  /**
+   * Rotation angle in degrees.
+   * The icon will be rotated by the specified amount.
+   */
+  rotate?: '0' | '90' | '180' | '270'
+
+  /**
+   * Whether the icon should flip horizontally in RTL contexts.
+   *
+   * @default true
+   *
+   * When true (default), the icon automatically flips horizontally when the
+   * document direction is RTL. Set to false to prevent flipping for icons
+   * that should maintain their orientation in all contexts.
+   */
+  bidirectional?: boolean
+
+  /**
+   * Display mode for the icon.
+   *
+   * @default true
+   *
+   * - true: display as inline-block (flows with text)
+   * - false: display as block (takes full width)
+   */
+  inline?: boolean
+
+  /**
+   * Accessible title for the icon.
+   * If provided, the icon will have role="img" and proper aria-labelledby.
+   */
+  title?: string
+
+  /**
+   * Accessible description for the icon.
+   * Used in combination with title for more detailed accessibility information.
+   */
+  description?: string
+
+  /**
+   * Ref forwarding for the underlying SVG element.
+   * Alternative to the standard `ref` prop for compatibility with InstUI patterns.
+   */
+  elementRef?: React.Ref<SVGSVGElement>
+
+  /**
+   * Theme overrides for this specific icon instance.
+   * Allows customization of theme variables on a per-component basis.
+   */
+  themeOverride?: Partial<LucideIconTheme>
+}
+
+/**
+ * Combined props: InstUI + Lucide.
+ *
+ * This interface merges InstUI props with Lucide's native props, with InstUI
+ * props taking precedence for `size`, `color`, and `rotate` (to support both semantic
+ * and numeric/string values).
+ */
+export interface LucideIconWrapperProps
+  extends Omit<LucideProps, 'size' | 'color' | 'rotate'>,
+    InstUIIconProps {
+  // size, color, and rotate are redefined in InstUIIconProps to support both formats:
+  // - size: semantic ('small') OR numeric (24)
+  // - color: semantic ('primary') OR CSS string ('#ff0000')
+  // - rotate: semantic ('0', '90', '180', '270')
+}
+
+/**
+ * Style object type for the icon wrapper.
+ * Generated by the generateStyle function and consumed by the useStyle hook.
+ */
+export type LucideIconStyle = ComponentStyle<'lucideIcon'>
+
+export { type LucideIconTheme }
diff --git a/packages/ui-icons-lucide/src/wrapLucideIcon/styles.ts b/packages/ui-icons-lucide/src/wrapLucideIcon/styles.ts
new file mode 100644
index 0000000000..b4d7174220
--- /dev/null
+++ b/packages/ui-icons-lucide/src/wrapLucideIcon/styles.ts
@@ -0,0 +1,107 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import type { LucideIconTheme } from './theme'
+import type { LucideIconStyle } from './props'
+
+interface StyleParams {
+  size?: 'x-small' | 'small' | 'medium' | 'large' | 'x-large'
+  color?: string
+  rotate?: '0' | '90' | '180' | '270'
+  bidirectional?: boolean
+  inline?: boolean
+  themeOverride?: Partial<LucideIconTheme>
+}
+
+/**
+ * Generates the style object from the theme and provided props.
+ *
+ * This function is called by useStyle hook and generates dynamic CSS-in-JS
+ * styles based on the component theme and current prop values.
+ *
+ * @param componentTheme The theme variable object
+ * @param params The reactive parameters (props that affect styling)
+ * @return The final style object, which will be used in the component
+ */
+const generateStyle = (
+  componentTheme: LucideIconTheme,
+  params: StyleParams
+): LucideIconStyle => {
+  const { color, rotate = '0', bidirectional = true, inline = true } = params
+
+  // Color mapping (semantic colors from theme)
+  // Note: Size is no longer applied here - it's passed directly to Lucide as pixels
+  const colorVariants = {
+    inherit: { color: 'inherit' },
+    primary: { color: componentTheme.primaryColor },
+    secondary: { color: componentTheme.secondaryColor },
+    'primary-inverse': { color: componentTheme.primaryInverseColor },
+    'secondary-inverse': { color: componentTheme.secondaryInverseColor },
+    success: { color: componentTheme.successColor },
+    error: { color: componentTheme.errorColor },
+    warning: { color: componentTheme.warningColor },
+    alert: { color: componentTheme.alertColor },
+    brand: { color: componentTheme.brandColor }
+  }
+
+  // Rotation transforms (LTR context)
+  const rotateVariants = {
+    '0': {},
+    '90': { transform: 'rotate(90deg)' },
+    '180': { transform: 'rotate(180deg)' },
+    '270': { transform: 'rotate(270deg)' }
+  }
+
+  // Bidirectional + rotation (RTL context) - flip + rotate
+  const bidirectionalRotateVariants = {
+    '0': { transform: 'scaleX(-1)' },
+    '90': { transform: 'scaleX(-1) rotate(90deg)' },
+    '180': { transform: 'scaleX(-1) rotate(180deg)' },
+    '270': { transform: 'scaleX(-1) rotate(270deg)' }
+  }
+
+  return {
+    lucideIcon: {
+      label: 'lucideIcon',
+      display: inline ? 'inline-block' : 'block',
+      verticalAlign: 'middle',
+      lineHeight: 0, // Remove extra line-height to prevent wrapper from being taller than icon
+      fontSize: 0, // Remove font-size to prevent wrapper from having its own dimensions
+
+      // Apply color (semantic or custom)
+      ...(color &&
+        (colorVariants[color as keyof typeof colorVariants] || { color })),
+
+      // Apply rotation in LTR
+      ...rotateVariants[rotate],
+
+      // Apply bidirectional flip + rotation in RTL
+      ...(bidirectional && {
+        '[dir="rtl"] &': bidirectionalRotateVariants[rotate]
+      })
+    }
+  }
+}
+
+export default generateStyle
diff --git a/packages/ui-icons-lucide/src/wrapLucideIcon/theme.ts b/packages/ui-icons-lucide/src/wrapLucideIcon/theme.ts
new file mode 100644
index 0000000000..d4806043f4
--- /dev/null
+++ b/packages/ui-icons-lucide/src/wrapLucideIcon/theme.ts
@@ -0,0 +1,80 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import type { Theme } from '@instructure/ui-themes'
+
+export interface LucideIconTheme {
+  // Size variables (matching SVGIcon theme)
+  sizeXSmall: string
+  sizeSmall: string
+  sizeMedium: string
+  sizeLarge: string
+  sizeXLarge: string
+
+  // Color variables (matching InlineSVG theme)
+  primaryColor: string
+  secondaryColor: string
+  primaryInverseColor: string
+  secondaryInverseColor: string
+  successColor: string
+  errorColor: string
+  warningColor: string
+  alertColor: string
+  brandColor: string
+
+  // Index signature for ComponentTheme compatibility
+  [key: string]: string | undefined
+}
+
+/**
+ * Generates the theme object for Lucide icons from the global theme.
+ *
+ * This matches the theme variables from SVGIcon (sizes) and InlineSVG (colors)
+ * to ensure consistency across the InstUI icon system.
+ */
+const generateComponentTheme = (theme: Theme): LucideIconTheme => {
+  const { colors } = theme
+
+  return {
+    // Sizes from SVGIcon (1.125rem, 2rem, 3rem, 5rem, 10rem)
+    sizeXSmall: '1.125rem', // ~18px
+    sizeSmall: '2rem', // 32px
+    sizeMedium: '3rem', // 48px
+    sizeLarge: '5rem', // 80px
+    sizeXLarge: '10rem', // 160px
+
+    // Colors from InlineSVG theme
+    primaryColor: colors?.contrasts?.grey125125,
+    secondaryColor: colors?.contrasts?.grey4570,
+    primaryInverseColor: colors?.contrasts?.white1010,
+    secondaryInverseColor: colors?.contrasts?.grey1111,
+    successColor: colors?.contrasts?.green4570,
+    errorColor: colors?.contrasts?.red4570,
+    warningColor: colors?.contrasts?.orange4570,
+    alertColor: colors?.contrasts?.blue4570,
+    brandColor: colors?.contrasts?.blue4570
+  }
+}
+
+export default generateComponentTheme
diff --git a/packages/ui-icons-lucide/tsconfig.build.json b/packages/ui-icons-lucide/tsconfig.build.json
new file mode 100644
index 0000000000..3239812ccc
--- /dev/null
+++ b/packages/ui-icons-lucide/tsconfig.build.json
@@ -0,0 +1,29 @@
+{
+  "extends": "../../tsconfig.build.json",
+  "compilerOptions": {
+    "outDir": "./types",
+    "composite": true,
+    "rootDir": "./src"
+  },
+  "include": ["src"],
+  "references": [
+    {
+      "path": "../emotion/tsconfig.build.json"
+    },
+    {
+      "path": "../shared-types/tsconfig.build.json"
+    },
+    {
+      "path": "../ui-react-utils/tsconfig.build.json"
+    },
+    {
+      "path": "../ui-themes/tsconfig.build.json"
+    },
+    {
+      "path": "../ui-utils/tsconfig.build.json"
+    },
+    {
+      "path": "../ui-babel-preset/tsconfig.build.json"
+    }
+  ]
+}
diff --git a/packages/ui-icons-lucide/tsconfig.json b/packages/ui-icons-lucide/tsconfig.json
new file mode 100644
index 0000000000..2c520b5ab9
--- /dev/null
+++ b/packages/ui-icons-lucide/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "baseUrl": "./src"
+  },
+  "include": ["src"]
+}
diff --git a/packages/ui-icons-lucide/tsconfig.scripts.json b/packages/ui-icons-lucide/tsconfig.scripts.json
new file mode 100644
index 0000000000..be0c5797be
--- /dev/null
+++ b/packages/ui-icons-lucide/tsconfig.scripts.json
@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true
+  },
+  "include": ["scripts/**/*"],
+  "ts-node": {
+    "compilerOptions": {
+      "module": "commonjs"
+    }
+  }
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3d2193fd83..56614e1151 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -271,6 +271,9 @@ importers:
       '@instructure/ui-icons':
         specifier: workspace:*
         version: link:../ui-icons
+      '@instructure/ui-icons-lucide':
+        specifier: workspace:*
+        version: link:../ui-icons-lucide
       '@instructure/ui-img':
         specifier: workspace:*
         version: link:../ui-img
@@ -2414,6 +2417,40 @@ importers:
         specifier: workspace:*
         version: link:../ui-babel-preset
 
+  packages/ui-icons-lucide:
+    dependencies:
+      '@babel/runtime':
+        specifier: ^7.27.6
+        version: 7.28.4
+      '@instructure/emotion':
+        specifier: workspace:*
+        version: link:../emotion
+      '@instructure/shared-types':
+        specifier: workspace:*
+        version: link:../shared-types
+      '@instructure/ui-react-utils':
+        specifier: workspace:*
+        version: link:../ui-react-utils
+      '@instructure/ui-themes':
+        specifier: workspace:*
+        version: link:../ui-themes
+      '@instructure/ui-utils':
+        specifier: workspace:*
+        version: link:../ui-utils
+      lucide-react:
+        specifier: ^0.460.0
+        version: 0.460.0(react@18.3.1)
+    devDependencies:
+      '@instructure/ui-babel-preset':
+        specifier: workspace:*
+        version: link:../ui-babel-preset
+      '@types/node':
+        specifier: ^22.5.4
+        version: 22.18.10
+      ts-node:
+        specifier: ^10.9.2
+        version: 10.9.2(@types/node@22.18.10)(typescript@5.8.3)
+
   packages/ui-img:
     dependencies:
       '@babel/runtime':
@@ -5946,6 +5983,10 @@ packages:
     resolution: {integrity: sha512-bVUNBqG6aznYcYjTjnc3+Cat/iBgbgpflxbIBTnsHTX0YVpnmINPEkSRWymT2Q8aSH3Y7aKnEbunilkYe8TybA==}
     engines: {node: '>=v18'}
 
+  '@cspotcode/source-map-support@0.8.1':
+    resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
+    engines: {node: '>=12'}
+
   '@csstools/color-helpers@5.1.0':
     resolution: {integrity: sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==}
     engines: {node: '>=18'}
@@ -6314,6 +6355,9 @@ packages:
   '@jridgewell/trace-mapping@0.3.31':
     resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
 
+  '@jridgewell/trace-mapping@0.3.9':
+    resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
+
   '@jsonjoy.com/base64@1.1.2':
     resolution: {integrity: sha512-q6XAnWQDIMA3+FTiOYajoYqySkO+JSat0ytXGSuRdq9uXE7o92gzuQwQM14xaCRlBLGq3v5miDGC4vkVTn54xA==}
     engines: {node: '>=10.0'}
@@ -6791,6 +6835,18 @@ packages:
     resolution: {integrity: sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==}
     engines: {node: '>=10.13.0'}
 
+  '@tsconfig/node10@1.0.11':
+    resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==}
+
+  '@tsconfig/node12@1.0.11':
+    resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==}
+
+  '@tsconfig/node14@1.0.3':
+    resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==}
+
+  '@tsconfig/node16@1.0.4':
+    resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==}
+
   '@tufjs/canonical-json@2.0.0':
     resolution: {integrity: sha512-yVtV8zsdo8qFHe+/3kw81dSLyF7D576A5cCFCi4X7B39tWT7SekaEFUnvnWJHz+9qO7qJTah1JbrDjWKqFtdWA==}
     engines: {node: ^16.14.0 || >=18.0.0}
@@ -7351,6 +7407,9 @@ packages:
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
     deprecated: This package is no longer supported.
 
+  arg@4.1.3:
+    resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==}
+
   argparse@1.0.10:
     resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
 
@@ -8128,6 +8187,9 @@ packages:
     resolution: {integrity: sha512-gYTKKexFO3kh200H1Nit76sRwRtOY32vQd3jpAQKpLtZqyNsSQNfI4N7o3eP2wUjV35pTWKRYqFUDBvUha/Pkw==}
     engines: {node: '>=0.10.0'}
 
+  create-require@1.1.1:
+    resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
+
   crelt@1.0.6:
     resolution: {integrity: sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==}
 
@@ -8423,6 +8485,10 @@ packages:
     resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
+  diff@4.0.2:
+    resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
+    engines: {node: '>=0.3.1'}
+
   diff@5.2.0:
     resolution: {integrity: sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==}
     engines: {node: '>=0.3.1'}
@@ -10427,6 +10493,11 @@ packages:
   lru-queue@0.1.0:
     resolution: {integrity: sha512-BpdYkt9EvGl8OfWHDQPISVpcl5xZthb+XPsbELj5AQXxIC8IriDZIQYjBJPEm5rS420sjZ0TLEzRcq5KdBhYrQ==}
 
+  lucide-react@0.460.0:
+    resolution: {integrity: sha512-BVtq/DykVeIvRTJvRAgCsOwaGL8Un3Bxh8MbDxMhEWlZay3T4IpEKDEpwt5KZ0KJMHzgm6jrltxlT5eXOWXDHg==}
+    peerDependencies:
+      react: 18.3.1
+
   lz-string@1.5.0:
     resolution: {integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==}
     hasBin: true
@@ -10450,6 +10521,9 @@ packages:
     resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
     engines: {node: '>=10'}
 
+  make-error@1.3.6:
+    resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==}
+
   make-fetch-happen@10.2.1:
     resolution: {integrity: sha512-NgOPbRiaQM10DYXvN3/hhGVI2M5MtITFryzBGxHM5p4wnFxsVCbxkrBrDsk+EZ5OB4jEOT7AjDxtdF+KVEFT7w==}
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
@@ -12493,6 +12567,20 @@ packages:
     peerDependencies:
       typescript: '>=4.8.4'
 
+  ts-node@10.9.2:
+    resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==}
+    hasBin: true
+    peerDependencies:
+      '@swc/core': '>=1.2.50'
+      '@swc/wasm': '>=1.2.50'
+      '@types/node': '*'
+      typescript: '>=2.7'
+    peerDependenciesMeta:
+      '@swc/core':
+        optional: true
+      '@swc/wasm':
+        optional: true
+
   tsconfig-paths@4.2.0:
     resolution: {integrity: sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==}
     engines: {node: '>=6'}
@@ -12744,6 +12832,9 @@ packages:
     resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==}
     hasBin: true
 
+  v8-compile-cache-lib@3.0.1:
+    resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
+
   validate-npm-package-license@3.0.4:
     resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==}
 
@@ -13149,6 +13240,10 @@ packages:
   yauzl@2.10.0:
     resolution: {integrity: sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==}
 
+  yn@3.1.1:
+    resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==}
+    engines: {node: '>=6'}
+
   yocto-queue@0.1.0:
     resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
     engines: {node: '>=10'}
@@ -14287,6 +14382,10 @@ snapshots:
       chalk: 5.6.2
     optional: true
 
+  '@cspotcode/source-map-support@0.8.1':
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.9
+
   '@csstools/color-helpers@5.1.0': {}
 
   '@csstools/css-calc@2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)':
@@ -14630,6 +14729,11 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.5
 
+  '@jridgewell/trace-mapping@0.3.9':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+
   '@jsonjoy.com/base64@1.1.2(tslib@2.8.1)':
     dependencies:
       tslib: 2.8.1
@@ -15233,6 +15337,14 @@ snapshots:
 
   '@trysound/sax@0.2.0': {}
 
+  '@tsconfig/node10@1.0.11': {}
+
+  '@tsconfig/node12@1.0.11': {}
+
+  '@tsconfig/node14@1.0.3': {}
+
+  '@tsconfig/node16@1.0.4': {}
+
   '@tufjs/canonical-json@2.0.0': {}
 
   '@tufjs/models@2.0.1':
@@ -15869,6 +15981,8 @@ snapshots:
       delegates: 1.0.0
       readable-stream: 3.6.2
 
+  arg@4.1.3: {}
+
   argparse@1.0.10:
     dependencies:
       sprintf-js: 1.0.3
@@ -16790,6 +16904,8 @@ snapshots:
     dependencies:
       capture-stack-trace: 1.0.2
 
+  create-require@1.1.1: {}
+
   crelt@1.0.6: {}
 
   cross-spawn@5.1.0:
@@ -17101,6 +17217,8 @@ snapshots:
 
   diff-sequences@29.6.3: {}
 
+  diff@4.0.2: {}
+
   diff@5.2.0: {}
 
   dir-glob@3.0.1:
@@ -19563,6 +19681,10 @@ snapshots:
     dependencies:
       es5-ext: 0.10.64
 
+  lucide-react@0.460.0(react@18.3.1):
+    dependencies:
+      react: 18.3.1
+
   lz-string@1.5.0: {}
 
   magic-string@0.30.19:
@@ -19586,6 +19708,8 @@ snapshots:
     dependencies:
       semver: 7.7.3
 
+  make-error@1.3.6: {}
+
   make-fetch-happen@10.2.1:
     dependencies:
       agentkeepalive: 4.6.0
@@ -21965,6 +22089,24 @@ snapshots:
     dependencies:
       typescript: 5.8.3
 
+  ts-node@10.9.2(@types/node@22.18.10)(typescript@5.8.3):
+    dependencies:
+      '@cspotcode/source-map-support': 0.8.1
+      '@tsconfig/node10': 1.0.11
+      '@tsconfig/node12': 1.0.11
+      '@tsconfig/node14': 1.0.3
+      '@tsconfig/node16': 1.0.4
+      '@types/node': 22.18.10
+      acorn: 8.15.0
+      acorn-walk: 8.3.4
+      arg: 4.1.3
+      create-require: 1.1.1
+      diff: 4.0.2
+      make-error: 1.3.6
+      typescript: 5.8.3
+      v8-compile-cache-lib: 3.0.1
+      yn: 3.1.1
+
   tsconfig-paths@4.2.0:
     dependencies:
       json5: 2.2.3
@@ -22216,6 +22358,8 @@ snapshots:
 
   uuid@8.3.2: {}
 
+  v8-compile-cache-lib@3.0.1: {}
+
   validate-npm-package-license@3.0.4:
     dependencies:
       spdx-correct: 3.2.0
@@ -22745,6 +22889,8 @@ snapshots:
       buffer-crc32: 0.2.13
       fd-slicer: 1.1.0
 
+  yn@3.1.1: {}
+
   yocto-queue@0.1.0: {}
 
   yocto-queue@1.2.1: {}
diff --git a/tsconfig.references.json b/tsconfig.references.json
index ddbcf71c60..43e0ed20dd 100644
--- a/tsconfig.references.json
+++ b/tsconfig.references.json
@@ -123,6 +123,9 @@
     {
       "path": "./packages/ui-i18n/tsconfig.build.json"
     },
+    {
+      "path": "./packages/ui-icons-lucide/tsconfig.build.json"
+    },
     {
       "path": "./packages/ui-img/tsconfig.build.json"
     },