nexi-agent 0.1.1 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.d.cts CHANGED
@@ -1,5 +1,5 @@
1
1
  import * as react from 'react';
2
- import { ButtonHTMLAttributes, ReactNode } from 'react';
2
+ import { ButtonHTMLAttributes, ReactNode, CSSProperties, ElementType, MouseEvent, InputHTMLAttributes, FormEvent } from 'react';
3
3
  import * as class_variance_authority_types from 'class-variance-authority/types';
4
4
  import { VariantProps } from 'class-variance-authority';
5
5
  export { a as RECORD_TAG_PALETTE, R as RecordRow, b as RecordStrength, c as RecordTagColor, d as RecordsAiColumn, e as RecordsColumnConfig, f as RecordsColumnKey, g as RecordsPrompt, h as RecordsTable, i as RecordsTableLabels, j as RecordsTableProps, k as RecordsToolKind } from './RecordsTable-DHbIfUQH.cjs';
@@ -1151,6 +1151,1706 @@ type UsageMeterProps = {
1151
1151
  };
1152
1152
  declare function UsageMeter({ label, used: usedProp, limit, segments, format, warnAt, dangerAt, hint, className, }?: UsageMeterProps): react.JSX.Element;
1153
1153
 
1154
+ type AnimatedModalLabels = {
1155
+ close: string;
1156
+ };
1157
+ type AnimatedModalProps = {
1158
+ /** Trigger button text. */
1159
+ trigger?: ReactNode;
1160
+ /** Shown in place of the trigger text on hover. */
1161
+ triggerIcon?: ReactNode;
1162
+ title?: ReactNode;
1163
+ children?: ReactNode;
1164
+ /** Footer content; pass a function to get a `close` callback for your buttons. */
1165
+ footer?: ReactNode | ((close: () => void) => ReactNode);
1166
+ /** Controlled open state. */
1167
+ open?: boolean;
1168
+ defaultOpen?: boolean;
1169
+ onOpenChange?: (open: boolean) => void;
1170
+ labels?: Partial<AnimatedModalLabels>;
1171
+ /** Class for the modal panel. */
1172
+ className?: string;
1173
+ };
1174
+ declare function AnimatedModal({ trigger, triggerIcon, title, children, footer, open: controlled, defaultOpen, onOpenChange, labels, className, }: AnimatedModalProps): react.JSX.Element;
1175
+
1176
+ type AnimatedTab = {
1177
+ title: string;
1178
+ value: string;
1179
+ content?: ReactNode;
1180
+ };
1181
+ type AnimatedTabsProps = {
1182
+ tabs?: AnimatedTab[];
1183
+ defaultValue?: string;
1184
+ onValueChange?: (value: string) => void;
1185
+ className?: string;
1186
+ /** Height of the panel stack (px). */
1187
+ panelHeight?: number;
1188
+ };
1189
+ declare function AnimatedTabs({ tabs, defaultValue, onValueChange, className, panelHeight, }: AnimatedTabsProps): react.JSX.Element;
1190
+
1191
+ type Testimonial = {
1192
+ quote: string;
1193
+ name: string;
1194
+ designation?: string;
1195
+ /** Photo URL; falls back to a coloured monogram tile. */
1196
+ src?: string;
1197
+ color?: string;
1198
+ };
1199
+ type AnimatedTestimonialsLabels = {
1200
+ previous: string;
1201
+ next: string;
1202
+ };
1203
+ type AnimatedTestimonialsProps = {
1204
+ items?: Testimonial[];
1205
+ autoplay?: boolean;
1206
+ /** Milliseconds per testimonial when autoplaying. */
1207
+ interval?: number;
1208
+ labels?: Partial<AnimatedTestimonialsLabels>;
1209
+ className?: string;
1210
+ };
1211
+ declare function AnimatedTestimonials({ items, autoplay, interval, labels, className, }: AnimatedTestimonialsProps): react.JSX.Element;
1212
+
1213
+ type TooltipPerson = {
1214
+ id: string | number;
1215
+ name: string;
1216
+ designation?: string;
1217
+ /** Image URL; falls back to a coloured monogram. */
1218
+ image?: string;
1219
+ color?: string;
1220
+ };
1221
+ type AnimatedTooltipProps = {
1222
+ items?: TooltipPerson[];
1223
+ /** Avatar diameter in px. */
1224
+ size?: number;
1225
+ className?: string;
1226
+ };
1227
+ declare function AnimatedTooltip({ items, size, className }: AnimatedTooltipProps): react.JSX.Element;
1228
+
1229
+ type GlobeArc = {
1230
+ from: {
1231
+ lat: number;
1232
+ lng: number;
1233
+ };
1234
+ to: {
1235
+ lat: number;
1236
+ lng: number;
1237
+ };
1238
+ color?: string;
1239
+ };
1240
+ type ArcGlobeProps = {
1241
+ arcs?: GlobeArc[];
1242
+ /** Colours used for arcs without their own. */
1243
+ arcColors?: string[];
1244
+ dotColor?: string;
1245
+ /** Fill of the globe body. */
1246
+ oceanColor?: string;
1247
+ atmosphereColor?: string;
1248
+ /** How high arcs rise off the surface, 0–1. */
1249
+ arcHeight?: number;
1250
+ /** Seconds for one arc flight. */
1251
+ flightTime?: number;
1252
+ density?: number;
1253
+ autoRotate?: number;
1254
+ draggable?: boolean;
1255
+ focus?: {
1256
+ lat: number;
1257
+ lng: number;
1258
+ };
1259
+ size?: number;
1260
+ label?: string;
1261
+ className?: string;
1262
+ };
1263
+ declare function ArcGlobe({ arcs, arcColors, dotColor, oceanColor, atmosphereColor, arcHeight, flightTime, density, autoRotate, draggable, focus, size, label, className, }: ArcGlobeProps): react.JSX.Element;
1264
+
1265
+ type AsciiArtProps = {
1266
+ src?: string;
1267
+ /** Characters per row. */
1268
+ columns?: number;
1269
+ /** Characters from lightest to densest. */
1270
+ ramp?: string;
1271
+ /** Flip the ramp, for light text on a dark background. */
1272
+ invert?: boolean;
1273
+ /** Use the image's colours for each character. */
1274
+ colored?: boolean;
1275
+ /** Reveal the art row by row. */
1276
+ animate?: boolean;
1277
+ className?: string;
1278
+ };
1279
+ declare function AsciiArt({ src, columns, ramp, invert, colored, animate, className, }: AsciiArtProps): react.JSX.Element;
1280
+
1281
+ type AuroraBackgroundProps = {
1282
+ children?: ReactNode;
1283
+ /** Fade the aurora out away from the top-right so it reads as a light source. */
1284
+ showRadialGradient?: boolean;
1285
+ className?: string;
1286
+ };
1287
+ declare function AuroraBackground({ children, showRadialGradient, className }: AuroraBackgroundProps): react.JSX.Element;
1288
+
1289
+ type BackgroundBeamsProps = {
1290
+ children?: ReactNode;
1291
+ /** How many beams in the fan. */
1292
+ count?: number;
1293
+ className?: string;
1294
+ };
1295
+ declare function BackgroundBeams({ children, count, className }: BackgroundBeamsProps): react.JSX.Element;
1296
+
1297
+ type BackgroundBoxesProps = {
1298
+ children?: ReactNode;
1299
+ rows?: number;
1300
+ cols?: number;
1301
+ /** Tile size in px. */
1302
+ cellSize?: number;
1303
+ /** Tiles pick one of these at random when lit. */
1304
+ colors?: string[];
1305
+ /** Milliseconds a lit tile takes to fade out. */
1306
+ fadeMs?: number;
1307
+ className?: string;
1308
+ };
1309
+ declare function BackgroundBoxes({ children, rows, cols, cellSize, colors, fadeMs, className, }: BackgroundBoxesProps): react.JSX.Element;
1310
+
1311
+ type BackgroundCubesGridProps = {
1312
+ children?: ReactNode;
1313
+ rows?: number;
1314
+ cols?: number;
1315
+ /** Cube edge in px. */
1316
+ cellSize?: number;
1317
+ /** How high (px) the cube under the pointer rises. */
1318
+ lift?: number;
1319
+ /** How many cubes away the rise reaches. */
1320
+ reach?: number;
1321
+ /** Top-face colour of a raised cube. */
1322
+ color?: string;
1323
+ className?: string;
1324
+ };
1325
+ declare function BackgroundCubesGrid({ children, rows, cols, cellSize, lift, reach, color, className, }: BackgroundCubesGridProps): react.JSX.Element;
1326
+
1327
+ type BackgroundGradientProps = {
1328
+ children?: ReactNode;
1329
+ /** Colours around the frame, in order. */
1330
+ colors?: string[];
1331
+ /** Turn the colours around the frame. */
1332
+ animate?: boolean;
1333
+ /** Seconds for one full turn. */
1334
+ duration?: number;
1335
+ /** Frame thickness in px. */
1336
+ borderWidth?: number;
1337
+ /** Outer radius in px. */
1338
+ radius?: number;
1339
+ /** Class for the outer frame. */
1340
+ containerClassName?: string;
1341
+ /** Class for the inner face. */
1342
+ className?: string;
1343
+ };
1344
+ declare function BackgroundGradient({ children, colors, animate, duration, borderWidth, radius, containerClassName, className, }: BackgroundGradientProps): react.JSX.Element;
1345
+
1346
+ type GradientOrb = {
1347
+ /** Any CSS colour. */
1348
+ color: string;
1349
+ /** Resting position, in % of the container. */
1350
+ x: number;
1351
+ y: number;
1352
+ /** How far it drifts, in % of its own size. */
1353
+ drift?: number;
1354
+ /** Seconds per drift loop. */
1355
+ duration?: number;
1356
+ };
1357
+ type BackgroundGradientAnimationProps = {
1358
+ children?: ReactNode;
1359
+ /** Field gradient colours. */
1360
+ from?: string;
1361
+ to?: string;
1362
+ orbs?: GradientOrb[];
1363
+ /** Colour of the orb that follows the pointer. */
1364
+ pointerColor?: string;
1365
+ /** Orb diameter, any CSS length. */
1366
+ size?: string;
1367
+ /** How the orbs mix with each other. */
1368
+ blendMode?: CSSProperties["mixBlendMode"];
1369
+ /** Let an orb follow the pointer. */
1370
+ interactive?: boolean;
1371
+ className?: string;
1372
+ };
1373
+ declare function BackgroundGradientAnimation({ children, from, to, orbs, pointerColor, size, blendMode, interactive, className, }: BackgroundGradientAnimationProps): react.JSX.Element;
1374
+
1375
+ type BackgroundLinesProps = {
1376
+ children?: ReactNode;
1377
+ /** Number of curves. */
1378
+ count?: number;
1379
+ /** Colours the curves cycle through. */
1380
+ colors?: string[];
1381
+ /** Base seconds for one stroke to travel a curve. */
1382
+ duration?: number;
1383
+ className?: string;
1384
+ };
1385
+ declare function BackgroundLines({ children, count, colors, duration, className, }: BackgroundLinesProps): react.JSX.Element;
1386
+
1387
+ type BackgroundRippleEffectProps = {
1388
+ children?: ReactNode;
1389
+ rows?: number;
1390
+ cols?: number;
1391
+ /** Tile size in px. */
1392
+ cellSize?: number;
1393
+ /** Milliseconds for the ring to travel one tile. */
1394
+ stepMs?: number;
1395
+ /** fired with the clicked tile */
1396
+ onCellClick?: (row: number, col: number) => void;
1397
+ className?: string;
1398
+ };
1399
+ declare function BackgroundRippleEffect({ children, rows, cols, cellSize, stepMs, onCellClick, className, }: BackgroundRippleEffectProps): react.JSX.Element;
1400
+
1401
+ type FallingBeam = {
1402
+ /** Horizontal position, % of the width. */
1403
+ x: number;
1404
+ /** Seconds to fall the full height. */
1405
+ duration: number;
1406
+ /** Seconds before the first fall. */
1407
+ delay?: number;
1408
+ /** Beam length in px. */
1409
+ length?: number;
1410
+ };
1411
+ type BeamsWithCollisionProps = {
1412
+ children?: ReactNode;
1413
+ /** Explicit beams; otherwise `count` beams are placed for you. */
1414
+ beams?: FallingBeam[];
1415
+ count?: number;
1416
+ /** Colours of the beam head and the sparks. */
1417
+ color?: string;
1418
+ accentColor?: string;
1419
+ className?: string;
1420
+ };
1421
+ declare function BeamsWithCollision({ children, beams, count, color, accentColor, className, }: BeamsWithCollisionProps): react.JSX.Element;
1422
+
1423
+ type BentoGridProps = {
1424
+ /** Tiles to render; ignored when you pass children. */
1425
+ items?: BentoGridItemProps[];
1426
+ children?: ReactNode;
1427
+ className?: string;
1428
+ };
1429
+ type BentoGridItemProps = {
1430
+ title?: ReactNode;
1431
+ description?: ReactNode;
1432
+ header?: ReactNode;
1433
+ icon?: ReactNode;
1434
+ className?: string;
1435
+ };
1436
+ declare function BentoGridItem({ title, description, header, icon, className }: BentoGridItemProps): react.JSX.Element;
1437
+ declare function BentoGrid({ items, children, className }: BentoGridProps): react.JSX.Element;
1438
+
1439
+ type CanvasRevealEffectProps = {
1440
+ children?: ReactNode;
1441
+ /** Dot colours, any CSS colour. */
1442
+ colors?: string[];
1443
+ /** Dot size and spacing in px. */
1444
+ dotSize?: number;
1445
+ gap?: number;
1446
+ /** Milliseconds per px for the reveal wave to spread. */
1447
+ speed?: number;
1448
+ /** Background behind the dots while revealed. */
1449
+ revealBackground?: string;
1450
+ /** Force the reveal on (otherwise it follows hover). */
1451
+ active?: boolean;
1452
+ className?: string;
1453
+ };
1454
+ declare function CanvasRevealEffect({ children, colors, dotSize, gap, speed, revealBackground, active, className, }: CanvasRevealEffectProps): react.JSX.Element;
1455
+
1456
+ type CanvasTextProps = {
1457
+ text?: string;
1458
+ /** Colours of the flowing bands. */
1459
+ colors?: string[];
1460
+ /** Any CSS font weight and family for the lettering. */
1461
+ font?: string;
1462
+ /** Height of the canvas in px; the text is sized to fit it. */
1463
+ height?: number;
1464
+ /** Flow speed multiplier. */
1465
+ speed?: number;
1466
+ className?: string;
1467
+ };
1468
+ declare function CanvasText({ text, colors, font, height, speed, className, }: CanvasTextProps): react.JSX.Element;
1469
+
1470
+ type Card3DProps = {
1471
+ children?: ReactNode;
1472
+ /** Maximum turn in degrees. */
1473
+ maxTilt?: number;
1474
+ /** Class for the outer element that holds the perspective. */
1475
+ containerClassName?: string;
1476
+ className?: string;
1477
+ };
1478
+ declare function Card3D({ children, maxTilt, containerClassName, className }: Card3DProps): react.JSX.Element;
1479
+ type Card3DItemProps = {
1480
+ children?: ReactNode;
1481
+ /** Element to render. */
1482
+ as?: ElementType;
1483
+ /** How far (px) the item lifts toward the viewer on hover. */
1484
+ translateZ?: number;
1485
+ translateX?: number;
1486
+ translateY?: number;
1487
+ rotateX?: number;
1488
+ rotateY?: number;
1489
+ rotateZ?: number;
1490
+ className?: string;
1491
+ style?: CSSProperties;
1492
+ };
1493
+ declare function Card3DItem({ children, as: Tag, translateZ, translateX, translateY, rotateX, rotateY, rotateZ, className, style, }: Card3DItemProps): react.JSX.Element;
1494
+
1495
+ type HoverCardItem = {
1496
+ title: string;
1497
+ description: string;
1498
+ href?: string;
1499
+ };
1500
+ type CardHoverEffectProps = {
1501
+ items?: HoverCardItem[];
1502
+ /** fired when a card without an href is clicked */
1503
+ onSelect?: (item: HoverCardItem, index: number) => void;
1504
+ className?: string;
1505
+ };
1506
+ declare function CardHoverEffect({ items, onSelect, className }: CardHoverEffectProps): react.JSX.Element;
1507
+
1508
+ type StackCard = {
1509
+ id: string | number;
1510
+ name: string;
1511
+ designation?: string;
1512
+ content: ReactNode;
1513
+ };
1514
+ type CardStackProps = {
1515
+ items?: StackCard[];
1516
+ /** Vertical offset between stacked cards, px. */
1517
+ offset?: number;
1518
+ /** How much smaller each card behind is, 0–1. */
1519
+ scaleFactor?: number;
1520
+ /** Milliseconds between automatic shuffles; 0 turns it off. */
1521
+ interval?: number;
1522
+ className?: string;
1523
+ };
1524
+ declare function CardStack({ items, offset, scaleFactor, interval, className, }: CardStackProps): react.JSX.Element;
1525
+
1526
+ type CarouselCard = {
1527
+ category: string;
1528
+ title: string;
1529
+ /** Cover image URL. */
1530
+ image?: string;
1531
+ /** CSS background used when there's no image (a colour or gradient). */
1532
+ background?: string;
1533
+ /** Shown when the card is opened. */
1534
+ content?: ReactNode;
1535
+ };
1536
+ type CardsCarouselLabels = {
1537
+ previous: string;
1538
+ next: string;
1539
+ close: string;
1540
+ };
1541
+ type CardsCarouselProps = {
1542
+ items?: CarouselCard[];
1543
+ labels?: Partial<CardsCarouselLabels>;
1544
+ /** fired when a card is opened */
1545
+ onOpen?: (card: CarouselCard, index: number) => void;
1546
+ className?: string;
1547
+ };
1548
+ declare function CardsCarousel({ items, labels, onOpen, className }: CardsCarouselProps): react.JSX.Element;
1549
+
1550
+ type Carousel3DSlide = {
1551
+ src: string;
1552
+ title: string;
1553
+ /** Text of the button on the current slide. Leave out for no button. */
1554
+ action?: string;
1555
+ };
1556
+ type Carousel3DLabels = {
1557
+ previous: string;
1558
+ next: string;
1559
+ region: string;
1560
+ };
1561
+ type Carousel3DProps = {
1562
+ slides?: Carousel3DSlide[];
1563
+ /** Fired by the button on the current slide. */
1564
+ onAction?: (slide: Carousel3DSlide, index: number) => void;
1565
+ onIndexChange?: (index: number) => void;
1566
+ /** Slide width in px (shrinks to fit narrow screens). */
1567
+ slideWidth?: number;
1568
+ labels?: Partial<Carousel3DLabels>;
1569
+ className?: string;
1570
+ };
1571
+ declare function Carousel3D({ slides, onAction, onIndexChange, slideWidth, labels, className, }: Carousel3DProps): react.JSX.Element;
1572
+
1573
+ type ChromaticImageProps = {
1574
+ src?: string;
1575
+ alt?: string;
1576
+ /** Maximum channel split in px. */
1577
+ intensity?: number;
1578
+ /** Keep a small split even when the pointer is away. */
1579
+ idleSplit?: number;
1580
+ /** Corner radius in px. */
1581
+ radius?: number;
1582
+ className?: string;
1583
+ };
1584
+ declare function ChromaticImage({ src, alt, intensity, idleSplit, radius, className, }: ChromaticImageProps): react.JSX.Element;
1585
+
1586
+ type CipherCardProps = {
1587
+ /** Shown in the middle of the card. */
1588
+ children?: ReactNode;
1589
+ /** Characters the wall is made of. */
1590
+ charset?: string;
1591
+ /** Glow gradient colours. */
1592
+ colors?: [string, string];
1593
+ /** Glow radius in px. */
1594
+ radius?: number;
1595
+ className?: string;
1596
+ };
1597
+ declare function CipherCard({ children, charset, colors, radius, className, }: CipherCardProps): react.JSX.Element;
1598
+
1599
+ type CloudShaderProps = {
1600
+ children?: ReactNode;
1601
+ /** Sky gradient, top to bottom. */
1602
+ skyTop?: string;
1603
+ skyBottom?: string;
1604
+ /** Cloud colour as [r, g, b]. */
1605
+ cloudColor?: [number, number, number];
1606
+ /** 0–1: how much of the sky is covered. */
1607
+ coverage?: number;
1608
+ /** Drift speed multiplier. */
1609
+ speed?: number;
1610
+ /** Noise resolution divisor; higher is cheaper and softer. */
1611
+ resolution?: number;
1612
+ className?: string;
1613
+ };
1614
+ declare function CloudShader({ children, skyTop, skyBottom, cloudColor, coverage, speed, resolution, className, }: CloudShaderProps): react.JSX.Element;
1615
+
1616
+ type ColourfulTextProps = {
1617
+ text?: string;
1618
+ colors?: string[];
1619
+ /** Milliseconds between reshuffles. */
1620
+ interval?: number;
1621
+ className?: string;
1622
+ };
1623
+ declare function ColourfulText({ text, colors, interval, className }: ColourfulTextProps): react.JSX.Element;
1624
+
1625
+ type CometCardProps = {
1626
+ children?: ReactNode;
1627
+ /** Maximum tilt in degrees. */
1628
+ maxTilt?: number;
1629
+ /** How far (px) the card lifts toward the viewer on hover. */
1630
+ lift?: number;
1631
+ /** Corner radius in px. */
1632
+ radius?: number;
1633
+ className?: string;
1634
+ };
1635
+ declare function CometCard({ children, maxTilt, lift, radius, className }: CometCardProps): react.JSX.Element;
1636
+
1637
+ type CompareLabels = {
1638
+ before: string;
1639
+ after: string;
1640
+ handle: string;
1641
+ };
1642
+ type CompareProps = {
1643
+ /** Image on the left of the divider. */
1644
+ before?: string;
1645
+ /** Image on the right of the divider. */
1646
+ after?: string;
1647
+ /** Drag the handle, or follow the pointer on hover. */
1648
+ mode?: "drag" | "hover";
1649
+ /** Start position, 0–100. */
1650
+ initial?: number;
1651
+ /** Sweep back and forth until touched. */
1652
+ autoplay?: boolean;
1653
+ /** Show the before / after tags. */
1654
+ showLabels?: boolean;
1655
+ onChange?: (position: number) => void;
1656
+ aspectRatio?: string;
1657
+ labels?: Partial<CompareLabels>;
1658
+ className?: string;
1659
+ };
1660
+ declare function Compare({ before, after, mode, initial, autoplay, showLabels, onChange, aspectRatio, labels, className, }: CompareProps): react.JSX.Element;
1661
+
1662
+ type ContainerCoverProps = {
1663
+ children?: ReactNode;
1664
+ /** Colours of the light streaks. */
1665
+ colors?: string[];
1666
+ /** Number of streaks. */
1667
+ streaks?: number;
1668
+ className?: string;
1669
+ };
1670
+ declare function ContainerCover({ children, colors, streaks, className }: ContainerCoverProps): react.JSX.Element;
1671
+
1672
+ type ContainerScrollAnimationProps = {
1673
+ /** Heading above the frame. */
1674
+ title?: ReactNode;
1675
+ /** Shown inside the frame. */
1676
+ children?: ReactNode;
1677
+ /** Starting tilt in degrees. */
1678
+ tilt?: number;
1679
+ className?: string;
1680
+ };
1681
+ declare function ContainerScrollAnimation({ title, children, tilt, className }: ContainerScrollAnimationProps): react.JSX.Element;
1682
+
1683
+ type ContainerTextFlipProps = {
1684
+ words?: string[];
1685
+ /** Milliseconds each word stays. */
1686
+ interval?: number;
1687
+ /** Class for the box. */
1688
+ className?: string;
1689
+ /** Class for the word. */
1690
+ textClassName?: string;
1691
+ };
1692
+ declare function ContainerTextFlip({ words, interval, className, textClassName }: ContainerTextFlipProps): react.JSX.Element;
1693
+
1694
+ type DirectionAwareHoverProps = {
1695
+ src?: string;
1696
+ alt?: string;
1697
+ /** Caption shown over the picture on hover. */
1698
+ children?: ReactNode;
1699
+ /** Class for the outer card. */
1700
+ className?: string;
1701
+ /** Class for the caption. */
1702
+ childrenClassName?: string;
1703
+ };
1704
+ declare function DirectionAwareHover({ src, alt, children, className, childrenClassName }: DirectionAwareHoverProps): react.JSX.Element;
1705
+
1706
+ type DitherShaderProps = {
1707
+ /** Image to dither. Leave out for an animated plasma field. Must be same-origin or CORS-enabled. */
1708
+ src?: string;
1709
+ /** Palette from darkest to lightest; two colours give classic 1-bit dithering. */
1710
+ colors?: string[];
1711
+ /** Size of one dither pixel in CSS px. */
1712
+ pixelSize?: number;
1713
+ /** Animation speed multiplier. */
1714
+ speed?: number;
1715
+ /** Strength of the moving ripple of light, 0–1. */
1716
+ ripple?: number;
1717
+ /** Brightness contrast, 1 is neutral. */
1718
+ contrast?: number;
1719
+ /** Height of the canvas in px. */
1720
+ height?: number;
1721
+ /** Accessible description. */
1722
+ label?: string;
1723
+ className?: string;
1724
+ };
1725
+ declare function DitherShader({ src, colors, pixelSize, speed, ripple, contrast, height, label, className, }: DitherShaderProps): react.JSX.Element;
1726
+
1727
+ type DottedGlowBackgroundProps = {
1728
+ children?: ReactNode;
1729
+ /** Distance between dots in px. */
1730
+ gap?: number;
1731
+ /** Dot radius in px. */
1732
+ radius?: number;
1733
+ /** Share of dots that glow, 0–1. */
1734
+ glowRatio?: number;
1735
+ /** Dot colour. Defaults to the muted ink token. */
1736
+ color?: string;
1737
+ /** Glow colour. Defaults to the accent token. */
1738
+ glowColor?: string;
1739
+ /** Multiplier for how fast dots breathe. */
1740
+ speed?: number;
1741
+ className?: string;
1742
+ };
1743
+ declare function DottedGlowBackground({ children, gap, radius, glowRatio, color, glowColor, speed, className, }: DottedGlowBackgroundProps): react.JSX.Element;
1744
+
1745
+ type DraggableItem = {
1746
+ title: string;
1747
+ src?: string;
1748
+ /** Resting position, % of the table. */
1749
+ x: number;
1750
+ y: number;
1751
+ /** Resting tilt in degrees. */
1752
+ rotate?: number;
1753
+ };
1754
+ type DraggableCardsProps = {
1755
+ items?: DraggableItem[];
1756
+ /** Content shown on the table underneath the cards. */
1757
+ children?: ReactNode;
1758
+ /** Card width in px. */
1759
+ cardWidth?: number;
1760
+ /** 0–1: how quickly a flung card slows down (higher glides further). */
1761
+ friction?: number;
1762
+ className?: string;
1763
+ };
1764
+ declare function DraggableCards({ items, children, cardWidth, friction, className, }: DraggableCardsProps): react.JSX.Element;
1765
+
1766
+ declare const EFFECT_BUTTON_VARIANTS: readonly ["shimmer", "glow", "sketch", "lift", "outline", "gradient", "invert", "spotlight", "arrow"];
1767
+ type EffectButtonVariant = (typeof EFFECT_BUTTON_VARIANTS)[number];
1768
+ type EffectButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
1769
+ variant?: EffectButtonVariant;
1770
+ size?: "sm" | "md" | "lg";
1771
+ children?: ReactNode;
1772
+ };
1773
+ declare function EffectButton({ variant, size, className, children, onPointerMove, style, type, ...props }: EffectButtonProps): react.JSX.Element;
1774
+
1775
+ type EncryptedTextProps = {
1776
+ text?: string;
1777
+ /** Milliseconds between each character locking in. */
1778
+ revealDelay?: number;
1779
+ /** Milliseconds between glyph swaps for unrevealed characters. */
1780
+ flipDelay?: number;
1781
+ /** Glyphs to scramble through. */
1782
+ charset?: string;
1783
+ /** Replay the reveal each time the pointer enters. */
1784
+ replayOnHover?: boolean;
1785
+ className?: string;
1786
+ /** Class for characters that are still scrambled. */
1787
+ scrambledClassName?: string;
1788
+ /** Class for characters that have locked in. */
1789
+ revealedClassName?: string;
1790
+ };
1791
+ declare function EncryptedText({ text, revealDelay, flipDelay, charset, replayOnHover, className, scrambledClassName, revealedClassName, }: EncryptedTextProps): react.JSX.Element;
1792
+
1793
+ type ExpandableItem = {
1794
+ title: string;
1795
+ description?: string;
1796
+ /** Image URL shown on the row and as the card's cover. */
1797
+ src?: string;
1798
+ /** Button label on the row and the expanded card. */
1799
+ ctaText?: string;
1800
+ ctaHref?: string;
1801
+ /** Shown only in the expanded card. */
1802
+ content?: ReactNode;
1803
+ };
1804
+ type ExpandableCardLabels = {
1805
+ close: string;
1806
+ };
1807
+ type ExpandableCardProps = {
1808
+ items?: ExpandableItem[];
1809
+ labels?: Partial<ExpandableCardLabels>;
1810
+ /** fired when a row is opened */
1811
+ onOpen?: (item: ExpandableItem, index: number) => void;
1812
+ className?: string;
1813
+ };
1814
+ declare function ExpandableCard({ items, labels, onOpen, className }: ExpandableCardProps): react.JSX.Element;
1815
+
1816
+ type FileUploadLabels = {
1817
+ title: string;
1818
+ hint: string;
1819
+ drop: string;
1820
+ modified: string;
1821
+ };
1822
+ type FileUploadProps = {
1823
+ onChange?: (files: File[]) => void;
1824
+ /** Passed to the file input, e.g. "image/*,.pdf". */
1825
+ accept?: string;
1826
+ multiple?: boolean;
1827
+ labels?: Partial<FileUploadLabels>;
1828
+ className?: string;
1829
+ };
1830
+ declare function FileUpload({ onChange, accept, multiple, labels, className }: FileUploadProps): react.JSX.Element;
1831
+
1832
+ type FlipWordsProps = {
1833
+ words?: string[];
1834
+ /** Milliseconds each word stays on screen. */
1835
+ duration?: number;
1836
+ className?: string;
1837
+ };
1838
+ declare function FlipWords({ words, duration, className, }: FlipWordsProps): react.JSX.Element;
1839
+
1840
+ type DockItem = {
1841
+ title: string;
1842
+ icon: ReactNode;
1843
+ href?: string;
1844
+ onClick?: () => void;
1845
+ };
1846
+ type FloatingDockProps = {
1847
+ items?: DockItem[];
1848
+ /** Resting icon tile size (px). */
1849
+ baseSize?: number;
1850
+ /** Size of the tile directly under the pointer (px). */
1851
+ maxSize?: number;
1852
+ /** How far (px) from the pointer tiles still grow. */
1853
+ distance?: number;
1854
+ className?: string;
1855
+ };
1856
+ declare function FloatingDock({ items, baseSize, maxSize, distance, className, }: FloatingDockProps): react.JSX.Element;
1857
+
1858
+ type FloatingNavItem = {
1859
+ label: string;
1860
+ href: string;
1861
+ /** Shown instead of the label on narrow screens. */
1862
+ icon?: ReactNode;
1863
+ };
1864
+ type FloatingNavbarProps = {
1865
+ items?: FloatingNavItem[];
1866
+ /** Anything on the right, e.g. a sign-in button. */
1867
+ action?: ReactNode;
1868
+ /** Fired when a link is chosen; call preventDefault on the event to route client-side. */
1869
+ onNavigate?: (href: string, event: MouseEvent<HTMLAnchorElement>) => void;
1870
+ /** Pin to the top of the viewport (default) or sit in the normal flow. */
1871
+ fixed?: boolean;
1872
+ /** Always visible above this scroll distance (px). */
1873
+ threshold?: number;
1874
+ /** Marks a link as current. */
1875
+ activeHref?: string;
1876
+ className?: string;
1877
+ };
1878
+ declare function FloatingNavbar({ items, action, onNavigate, fixed, threshold, activeHref, className, }: FloatingNavbarProps): react.JSX.Element;
1879
+
1880
+ type FocusCard = {
1881
+ title: string;
1882
+ src: string;
1883
+ };
1884
+ type FocusCardsProps = {
1885
+ cards?: FocusCard[];
1886
+ /** fired when a card is clicked */
1887
+ onSelect?: (card: FocusCard, index: number) => void;
1888
+ className?: string;
1889
+ };
1890
+ declare function FocusCards({ cards, onSelect, className }: FocusCardsProps): react.JSX.Element;
1891
+
1892
+ type FollowingPointerProps = {
1893
+ children?: ReactNode;
1894
+ /** The tag beside the arrow, e.g. a name. Leave out for a bare arrow. */
1895
+ label?: ReactNode;
1896
+ /** Colour of the arrow and tag. */
1897
+ color?: string;
1898
+ className?: string;
1899
+ };
1900
+ declare function FollowingPointer({ children, label, color, className }: FollowingPointerProps): react.JSX.Element;
1901
+
1902
+ type GlareCardProps = {
1903
+ children?: ReactNode;
1904
+ /** Maximum tilt in degrees. */
1905
+ maxTilt?: number;
1906
+ className?: string;
1907
+ };
1908
+ declare function GlareCard({ children, maxTilt, className }: GlareCardProps): react.JSX.Element;
1909
+
1910
+ type GlobeMarker = {
1911
+ lat: number;
1912
+ lng: number;
1913
+ size?: number;
1914
+ };
1915
+ type GlobeProps = {
1916
+ markers?: GlobeMarker[];
1917
+ /** Land dot colour; defaults to the theme's ink colour. */
1918
+ dotColor?: string;
1919
+ markerColor?: string;
1920
+ /** Colour of the halo around the globe. */
1921
+ glowColor?: string;
1922
+ /** Number of sample points over the sphere; more is denser. */
1923
+ density?: number;
1924
+ /** Radians per second; 0 stops it. */
1925
+ autoRotate?: number;
1926
+ draggable?: boolean;
1927
+ /** Point that faces the viewer at the start. */
1928
+ focus?: {
1929
+ lat: number;
1930
+ lng: number;
1931
+ };
1932
+ /** Size of the square canvas in px (it shrinks to fit narrower containers). */
1933
+ size?: number;
1934
+ /** Accessible description. */
1935
+ label?: string;
1936
+ className?: string;
1937
+ };
1938
+ declare function Globe({ markers, dotColor, markerColor, glowColor, density, autoRotate, draggable, focus, size, label, className, }: GlobeProps): react.JSX.Element;
1939
+
1940
+ type GlowingEffectProps = {
1941
+ children?: ReactNode;
1942
+ /** Width of the lit arc in degrees. */
1943
+ spread?: number;
1944
+ /** How far (px) outside the card the pointer still lights it. */
1945
+ proximity?: number;
1946
+ /** Share of the card's middle (0–1) where the glow switches off. */
1947
+ inactiveZone?: number;
1948
+ /** Border thickness in px. */
1949
+ borderWidth?: number;
1950
+ /** Colours along the arc. */
1951
+ colors?: string[];
1952
+ /** Also draw a soft blurred glow outside the border. */
1953
+ glow?: boolean;
1954
+ /** Corner radius in px. */
1955
+ radius?: number;
1956
+ disabled?: boolean;
1957
+ className?: string;
1958
+ };
1959
+ declare function GlowingEffect({ children, spread, proximity, inactiveZone, borderWidth, colors, glow, radius, disabled, className, }: GlowingEffectProps): react.JSX.Element;
1960
+
1961
+ type GlowingStarsProps = {
1962
+ children?: ReactNode;
1963
+ columns?: number;
1964
+ rows?: number;
1965
+ /** How many stars glow at once while idle. */
1966
+ glowing?: number;
1967
+ /** Milliseconds between idle reshuffles. */
1968
+ interval?: number;
1969
+ glowColor?: string;
1970
+ className?: string;
1971
+ };
1972
+ declare function GlowingStars({ children, columns, rows, glowing, interval, glowColor, className, }: GlowingStarsProps): react.JSX.Element;
1973
+
1974
+ type GooeyInputLabels = {
1975
+ placeholder: string;
1976
+ open: string;
1977
+ submit: string;
1978
+ };
1979
+ type GooeyInputProps = {
1980
+ value?: string;
1981
+ defaultValue?: string;
1982
+ onChange?: (value: string) => void;
1983
+ /** Fired with the text when the user presses Enter or the button. */
1984
+ onSubmit?: (value: string) => void;
1985
+ /** Start open. */
1986
+ defaultExpanded?: boolean;
1987
+ /** Width (px) when open. */
1988
+ width?: number;
1989
+ labels?: Partial<GooeyInputLabels>;
1990
+ className?: string;
1991
+ };
1992
+ declare function GooeyInput({ value, defaultValue, onChange, onSubmit, defaultExpanded, width, labels, className, }: GooeyInputProps): react.JSX.Element;
1993
+
1994
+ type GridBackgroundVariant = "grid" | "grid-small" | "dot";
1995
+ type GridBackgroundProps = {
1996
+ variant?: GridBackgroundVariant;
1997
+ /** Fade the pattern out toward the edges. */
1998
+ fade?: boolean;
1999
+ children?: ReactNode;
2000
+ className?: string;
2001
+ };
2002
+ declare function GridBackground({ variant, fade, children, className }: GridBackgroundProps): react.JSX.Element;
2003
+
2004
+ type HeroHighlightProps = {
2005
+ children?: ReactNode;
2006
+ /** Radius (px) of the brightened area around the pointer. */
2007
+ radius?: number;
2008
+ /** Class for the outer panel. */
2009
+ containerClassName?: string;
2010
+ className?: string;
2011
+ };
2012
+ declare function HeroHighlight({ children, radius, containerClassName, className }: HeroHighlightProps): react.JSX.Element;
2013
+ type HighlightProps = {
2014
+ children?: ReactNode;
2015
+ /** Marker colours, left to right. */
2016
+ colors?: [string, string];
2017
+ /** Seconds for the stroke to sweep across. */
2018
+ duration?: number;
2019
+ className?: string;
2020
+ };
2021
+ declare function Highlight({ children, colors, duration, className }: HighlightProps): react.JSX.Element;
2022
+
2023
+ type HeroProduct = {
2024
+ title: string;
2025
+ thumbnail: string;
2026
+ href?: string;
2027
+ };
2028
+ type HeroParallaxProps = {
2029
+ /** Headline block shown at the top. */
2030
+ children?: ReactNode;
2031
+ products?: HeroProduct[];
2032
+ /** How far (px) rows slide over the scroll. */
2033
+ distance?: number;
2034
+ className?: string;
2035
+ };
2036
+ declare function HeroParallax({ children, products, distance, className }: HeroParallaxProps): react.JSX.Element;
2037
+
2038
+ type HoverBorderGradientProps = ButtonHTMLAttributes<HTMLButtonElement> & {
2039
+ /** Seconds for one orbit of the highlight. */
2040
+ duration?: number;
2041
+ /** Class for the inner face. */
2042
+ innerClassName?: string;
2043
+ };
2044
+ declare function HoverBorderGradient({ duration, className, innerClassName, children, style, ...props }: HoverBorderGradientProps): react.JSX.Element;
2045
+
2046
+ type ImageGenerationLoaderLabels = {
2047
+ generating: string;
2048
+ done: string;
2049
+ };
2050
+ type ImageGenerationLoaderProps = {
2051
+ src?: string;
2052
+ alt?: string;
2053
+ /** Controlled progress, 0–1. Leave out to run on a timer. */
2054
+ progress?: number;
2055
+ /** Timer length (ms) when uncontrolled. */
2056
+ duration?: number;
2057
+ /** Start over after finishing (uncontrolled only). */
2058
+ loop?: boolean;
2059
+ onComplete?: () => void;
2060
+ /** Show the status chip with the percentage. */
2061
+ showStatus?: boolean;
2062
+ /** CSS aspect ratio of the frame. */
2063
+ aspectRatio?: string;
2064
+ labels?: Partial<ImageGenerationLoaderLabels>;
2065
+ className?: string;
2066
+ };
2067
+ declare function ImageGenerationLoader({ src, alt, progress, duration, loop, onComplete, showStatus, aspectRatio, labels, className, }: ImageGenerationLoaderProps): react.JSX.Element;
2068
+
2069
+ type ImagesBadgeProps = {
2070
+ /** Badge text. */
2071
+ children?: ReactNode;
2072
+ /** Thumbnail URLs (the first four are shown). */
2073
+ images?: string[];
2074
+ /** Thumbnail size in px. */
2075
+ size?: number;
2076
+ /** Makes the badge a link. */
2077
+ href?: string;
2078
+ onClick?: () => void;
2079
+ className?: string;
2080
+ };
2081
+ declare function ImagesBadge({ children, images, size, href, onClick, className }: ImagesBadgeProps): react.JSX.Element;
2082
+
2083
+ type ImagesSliderLabels = {
2084
+ previous: string;
2085
+ next: string;
2086
+ goTo: (n: number) => string;
2087
+ };
2088
+ type ImagesSliderProps = {
2089
+ images?: string[];
2090
+ /** Content shown over the slides. */
2091
+ children?: ReactNode;
2092
+ autoplay?: boolean;
2093
+ /** Milliseconds per slide when autoplaying. */
2094
+ interval?: number;
2095
+ /** Which way new slides enter from. */
2096
+ direction?: "up" | "down";
2097
+ /** Darken the slides so text on top stays readable. */
2098
+ overlay?: boolean;
2099
+ labels?: Partial<ImagesSliderLabels>;
2100
+ className?: string;
2101
+ };
2102
+ declare function ImagesSlider({ images, children, autoplay, interval, direction, overlay, labels, className, }: ImagesSliderProps): react.JSX.Element;
2103
+
2104
+ type MovingCardItem = {
2105
+ quote: string;
2106
+ name: string;
2107
+ title?: string;
2108
+ };
2109
+ type InfiniteMovingCardsProps = {
2110
+ items?: MovingCardItem[];
2111
+ direction?: "left" | "right";
2112
+ /** Preset speed, or seconds for one full loop. */
2113
+ speed?: "fast" | "normal" | "slow" | number;
2114
+ pauseOnHover?: boolean;
2115
+ className?: string;
2116
+ };
2117
+ declare function InfiniteMovingCards({ items, direction, speed, pauseOnHover, className, }: InfiniteMovingCardsProps): react.JSX.Element;
2118
+
2119
+ type KeyboardKey = {
2120
+ /** Text on the keycap. */
2121
+ label: string;
2122
+ /** `KeyboardEvent.code` this key mirrors (e.g. "KeyA", "Space"). */
2123
+ code: string;
2124
+ /** Width in key units (1 = a letter key). */
2125
+ width?: number;
2126
+ };
2127
+ type KeyboardProps = {
2128
+ /** Rows of keys; defaults to a standard US layout. */
2129
+ layout?: KeyboardKey[][];
2130
+ /** Light keys when the matching physical key is pressed. */
2131
+ listen?: boolean;
2132
+ /** Key codes to show highlighted, e.g. a shortcut you're teaching. */
2133
+ highlight?: string[];
2134
+ /** Size of one key unit in px. */
2135
+ unit?: number;
2136
+ /** fired when a key is clicked or pressed */
2137
+ onKeyPress?: (key: KeyboardKey) => void;
2138
+ className?: string;
2139
+ };
2140
+ declare const KEYBOARD_US: KeyboardKey[][];
2141
+ declare function Keyboard({ layout, listen, highlight, unit, onKeyPress, className, }: KeyboardProps): react.JSX.Element;
2142
+
2143
+ type LampEffectProps = {
2144
+ children?: ReactNode;
2145
+ /** Colour of the light. */
2146
+ color?: string;
2147
+ /** Background behind the light. */
2148
+ background?: string;
2149
+ className?: string;
2150
+ };
2151
+ declare function LampEffect({ children, color, background, className, }: LampEffectProps): react.JSX.Element;
2152
+
2153
+ type LaptopScrollProps = {
2154
+ /** Screenshot shown on the screen. */
2155
+ src?: string;
2156
+ /** Heading above the laptop. */
2157
+ title?: ReactNode;
2158
+ /** Small badge on the deck, e.g. a logo. */
2159
+ badge?: ReactNode;
2160
+ /** Total scroll length of the section, any CSS length. */
2161
+ scrollLength?: string;
2162
+ className?: string;
2163
+ };
2164
+ declare function LaptopScroll({ src, title, badge, scrollLength, className }: LaptopScrollProps): react.JSX.Element;
2165
+
2166
+ type LayoutGridCard = {
2167
+ src: string;
2168
+ alt?: string;
2169
+ /** Shown over the picture when it is open. */
2170
+ content?: ReactNode;
2171
+ /** Take two columns (wide) or two rows (tall). */
2172
+ span?: "wide" | "tall";
2173
+ };
2174
+ type LayoutGridProps = {
2175
+ cards?: LayoutGridCard[];
2176
+ onSelect?: (card: LayoutGridCard | null, index: number | null) => void;
2177
+ /** Height (px) of one grid row. */
2178
+ rowHeight?: number;
2179
+ className?: string;
2180
+ };
2181
+ declare function LayoutGrid({ cards, onSelect, rowHeight, className }: LayoutGridProps): react.JSX.Element;
2182
+
2183
+ type LayoutTextFlipProps = {
2184
+ /** The fixed phrase before the flipping word. */
2185
+ text?: string;
2186
+ words?: string[];
2187
+ /** Milliseconds each word stays. */
2188
+ interval?: number;
2189
+ className?: string;
2190
+ };
2191
+ declare function LayoutTextFlip({ text, words, interval, className }: LayoutTextFlipProps): react.JSX.Element;
2192
+
2193
+ type LensProps = {
2194
+ children?: ReactNode;
2195
+ /** Magnification. */
2196
+ zoom?: number;
2197
+ /** Lens diameter in px. */
2198
+ size?: number;
2199
+ /** Keep the lens at a fixed spot (in px) instead of following the pointer. */
2200
+ position?: {
2201
+ x: number;
2202
+ y: number;
2203
+ };
2204
+ className?: string;
2205
+ };
2206
+ declare function Lens({ children, zoom, size, position, className }: LensProps): react.JSX.Element;
2207
+
2208
+ type LinkPreviewProps = {
2209
+ url?: string;
2210
+ /** Link text. Defaults to the URL's host name. */
2211
+ children?: ReactNode;
2212
+ /** Screenshot or image of the page. */
2213
+ image?: string;
2214
+ /** Shown on the generated card when there's no image. */
2215
+ title?: string;
2216
+ description?: string;
2217
+ width?: number;
2218
+ height?: number;
2219
+ /** Open in a new tab. */
2220
+ newTab?: boolean;
2221
+ className?: string;
2222
+ };
2223
+ declare function LinkPreview({ url, children, image, title, description, width, height, newTab, className, }: LinkPreviewProps): react.JSX.Element;
2224
+
2225
+ type LiquidGlassProps = {
2226
+ children?: ReactNode;
2227
+ /** Frost blur in px. */
2228
+ blur?: number;
2229
+ /** How strongly the edges bend what's behind (0 turns it off). */
2230
+ refraction?: number;
2231
+ /** Tint over the glass, any CSS colour. */
2232
+ tint?: string;
2233
+ /** Corner radius in px. */
2234
+ radius?: number;
2235
+ className?: string;
2236
+ };
2237
+ declare function LiquidGlass({ children, blur, refraction, tint, radius, className, }: LiquidGlassProps): react.JSX.Element;
2238
+
2239
+ type MagneticButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
2240
+ /** How strongly the button follows the pointer (0–1). */
2241
+ strength?: number;
2242
+ /** Extra distance (px) around the button where the pull starts. */
2243
+ radius?: number;
2244
+ children?: ReactNode;
2245
+ };
2246
+ declare function MagneticButton({ strength, radius, className, children, type, ...props }: MagneticButtonProps): react.JSX.Element;
2247
+
2248
+ type Marquee3DProps = {
2249
+ images?: string[];
2250
+ /** Number of columns. */
2251
+ columns?: number;
2252
+ /** Seconds for one full loop of a column; lower is faster. */
2253
+ duration?: number;
2254
+ /** Height of the frame in px. */
2255
+ height?: number;
2256
+ className?: string;
2257
+ };
2258
+ declare function Marquee3D({ images, columns, duration, height, className }: Marquee3DProps): react.JSX.Element;
2259
+
2260
+ type MeteorsProps = {
2261
+ /** How many meteors. */
2262
+ number?: number;
2263
+ children?: ReactNode;
2264
+ className?: string;
2265
+ };
2266
+ declare function Meteors({ number, children, className }: MeteorsProps): react.JSX.Element;
2267
+
2268
+ type MovingBorderProps = ButtonHTMLAttributes<HTMLButtonElement> & {
2269
+ /** Milliseconds for one lap of the glow. */
2270
+ duration?: number;
2271
+ /** Corner radius in px (outer edge). */
2272
+ radius?: number;
2273
+ /** Border thickness in px. */
2274
+ borderWidth?: number;
2275
+ /** Colour of the travelling glow. Defaults to the accent token. */
2276
+ glowColor?: string;
2277
+ /** Class for the inner face of the button. */
2278
+ innerClassName?: string;
2279
+ };
2280
+ declare function MovingBorder({ duration, radius, borderWidth, glowColor, className, innerClassName, children, style, ...props }: MovingBorderProps): react.JSX.Element;
2281
+
2282
+ type NavbarLink = {
2283
+ title: string;
2284
+ href: string;
2285
+ description?: string;
2286
+ };
2287
+ type NavbarItem = {
2288
+ label: string;
2289
+ /** Where the item goes when it has no dropdown. */
2290
+ href?: string;
2291
+ /** Links shown in the dropdown. */
2292
+ links?: NavbarLink[];
2293
+ };
2294
+ type NavbarMenuProps = {
2295
+ items?: NavbarItem[];
2296
+ /** fired when a link is chosen; call preventDefault on the event to route client-side */
2297
+ onNavigate?: (href: string, event: React.MouseEvent<HTMLAnchorElement>) => void;
2298
+ className?: string;
2299
+ };
2300
+ declare function NavbarMenu({ items, onNavigate, className }: NavbarMenuProps): react.JSX.Element;
2301
+
2302
+ type NoiseBackgroundProps = {
2303
+ children?: ReactNode;
2304
+ /** Three or more colours for the drifting washes. */
2305
+ colors?: string[];
2306
+ /** Grain strength, 0–1. */
2307
+ grain?: number;
2308
+ /** Seconds for one full drift; lower is faster. 0 stops it. */
2309
+ duration?: number;
2310
+ /** Width (px) of the coloured rim; 0 fills the whole box. */
2311
+ inset?: number;
2312
+ className?: string;
2313
+ /** Classes for the inner panel (the area that holds children). */
2314
+ innerClassName?: string;
2315
+ };
2316
+ declare function NoiseBackground({ children, colors, grain, duration, inset, className, innerClassName, }: NoiseBackgroundProps): react.JSX.Element;
2317
+
2318
+ type NotchLabels = {
2319
+ expand: string;
2320
+ };
2321
+ type NotchProps = {
2322
+ /** The glance shown while closed, e.g. a status dot and a word. */
2323
+ collapsed?: ReactNode;
2324
+ /** The full panel shown while open. */
2325
+ children?: ReactNode;
2326
+ /** Controlled open state. */
2327
+ expanded?: boolean;
2328
+ defaultExpanded?: boolean;
2329
+ onExpandedChange?: (expanded: boolean) => void;
2330
+ /** Open on click (default) or on hover. */
2331
+ trigger?: "click" | "hover";
2332
+ /** Size (px) when closed and when open. */
2333
+ collapsedSize?: {
2334
+ width: number;
2335
+ height: number;
2336
+ };
2337
+ expandedSize?: {
2338
+ width: number;
2339
+ height: number;
2340
+ };
2341
+ labels?: Partial<NotchLabels>;
2342
+ className?: string;
2343
+ };
2344
+ declare function Notch({ collapsed, children, expanded, defaultExpanded, onExpandedChange, trigger, collapsedSize, expandedSize, labels, className, }: NotchProps): react.JSX.Element;
2345
+
2346
+ type ParallaxImage = {
2347
+ src: string;
2348
+ alt?: string;
2349
+ /** Position of the image centre, % of the hero. */
2350
+ x: number;
2351
+ y: number;
2352
+ /** Width in px. */
2353
+ width: number;
2354
+ /** 0 (far, barely moves) … 1 (near, moves most). */
2355
+ depth: number;
2356
+ /** Resting tilt in degrees. */
2357
+ rotate?: number;
2358
+ };
2359
+ type ParallaxHeroImagesProps = {
2360
+ children?: ReactNode;
2361
+ images?: ParallaxImage[];
2362
+ /** Maximum shift in px for depth 1. */
2363
+ strength?: number;
2364
+ className?: string;
2365
+ };
2366
+ declare function ParallaxHeroImages({ children, images, strength, className }: ParallaxHeroImagesProps): react.JSX.Element;
2367
+
2368
+ type ParallaxScrollProps = {
2369
+ images?: string[];
2370
+ /** How far (px) the columns travel over the whole scroll. */
2371
+ distance?: number;
2372
+ className?: string;
2373
+ };
2374
+ declare function ParallaxScroll({ images, distance, className }: ParallaxScrollProps): react.JSX.Element;
2375
+
2376
+ type Pin3DProps = {
2377
+ children?: ReactNode;
2378
+ /** Text of the floating tag. */
2379
+ title?: ReactNode;
2380
+ /** Where the tag links to. */
2381
+ href?: string;
2382
+ onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
2383
+ /** Colour of the beam and ripples. */
2384
+ color?: string;
2385
+ className?: string;
2386
+ /** Classes for the card itself. */
2387
+ cardClassName?: string;
2388
+ };
2389
+ declare function Pin3D({ children, title, href, onClick, color, className, cardClassName, }: Pin3DProps): react.JSX.Element;
2390
+
2391
+ type PixelatedCanvasProps = {
2392
+ src?: string;
2393
+ /** Canvas size in px. */
2394
+ width?: number;
2395
+ height?: number;
2396
+ /** Pixel cell size in px. */
2397
+ cellSize?: number;
2398
+ /** Gap between cells as a share of the cell, 0–0.5. */
2399
+ gap?: number;
2400
+ /** Cell shape. */
2401
+ shape?: "square" | "circle";
2402
+ /** How far (px) the pointer's push reaches. */
2403
+ radius?: number;
2404
+ /** How hard cells are pushed away. */
2405
+ strength?: number;
2406
+ className?: string;
2407
+ };
2408
+ declare function PixelatedCanvas({ src, width, height, cellSize, gap, shape, radius, strength, className, }: PixelatedCanvasProps): react.JSX.Element;
2409
+
2410
+ type PointerHighlightProps = {
2411
+ children?: ReactNode;
2412
+ /** Colour of the box and the cursor. */
2413
+ color?: string;
2414
+ /** Milliseconds the box takes to draw. */
2415
+ duration?: number;
2416
+ className?: string;
2417
+ /** Classes for the drawn box. */
2418
+ boxClassName?: string;
2419
+ };
2420
+ declare function PointerHighlight({ children, color, duration, className, boxClassName, }: PointerHighlightProps): react.JSX.Element;
2421
+
2422
+ type ResizableNavItem = {
2423
+ label: string;
2424
+ href: string;
2425
+ };
2426
+ type ResizableNavbarLabels = {
2427
+ openMenu: string;
2428
+ closeMenu: string;
2429
+ };
2430
+ type ResizableNavbarProps = {
2431
+ /** Brand mark on the left. */
2432
+ logo?: ReactNode;
2433
+ items?: ResizableNavItem[];
2434
+ /** Buttons on the right (and at the foot of the mobile menu). */
2435
+ actions?: ReactNode;
2436
+ /** Fired when a link is chosen; call preventDefault on the event to route client-side. */
2437
+ onNavigate?: (href: string, event: MouseEvent<HTMLAnchorElement>) => void;
2438
+ /** Scroll distance (px) after which the bar tucks in. */
2439
+ threshold?: number;
2440
+ /** Width (px) of the bar at rest and when tucked in. */
2441
+ width?: number;
2442
+ compactWidth?: number;
2443
+ /** How the bar stays on screen. */
2444
+ position?: "sticky" | "fixed" | "static";
2445
+ labels?: Partial<ResizableNavbarLabels>;
2446
+ className?: string;
2447
+ };
2448
+ declare function ResizableNavbar({ logo, items, actions, onNavigate, threshold, width, compactWidth, position, labels, className, }: ResizableNavbarProps): react.JSX.Element;
2449
+
2450
+ type ScalesProps = {
2451
+ children?: ReactNode;
2452
+ /** Distance between ticks in px. */
2453
+ spacing?: number;
2454
+ /** A long, labelled tick every N ticks. */
2455
+ majorEvery?: number;
2456
+ /** Print numbers on the long ticks. */
2457
+ showLabels?: boolean;
2458
+ /** How far (px) from the pointer ticks react. */
2459
+ reach?: number;
2460
+ className?: string;
2461
+ };
2462
+ declare function Scales({ children, spacing, majorEvery, showLabels, reach, className, }: ScalesProps): react.JSX.Element;
2463
+
2464
+ type ScrollPathsEffectProps = {
2465
+ children?: ReactNode;
2466
+ /** One colour per ribbon. */
2467
+ colors?: string[];
2468
+ /** Total scroll length of the section, any CSS length. */
2469
+ scrollLength?: string;
2470
+ className?: string;
2471
+ };
2472
+ declare function ScrollPathsEffect({ children, colors, scrollLength, className, }: ScrollPathsEffectProps): react.JSX.Element;
2473
+
2474
+ type ShootingStarsProps = {
2475
+ children?: ReactNode;
2476
+ /** Background stars per 10,000 px². */
2477
+ starDensity?: number;
2478
+ /** Milliseconds between shooting stars (random within the range). */
2479
+ minDelay?: number;
2480
+ maxDelay?: number;
2481
+ /** Shooting-star speed in px per frame. */
2482
+ minSpeed?: number;
2483
+ maxSpeed?: number;
2484
+ starColor?: string;
2485
+ trailColor?: string;
2486
+ background?: string;
2487
+ className?: string;
2488
+ };
2489
+ declare function ShootingStars({ children, starDensity, minDelay, maxDelay, minSpeed, maxSpeed, starColor, trailColor, background, className, }: ShootingStarsProps): react.JSX.Element;
2490
+
2491
+ type GlowInputProps = InputHTMLAttributes<HTMLInputElement> & {
2492
+ /** Colour of the glow that follows the pointer. */
2493
+ glowColor?: string;
2494
+ /** Classes for the wrapper that carries the glow. */
2495
+ wrapperClassName?: string;
2496
+ };
2497
+ declare function GlowInput({ glowColor, wrapperClassName, className, ...props }: GlowInputProps): react.JSX.Element;
2498
+ type SignupField = {
2499
+ name: string;
2500
+ label: string;
2501
+ type?: string;
2502
+ placeholder?: string;
2503
+ autoComplete?: string;
2504
+ required?: boolean;
2505
+ /** Share a row with the next half-width field. */
2506
+ half?: boolean;
2507
+ };
2508
+ type SignupProvider = {
2509
+ id: string;
2510
+ label: string;
2511
+ icon?: ReactNode;
2512
+ };
2513
+ type SignupFormLabels = {
2514
+ firstName: string;
2515
+ lastName: string;
2516
+ email: string;
2517
+ password: string;
2518
+ submit: string;
2519
+ submitting: string;
2520
+ divider: string;
2521
+ };
2522
+ type SignupFormProps = {
2523
+ title?: ReactNode;
2524
+ description?: ReactNode;
2525
+ /** Replace the standard name / email / password fields. */
2526
+ fields?: SignupField[];
2527
+ /** Sign-in-with buttons shown under the divider. */
2528
+ providers?: SignupProvider[];
2529
+ /** Receives every field's value by name. */
2530
+ onSubmit?: (values: Record<string, string>, event: FormEvent<HTMLFormElement>) => void;
2531
+ onProvider?: (id: string) => void;
2532
+ /** Disables the form and shows the submitting label. */
2533
+ submitting?: boolean;
2534
+ /** Anything under the form, e.g. terms or a sign-in link. */
2535
+ footer?: ReactNode;
2536
+ labels?: Partial<SignupFormLabels>;
2537
+ className?: string;
2538
+ };
2539
+ declare function SignupForm({ title, description, fields, providers, onSubmit, onProvider, submitting, footer, labels, className, }: SignupFormProps): react.JSX.Element;
2540
+
2541
+ type SparklesProps = {
2542
+ children?: ReactNode;
2543
+ /** Particles per 100,000 px² of area. */
2544
+ density?: number;
2545
+ minSize?: number;
2546
+ maxSize?: number;
2547
+ /** Multiplier for drift and twinkle speed. */
2548
+ speed?: number;
2549
+ /** Any CSS colour. Defaults to the ink token, so it follows dark mode. */
2550
+ particleColor?: string;
2551
+ className?: string;
2552
+ };
2553
+ declare function Sparkles({ children, density, minSize, maxSize, speed, particleColor, className, }: SparklesProps): react.JSX.Element;
2554
+
2555
+ type SpotlightProps = {
2556
+ children?: ReactNode;
2557
+ /** Beam colour. */
2558
+ color?: string;
2559
+ /** Where the beam comes from. */
2560
+ from?: "top-left" | "top-right";
2561
+ /** Beam strength, 0–1. */
2562
+ intensity?: number;
2563
+ className?: string;
2564
+ };
2565
+ declare function Spotlight({ children, color, from, intensity, className, }: SpotlightProps): react.JSX.Element;
2566
+
2567
+ type SpotlightCardProps = {
2568
+ children?: ReactNode;
2569
+ /** Spotlight radius in px. */
2570
+ radius?: number;
2571
+ /** Show the dot pattern inside the spotlight. */
2572
+ dots?: boolean;
2573
+ className?: string;
2574
+ };
2575
+ declare function SpotlightCard({ children, radius, dots, className }: SpotlightCardProps): react.JSX.Element;
2576
+
2577
+ type SpotlightNewProps = {
2578
+ children?: ReactNode;
2579
+ /** Light colour as "h, s%, l%" so it can be layered at different strengths. */
2580
+ hsl?: string;
2581
+ /** How far (px) the banks sway. */
2582
+ sway?: number;
2583
+ /** Seconds per sway. */
2584
+ duration?: number;
2585
+ /** Width of each beam in px. */
2586
+ beamWidth?: number;
2587
+ className?: string;
2588
+ };
2589
+ declare function SpotlightNew({ children, hsl, sway, duration, beamWidth, className, }: SpotlightNewProps): react.JSX.Element;
2590
+
2591
+ type SquigglyTextProps = {
2592
+ children?: ReactNode;
2593
+ /** How far (px) the letters bend. */
2594
+ intensity?: number;
2595
+ /** How many times per second the wobble changes. */
2596
+ fps?: number;
2597
+ /** Noise scale; higher is a finer, busier wobble. */
2598
+ frequency?: number;
2599
+ className?: string;
2600
+ };
2601
+ declare function SquigglyText({ children, intensity, fps, frequency, className }: SquigglyTextProps): react.JSX.Element;
2602
+
2603
+ type StatefulButtonState = "idle" | "loading" | "success" | "error";
2604
+ type StatefulButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> & {
2605
+ /** Return a promise to drive the loading → success / error states. */
2606
+ onClick?: (e: MouseEvent<HTMLButtonElement>) => unknown;
2607
+ /** How long the success / error state stays before returning to idle (ms). */
2608
+ resetAfter?: number;
2609
+ children?: ReactNode;
2610
+ };
2611
+ declare function StatefulButton({ onClick, resetAfter, className, children, disabled, ...props }: StatefulButtonProps): react.JSX.Element;
2612
+
2613
+ type StickyBannerLabels = {
2614
+ close: string;
2615
+ region: string;
2616
+ };
2617
+ type StickyBannerProps = {
2618
+ children?: ReactNode;
2619
+ /** Show a close button. */
2620
+ dismissible?: boolean;
2621
+ /** Fired after the banner is dismissed. */
2622
+ onClose?: () => void;
2623
+ /** Slide away after this scroll distance (px); set to 0 to always stay. */
2624
+ hideAfter?: number;
2625
+ labels?: Partial<StickyBannerLabels>;
2626
+ className?: string;
2627
+ };
2628
+ declare function StickyBanner({ children, dismissible, onClose, hideAfter, labels, className, }: StickyBannerProps): react.JSX.Element;
2629
+
2630
+ type StickySection = {
2631
+ title: string;
2632
+ description: string;
2633
+ /** What the pinned panel shows for this section. */
2634
+ content?: ReactNode;
2635
+ };
2636
+ type StickyScrollRevealProps = {
2637
+ items?: StickySection[];
2638
+ /** Box background per section (cycled). */
2639
+ backgrounds?: string[];
2640
+ /** Pinned panel background per section (cycled). */
2641
+ panelBackgrounds?: string[];
2642
+ /** Height of the scrolling box, any CSS length. */
2643
+ height?: string;
2644
+ className?: string;
2645
+ };
2646
+ declare function StickyScrollReveal({ items, backgrounds, panelBackgrounds, height, className, }: StickyScrollRevealProps): react.JSX.Element;
2647
+
2648
+ type SvgMaskEffectProps = {
2649
+ /** What's on the surface. */
2650
+ children?: ReactNode;
2651
+ /** What's seen through the lens. */
2652
+ revealContent?: ReactNode;
2653
+ /** Lens diameter in px while just hovering. */
2654
+ size?: number;
2655
+ /** Lens diameter in px over the revealed content. */
2656
+ revealSize?: number;
2657
+ className?: string;
2658
+ };
2659
+ declare function SvgMaskEffect({ children, revealContent, size, revealSize, className, }: SvgMaskEffectProps): react.JSX.Element;
2660
+
2661
+ type TerminalLine = {
2662
+ /** "command" lines are typed after the prompt; "output" lines just appear. */
2663
+ type: "command" | "output";
2664
+ text: string;
2665
+ /** Colour for output lines, e.g. "var(--green)". */
2666
+ color?: string;
2667
+ /** Pause in ms before this line starts. */
2668
+ delay?: number;
2669
+ };
2670
+ type TerminalProps = {
2671
+ lines?: TerminalLine[];
2672
+ /** Window title. */
2673
+ title?: string;
2674
+ /** Prompt shown before commands. */
2675
+ prompt?: string;
2676
+ /** Milliseconds per typed character. */
2677
+ typingSpeed?: number;
2678
+ /** Start over after a pause once the session ends. */
2679
+ loop?: boolean;
2680
+ className?: string;
2681
+ };
2682
+ declare function Terminal({ lines, title, prompt, typingSpeed, loop, className, }: TerminalProps): react.JSX.Element;
2683
+
2684
+ type TextFlippingBoardProps = {
2685
+ /** Messages shown in turn; each is padded or cut to fit the board. */
2686
+ messages?: string[];
2687
+ /** Tiles per row. */
2688
+ columns?: number;
2689
+ /** Rows of tiles. */
2690
+ rows?: number;
2691
+ /** Milliseconds each message stays. */
2692
+ interval?: number;
2693
+ className?: string;
2694
+ };
2695
+ declare function TextFlippingBoard({ messages, columns, rows, interval, className, }: TextFlippingBoardProps): react.JSX.Element;
2696
+
2697
+ type TextHoverEffectProps = {
2698
+ text?: string;
2699
+ /** Colours of the lit outline, left to right. */
2700
+ colors?: string[];
2701
+ /** Radius of the lit area, % of the word's width. */
2702
+ radius?: number;
2703
+ /** Seconds for the outline to draw itself in. */
2704
+ drawDuration?: number;
2705
+ className?: string;
2706
+ };
2707
+ declare function TextHoverEffect({ text, colors, radius, drawDuration, className, }: TextHoverEffectProps): react.JSX.Element;
2708
+
2709
+ type TextRevealCardProps = {
2710
+ /** The muted text shown at rest. */
2711
+ text?: string;
2712
+ /** The bright text revealed under the pointer. */
2713
+ revealText?: string;
2714
+ /** Heading content above the text (title, description). */
2715
+ children?: ReactNode;
2716
+ className?: string;
2717
+ };
2718
+ declare function TextRevealCard({ text, revealText, children, className }: TextRevealCardProps): react.JSX.Element;
2719
+
2720
+ type TimelineEntry = {
2721
+ title: string;
2722
+ content: ReactNode;
2723
+ };
2724
+ type TimelineProps = {
2725
+ data?: TimelineEntry[];
2726
+ className?: string;
2727
+ };
2728
+ declare function Timeline({ data, className }: TimelineProps): react.JSX.Element;
2729
+
2730
+ type TooltipCardProps = {
2731
+ /** The inline trigger text. */
2732
+ children?: ReactNode;
2733
+ /** What the floating card shows. */
2734
+ content?: ReactNode;
2735
+ /** Card width in px. */
2736
+ width?: number;
2737
+ className?: string;
2738
+ };
2739
+ declare function TooltipCard({ children, content, width, className }: TooltipCardProps): react.JSX.Element;
2740
+
2741
+ type TracingBeamProps = {
2742
+ children?: ReactNode;
2743
+ /** Beam gradient colours, head to tail. */
2744
+ colors?: [string, string, string];
2745
+ /** Length of the beam in px. */
2746
+ beamLength?: number;
2747
+ className?: string;
2748
+ };
2749
+ declare function TracingBeam({ children, colors, beamLength, className, }: TracingBeamProps): react.JSX.Element;
2750
+
2751
+ type TypewriterWord = {
2752
+ text: string;
2753
+ className?: string;
2754
+ };
2755
+ type TypewriterProps = {
2756
+ words?: TypewriterWord[];
2757
+ /** Milliseconds per character. */
2758
+ speed?: number;
2759
+ /** Erase and retype after a pause. */
2760
+ loop?: boolean;
2761
+ /** Pause at the end before erasing (ms), when looping. */
2762
+ pause?: number;
2763
+ className?: string;
2764
+ cursorClassName?: string;
2765
+ };
2766
+ declare function Typewriter({ words, speed, loop, pause, className, cursorClassName, }: TypewriterProps): react.JSX.Element;
2767
+
2768
+ type VortexProps = {
2769
+ children?: ReactNode;
2770
+ particleCount?: number;
2771
+ /** Starting hue (0–360) and how far hues spread from it. */
2772
+ baseHue?: number;
2773
+ rangeHue?: number;
2774
+ baseSpeed?: number;
2775
+ rangeSpeed?: number;
2776
+ /** Panel colour; trails fade into it. */
2777
+ backgroundColor?: string;
2778
+ className?: string;
2779
+ };
2780
+ declare function Vortex({ children, particleCount, baseHue, rangeHue, baseSpeed, rangeSpeed, backgroundColor, className, }: VortexProps): react.JSX.Element;
2781
+
2782
+ type WavyBackgroundProps = {
2783
+ children?: ReactNode;
2784
+ /** One colour per wave. */
2785
+ colors?: string[];
2786
+ /** Stroke width of each wave in px. */
2787
+ waveWidth?: number;
2788
+ /** Canvas fill behind the waves. Defaults to the page token. */
2789
+ backgroundFill?: string;
2790
+ /** Blur in px applied to the whole canvas. */
2791
+ blur?: number;
2792
+ speed?: "slow" | "fast";
2793
+ waveOpacity?: number;
2794
+ className?: string;
2795
+ };
2796
+ declare function WavyBackground({ children, colors, waveWidth, backgroundFill, blur, speed, waveOpacity, className, }: WavyBackgroundProps): react.JSX.Element;
2797
+
2798
+ type WebcamPixelGridLabels = {
2799
+ start: string;
2800
+ stop: string;
2801
+ denied: string;
2802
+ unsupported: string;
2803
+ };
2804
+ type WebcamPixelGridProps = {
2805
+ /** Grid cell size in px. */
2806
+ cellSize?: number;
2807
+ /** Dot colour. Defaults to the ink token; "camera" uses the camera's colours. */
2808
+ color?: string;
2809
+ /** Mirror horizontally, like a selfie view. */
2810
+ mirror?: boolean;
2811
+ /** Dot shape. */
2812
+ shape?: "circle" | "square";
2813
+ labels?: Partial<WebcamPixelGridLabels>;
2814
+ className?: string;
2815
+ };
2816
+ declare function WebcamPixelGrid({ cellSize, color, mirror, shape, labels, className, }: WebcamPixelGridProps): react.JSX.Element;
2817
+
2818
+ type WobbleCardProps = {
2819
+ children?: ReactNode;
2820
+ /** Card background, any CSS colour or gradient. */
2821
+ background?: string;
2822
+ /** How far (px) the card leans toward the pointer. */
2823
+ strength?: number;
2824
+ /** Class for the outer card. */
2825
+ containerClassName?: string;
2826
+ /** Class for the content area. */
2827
+ className?: string;
2828
+ };
2829
+ declare function WobbleCard({ children, background, strength, containerClassName, className, }: WobbleCardProps): react.JSX.Element;
2830
+
2831
+ type MapPoint = {
2832
+ lat: number;
2833
+ lng: number;
2834
+ label?: string;
2835
+ };
2836
+ type MapConnection = {
2837
+ from: MapPoint;
2838
+ to: MapPoint;
2839
+ };
2840
+ type WorldMapProps = {
2841
+ connections?: MapConnection[];
2842
+ /** Colour of the land dots. */
2843
+ dotColor?: string;
2844
+ /** Colour of the arcs and end points. */
2845
+ lineColor?: string;
2846
+ /** Grid spacing of the dots in degrees; smaller is denser. */
2847
+ spacing?: number;
2848
+ /** Seconds between one arc and the next. */
2849
+ stagger?: number;
2850
+ className?: string;
2851
+ };
2852
+ declare function WorldMap({ connections, dotColor, lineColor, spacing, stagger, className, }: WorldMapProps): react.JSX.Element;
2853
+
1154
2854
  type NexiProviderProps = React.HTMLAttributes<HTMLDivElement> & {
1155
2855
  /** Force the dark palette for this subtree. Leave undefined to inherit a
1156
2856
  * `.dark` class from an ancestor (e.g. on <html>). */
@@ -1165,5 +2865,5 @@ declare function NexiProvider({ dark, contents, className, children, ...rest }:
1165
2865
  /** Merge class names, letting later Tailwind classes win over conflicting earlier ones. */
1166
2866
  declare function cn(...inputs: ClassValue[]): string;
1167
2867
 
1168
- export { AgentScreen, ApprovalCard, Avatar, Badge, Button, ChatComposer, Chip, CodeBlock, ContextCards, Dialog, DiffTable, EmptyState, EntityChip, FilterTable, FineTuneCard, Flowchart, GlideMenu, InsightAllocationCard, InsightAnomalyCard, InsightCards, InsightCompareCard, InsightEntity, InsightMono, LoadingState, Markdown, Message, MessageThread, Monogram, NexiProvider, ProgressRing, PromptBar, RecommendationCard, SearchList, SegmentedControl, SelectionActions, Shimmer, SidebarNav, StatusPill, StreamText, StreamingText, Switch, TaskRows, TextRow, ThinkingState, ToastProvider, ToolChips, Tooltip, UsageMeter, ValuePill, badgeVariants, buttonVariants, cn, toStreamingTokens, useToast };
1169
- export type { AgentScreenLabels, AgentScreenProps, AllocationSegment, AnomalyMetric, ApprovalCardProps, ApprovalLabels, ApprovalQuestion, AvatarProps, AvatarStatus, BadgeProps, BadgeTone, ButtonVariant, ChatComposerLabels, ChatComposerProps, ChatMessage, CodeBlockLabels, CodeBlockProps, CodePiece, CompareSeries, ContextCardsProps, ContextChunk, DialogLabels, DialogProps, DiffRow, DiffTableLabels, DiffTableProps, DiffTableRow, DiffTableTone, EmptyStateAction, EmptyStateProps, FilterTableLabels, FilterTableProps, FilterTableStatus, FineTuneCardLabels, FineTuneCardProps, FineTuneField, FineTuneState, FlowCondition, FlowEdge, FlowOption, FlowchartProps, GlideMenuProps, InsightAllocationCardProps, InsightAnomalyCardProps, InsightCardsLabels, InsightCardsProps, InsightCompareCardProps, InsightPage, LoadingStateProps, MarkdownProps, MessageProps, MessageThreadProps, NexiProviderProps, PromptBarLabels, PromptBarProps, PromptCommand, PromptModel, PromptSource, RecommendationCardProps, RecommendationLabels, RecommendationOption, SearchItem, SearchListLabels, SearchListProps, SelectionAction, SelectionActionSet, SelectionActionsLabels, SelectionActionsProps, SelectionText, SidebarMenuItem, SidebarNavItem, SidebarNavLabels, SidebarNavProps, SidebarRecent, SidebarWorkspace, StepNode, StreamingLabels, StreamingSource, StreamingTextProps, StreamingToken, TableRow, TaskDetail, TaskRow, TaskRowsLabels, TaskRowsProps, ThinkingRow, ThinkingStateProps, ThreadMessage, ToastOptions, ToastProviderProps, ToastTone, ToolChipsLabels, ToolChipsProps, ToolDetailLine, ToolDiff, ToolDiffLine, ToolStep, TooltipProps, UsageMeterProps, UsageSegment };
2868
+ export { AgentScreen, AnimatedModal, AnimatedTabs, AnimatedTestimonials, AnimatedTooltip, ApprovalCard, ArcGlobe, AsciiArt, AuroraBackground, Avatar, BackgroundBeams, BackgroundBoxes, BackgroundCubesGrid, BackgroundGradient, BackgroundGradientAnimation, BackgroundLines, BackgroundRippleEffect, Badge, BeamsWithCollision, BentoGrid, BentoGridItem, Button, CanvasRevealEffect, CanvasText, Card3D, Card3DItem, CardHoverEffect, CardStack, CardsCarousel, Carousel3D, ChatComposer, Chip, ChromaticImage, CipherCard, CloudShader, CodeBlock, ColourfulText, CometCard, Compare, ContainerCover, ContainerScrollAnimation, ContainerTextFlip, ContextCards, Dialog, DiffTable, DirectionAwareHover, DitherShader, DottedGlowBackground, DraggableCards, EFFECT_BUTTON_VARIANTS, EffectButton, EmptyState, EncryptedText, EntityChip, ExpandableCard, FileUpload, FilterTable, FineTuneCard, FlipWords, FloatingDock, FloatingNavbar, Flowchart, FocusCards, FollowingPointer, GlareCard, GlideMenu, Globe, GlowInput, GlowingEffect, GlowingStars, GooeyInput, GridBackground, HeroHighlight, HeroParallax, Highlight, HoverBorderGradient, ImageGenerationLoader, ImagesBadge, ImagesSlider, InfiniteMovingCards, InsightAllocationCard, InsightAnomalyCard, InsightCards, InsightCompareCard, InsightEntity, InsightMono, KEYBOARD_US, Keyboard, LampEffect, LaptopScroll, LayoutGrid, LayoutTextFlip, Lens, LinkPreview, LiquidGlass, LoadingState, MagneticButton, Markdown, Marquee3D, Message, MessageThread, Meteors, Monogram, MovingBorder, NavbarMenu, NexiProvider, NoiseBackground, Notch, ParallaxHeroImages, ParallaxScroll, Pin3D, PixelatedCanvas, PointerHighlight, ProgressRing, PromptBar, RecommendationCard, ResizableNavbar, Scales, ScrollPathsEffect, SearchList, SegmentedControl, SelectionActions, Shimmer, ShootingStars, SidebarNav, SignupForm, Sparkles, Spotlight, SpotlightCard, SpotlightNew, SquigglyText, StatefulButton, StatusPill, StickyBanner, StickyScrollReveal, StreamText, StreamingText, SvgMaskEffect, Switch, TaskRows, Terminal, TextFlippingBoard, TextHoverEffect, TextRevealCard, TextRow, ThinkingState, Timeline, ToastProvider, ToolChips, Tooltip, TooltipCard, TracingBeam, Typewriter, UsageMeter, ValuePill, Vortex, WavyBackground, WebcamPixelGrid, WobbleCard, WorldMap, badgeVariants, buttonVariants, cn, toStreamingTokens, useToast };
2869
+ export type { AgentScreenLabels, AgentScreenProps, AllocationSegment, AnimatedModalLabels, AnimatedModalProps, AnimatedTab, AnimatedTabsProps, AnimatedTestimonialsLabels, AnimatedTestimonialsProps, AnimatedTooltipProps, AnomalyMetric, ApprovalCardProps, ApprovalLabels, ApprovalQuestion, ArcGlobeProps, AsciiArtProps, AuroraBackgroundProps, AvatarProps, AvatarStatus, BackgroundBeamsProps, BackgroundBoxesProps, BackgroundCubesGridProps, BackgroundGradientAnimationProps, BackgroundGradientProps, BackgroundLinesProps, BackgroundRippleEffectProps, BadgeProps, BadgeTone, BeamsWithCollisionProps, BentoGridItemProps, BentoGridProps, ButtonVariant, CanvasRevealEffectProps, CanvasTextProps, Card3DItemProps, Card3DProps, CardHoverEffectProps, CardStackProps, CardsCarouselLabels, CardsCarouselProps, Carousel3DLabels, Carousel3DProps, Carousel3DSlide, CarouselCard, ChatComposerLabels, ChatComposerProps, ChatMessage, ChromaticImageProps, CipherCardProps, CloudShaderProps, CodeBlockLabels, CodeBlockProps, CodePiece, ColourfulTextProps, CometCardProps, CompareLabels, CompareProps, CompareSeries, ContainerCoverProps, ContainerScrollAnimationProps, ContainerTextFlipProps, ContextCardsProps, ContextChunk, DialogLabels, DialogProps, DiffRow, DiffTableLabels, DiffTableProps, DiffTableRow, DiffTableTone, DirectionAwareHoverProps, DitherShaderProps, DockItem, DottedGlowBackgroundProps, DraggableCardsProps, DraggableItem, EffectButtonProps, EffectButtonVariant, EmptyStateAction, EmptyStateProps, EncryptedTextProps, ExpandableCardLabels, ExpandableCardProps, ExpandableItem, FallingBeam, FileUploadLabels, FileUploadProps, FilterTableLabels, FilterTableProps, FilterTableStatus, FineTuneCardLabels, FineTuneCardProps, FineTuneField, FineTuneState, FlipWordsProps, FloatingDockProps, FloatingNavItem, FloatingNavbarProps, FlowCondition, FlowEdge, FlowOption, FlowchartProps, FocusCard, FocusCardsProps, FollowingPointerProps, GlareCardProps, GlideMenuProps, GlobeArc, GlobeMarker, GlobeProps, GlowInputProps, GlowingEffectProps, GlowingStarsProps, GooeyInputLabels, GooeyInputProps, GradientOrb, GridBackgroundProps, GridBackgroundVariant, HeroHighlightProps, HeroParallaxProps, HeroProduct, HighlightProps, HoverBorderGradientProps, HoverCardItem, ImageGenerationLoaderLabels, ImageGenerationLoaderProps, ImagesBadgeProps, ImagesSliderLabels, ImagesSliderProps, InfiniteMovingCardsProps, InsightAllocationCardProps, InsightAnomalyCardProps, InsightCardsLabels, InsightCardsProps, InsightCompareCardProps, InsightPage, KeyboardKey, KeyboardProps, LampEffectProps, LaptopScrollProps, LayoutGridCard, LayoutGridProps, LayoutTextFlipProps, LensProps, LinkPreviewProps, LiquidGlassProps, LoadingStateProps, MagneticButtonProps, MapConnection, MapPoint, MarkdownProps, Marquee3DProps, MessageProps, MessageThreadProps, MeteorsProps, MovingBorderProps, MovingCardItem, NavbarItem, NavbarLink, NavbarMenuProps, NexiProviderProps, NoiseBackgroundProps, NotchLabels, NotchProps, ParallaxHeroImagesProps, ParallaxImage, ParallaxScrollProps, Pin3DProps, PixelatedCanvasProps, PointerHighlightProps, PromptBarLabels, PromptBarProps, PromptCommand, PromptModel, PromptSource, RecommendationCardProps, RecommendationLabels, RecommendationOption, ResizableNavItem, ResizableNavbarLabels, ResizableNavbarProps, ScalesProps, ScrollPathsEffectProps, SearchItem, SearchListLabels, SearchListProps, SelectionAction, SelectionActionSet, SelectionActionsLabels, SelectionActionsProps, SelectionText, ShootingStarsProps, SidebarMenuItem, SidebarNavItem, SidebarNavLabels, SidebarNavProps, SidebarRecent, SidebarWorkspace, SignupField, SignupFormLabels, SignupFormProps, SignupProvider, SparklesProps, SpotlightCardProps, SpotlightNewProps, SpotlightProps, SquigglyTextProps, StackCard, StatefulButtonProps, StatefulButtonState, StepNode, StickyBannerLabels, StickyBannerProps, StickyScrollRevealProps, StickySection, StreamingLabels, StreamingSource, StreamingTextProps, StreamingToken, SvgMaskEffectProps, TableRow, TaskDetail, TaskRow, TaskRowsLabels, TaskRowsProps, TerminalLine, TerminalProps, Testimonial, TextFlippingBoardProps, TextHoverEffectProps, TextRevealCardProps, ThinkingRow, ThinkingStateProps, ThreadMessage, TimelineEntry, TimelineProps, ToastOptions, ToastProviderProps, ToastTone, ToolChipsLabels, ToolChipsProps, ToolDetailLine, ToolDiff, ToolDiffLine, ToolStep, TooltipCardProps, TooltipPerson, TooltipProps, TracingBeamProps, TypewriterProps, TypewriterWord, UsageMeterProps, UsageSegment, VortexProps, WavyBackgroundProps, WebcamPixelGridLabels, WebcamPixelGridProps, WobbleCardProps, WorldMapProps };