@hyddenlabs/hydn-ui 0.3.0-alpha.151 → 0.3.0-alpha.152

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.
Files changed (7) hide show
  1. package/dist/index.cjs +3962 -3705
  2. package/dist/index.cjs.map +1 -1
  3. package/dist/index.d.cts +917 -743
  4. package/dist/index.d.ts +917 -743
  5. package/dist/index.js +3971 -3729
  6. package/dist/index.js.map +1 -1
  7. package/package.json +1 -1
package/dist/index.d.cts CHANGED
@@ -1,345 +1,457 @@
1
- import * as React$1 from 'react';
2
- import React__default, { ReactNode, CSSProperties, HTMLAttributes, MouseEvent } from 'react';
3
1
  import * as react_jsx_runtime from 'react/jsx-runtime';
2
+ import * as React$1 from 'react';
3
+ import React__default, { ReactNode, MouseEvent, HTMLAttributes, CSSProperties, FormEvent, RefObject } from 'react';
4
4
 
5
- type ButtonProps = {
6
- children?: React__default.ReactNode;
7
- onClick?: (e: React__default.MouseEvent<HTMLButtonElement>) => void;
8
- ariaLabel?: string;
9
- disabled?: boolean;
10
- type?: 'button' | 'submit' | 'reset';
5
+ type Theme = 'light' | 'dark';
6
+ type ThemeContextType = {
7
+ theme: Theme;
8
+ setTheme: (theme: Theme) => void;
9
+ availableThemes: Theme[];
10
+ };
11
+ type ThemeProviderProps = {
12
+ children: ReactNode;
13
+ defaultTheme?: Theme;
14
+ storageKey?: string;
15
+ themes?: Theme[];
16
+ };
17
+ declare function ThemeProvider({ children, defaultTheme, storageKey, themes }: Readonly<ThemeProviderProps>): react_jsx_runtime.JSX.Element;
18
+ declare function useTheme(): ThemeContextType;
19
+
20
+ type ColorModeToggleProps = {
11
21
  className?: string;
12
- icon?: React__default.ReactNode;
13
- iconPosition?: 'left' | 'right';
14
- variant?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
15
- style?: 'solid' | 'outline' | 'ghost' | 'link' | 'soft';
22
+ };
23
+ declare function ColorModeToggle({ className }: Readonly<ColorModeToggleProps>): react_jsx_runtime.JSX.Element;
24
+ declare namespace ColorModeToggle {
25
+ var displayName: string;
26
+ }
27
+
28
+ type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | number;
29
+ interface IconProps {
30
+ name: string;
31
+ size?: IconSize;
32
+ color?: string;
33
+ strokeWidth?: number;
34
+ className?: string;
35
+ onClick?: () => void;
36
+ }
37
+ declare const Icon: React$1.FC<IconProps>;
38
+
39
+ interface AuthUser {
40
+ id: string;
41
+ [key: string]: unknown;
42
+ }
43
+ interface AuthState {
44
+ user: AuthUser | null;
45
+ isLoading: boolean;
46
+ isAuthenticated: boolean;
47
+ error: Error | null;
48
+ }
49
+ interface AuthActions {
50
+ login: (credentials: unknown) => Promise<void>;
51
+ logout: () => Promise<void>;
52
+ refresh: () => Promise<void>;
53
+ clearError: () => void;
54
+ updateUser: (updates: Partial<AuthUser>) => void;
55
+ }
56
+ type AuthContextType = AuthState & AuthActions;
57
+ interface AuthProviderConfig {
58
+ onLogin: (credentials: unknown) => Promise<AuthUser>;
59
+ onLogout?: () => Promise<void>;
60
+ onRefresh?: () => Promise<AuthUser | null>;
61
+ storageKey?: string;
62
+ useSessionStorage?: boolean;
63
+ autoRefresh?: boolean;
64
+ authUrl?: string;
65
+ withCredentials?: boolean;
66
+ }
67
+ interface AuthProviderProps {
68
+ config: AuthProviderConfig;
69
+ children: ReactNode;
70
+ }
71
+ declare function AuthProvider({ config, children }: Readonly<AuthProviderProps>): react_jsx_runtime.JSX.Element;
72
+ declare function useAuth(): AuthContextType;
73
+
74
+ declare function authFetch(url: string, options?: RequestInit, withCredentials?: boolean): Promise<Response>;
75
+ declare function checkAuthStatus(authUrl: string): Promise<boolean>;
76
+ declare function getCurrentUser(authUrl: string): Promise<any | null>;
77
+ declare function loginExternal(authUrl: string, credentials: unknown): Promise<any>;
78
+ declare function logoutExternal(authUrl: string): Promise<void>;
79
+ declare function redirectToLogin(authUrl: string, returnUrl?: string): void;
80
+ declare function openLoginPopup(authUrl: string, onSuccess?: () => void): Window | null;
81
+
82
+ type LogoProps = {
16
83
  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
17
- rounded?: 'default' | 'pill' | 'square' | 'circle';
18
- loading?: boolean;
19
- fullWidth?: boolean;
20
- wide?: boolean;
21
- active?: boolean;
84
+ className?: string;
22
85
  };
23
- declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
86
+ declare function Logo({ size, className }: Readonly<LogoProps>): react_jsx_runtime.JSX.Element;
24
87
 
25
- type ValidationState$5 = 'default' | 'error' | 'success' | 'warning';
26
- type InputProps = {
27
- value?: string;
28
- onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
29
- onFocus?: (e: React__default.FocusEvent<HTMLInputElement>) => void;
30
- placeholder?: string;
31
- disabled?: boolean;
32
- type?: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url';
88
+ type ContainerProps = {
89
+ children: React__default.ReactNode;
33
90
  className?: string;
34
- ariaLabel?: string;
35
- ref?: React__default.Ref<HTMLInputElement>;
36
- id?: string;
37
- name?: string;
38
- required?: boolean;
39
- size?: 'sm' | 'md' | 'lg';
40
- validationState?: ValidationState$5;
91
+ size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
92
+ padding?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
93
+ align?: 'start' | 'center' | 'end';
94
+ minWidth?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | 'full' | string;
95
+ minHeight?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | 'screen' | string;
41
96
  };
42
- declare function Input({ value, onChange, onFocus, placeholder, disabled, type, className, ariaLabel, ref, id, name, required, size, validationState }: Readonly<InputProps>): react_jsx_runtime.JSX.Element;
43
- declare namespace Input {
97
+ declare function Container({ children, className, size, padding, align, minWidth, minHeight }: Readonly<ContainerProps>): react_jsx_runtime.JSX.Element;
98
+ declare namespace Container {
44
99
  var displayName: string;
45
100
  }
46
101
 
47
- type ValidationState$4 = 'default' | 'error' | 'success' | 'warning';
48
- type CheckboxProps = {
49
- checked?: boolean;
50
- onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
51
- disabled?: boolean;
102
+ type GridProps = {
103
+ children: React__default.ReactNode;
52
104
  className?: string;
53
- ariaLabel?: string;
54
- id?: string;
55
- name?: string;
56
- validationState?: ValidationState$4;
105
+ itemSize?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
106
+ maxCols?: number;
107
+ gap?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
108
+ responsive?: {
109
+ sm?: number;
110
+ md?: number;
111
+ lg?: number;
112
+ xl?: number;
113
+ };
114
+ alignItems?: 'start' | 'center' | 'end' | 'stretch';
115
+ justifyItems?: 'start' | 'center' | 'end' | 'stretch';
57
116
  };
58
- declare function Checkbox({ checked, onChange, disabled, className, ariaLabel, id, name, validationState }: Readonly<CheckboxProps>): react_jsx_runtime.JSX.Element;
59
- declare namespace Checkbox {
117
+ declare function Grid({ children, className, itemSize, maxCols, gap, responsive, alignItems, justifyItems }: Readonly<GridProps>): react_jsx_runtime.JSX.Element;
118
+ declare namespace Grid {
60
119
  var displayName: string;
61
120
  }
62
121
 
63
- type ValidationState$3 = 'default' | 'error' | 'success' | 'warning';
64
- type RadioProps = {
65
- checked?: boolean;
66
- onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
67
- disabled?: boolean;
122
+ type PageProps = {
123
+ children: React__default.ReactNode;
68
124
  className?: string;
69
- ariaLabel?: string;
70
- id?: string;
71
- name?: string;
72
- value?: string;
73
- validationState?: ValidationState$3;
74
125
  };
75
- declare function Radio({ checked, onChange, disabled, className, ariaLabel, id, name: nameProp, value, validationState }: Readonly<RadioProps>): react_jsx_runtime.JSX.Element;
76
- declare namespace Radio {
126
+ declare function Page({ children, className }: Readonly<PageProps>): react_jsx_runtime.JSX.Element;
127
+ declare namespace Page {
77
128
  var displayName: string;
78
129
  }
79
130
 
80
- type ValidationState$2 = 'default' | 'error' | 'success' | 'warning';
81
- type SelectProps = {
82
- value?: string;
83
- onChange?: (e: React__default.ChangeEvent<HTMLSelectElement>) => void;
84
- disabled?: boolean;
131
+ type PageHeaderProps = {
132
+ title: string;
133
+ description?: string;
134
+ badge?: React__default.ReactNode;
135
+ className?: string;
136
+ };
137
+ declare function PageHeader({ title, description, badge, className }: Readonly<PageHeaderProps>): react_jsx_runtime.JSX.Element;
138
+ declare namespace PageHeader {
139
+ var displayName: string;
140
+ }
141
+
142
+ interface SectionProps {
143
+ children: React.ReactNode;
144
+ variant?: 'default' | 'muted' | 'primary' | 'dark';
145
+ padding?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
85
146
  className?: string;
86
- ariaLabel?: string;
87
147
  id?: string;
88
- name?: string;
89
- children: React__default.ReactNode;
90
- required?: boolean;
91
- size?: 'sm' | 'md' | 'lg';
92
- validationState?: ValidationState$2;
148
+ }
149
+ declare function Section({ children, variant, padding, className, id }: SectionProps): react_jsx_runtime.JSX.Element;
150
+ declare namespace Section {
151
+ var displayName: string;
152
+ }
153
+
154
+ type SectionHeaderProps = {
155
+ title: string;
156
+ description?: string;
157
+ badge?: React__default.ReactNode;
158
+ level?: 2 | 3 | 4;
159
+ className?: string;
93
160
  };
94
- declare function Select({ value, onChange, disabled, className, ariaLabel, id, name, children, required, size, validationState }: Readonly<SelectProps>): react_jsx_runtime.JSX.Element;
95
- declare namespace Select {
161
+ declare function SectionHeader({ title, description, badge, level, className }: Readonly<SectionHeaderProps>): react_jsx_runtime.JSX.Element;
162
+ declare namespace SectionHeader {
96
163
  var displayName: string;
97
164
  }
98
165
 
99
- type SelectItemProps = {
100
- value?: string;
101
- disabled?: boolean;
166
+ type StackProps = {
102
167
  children: React__default.ReactNode;
168
+ className?: string;
169
+ direction?: 'horizontal' | 'vertical';
170
+ spacing?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
171
+ align?: 'start' | 'center' | 'end' | 'stretch';
172
+ justify?: 'start' | 'center' | 'end' | 'between' | 'around';
103
173
  };
104
- declare function SelectItem({ value, disabled, children }: Readonly<SelectItemProps>): react_jsx_runtime.JSX.Element;
105
- declare namespace SelectItem {
174
+ declare function Stack({ children, className, direction, spacing, align, justify }: Readonly<StackProps>): react_jsx_runtime.JSX.Element;
175
+ declare namespace Stack {
106
176
  var displayName: string;
107
177
  }
108
178
 
109
- type MultiSelectOption = {
110
- value: string;
111
- label: string;
179
+ type AccordionItemProps = {
180
+ title: string;
181
+ children: ReactNode;
182
+ defaultOpen?: boolean;
112
183
  };
113
- type MultiSelectProps = {
114
- options: MultiSelectOption[];
115
- value?: string[];
116
- onChange?: (values: string[]) => void;
117
- placeholder?: string;
118
- disabled?: boolean;
119
- maxSelections?: number;
120
- size?: 'sm' | 'md' | 'lg';
184
+ type AccordionProps = {
185
+ children: ReactNode;
121
186
  className?: string;
187
+ allowMultiple?: boolean;
122
188
  };
123
- declare function MultiSelect({ options, value, onChange, placeholder, disabled, maxSelections, size, className }: Readonly<MultiSelectProps>): react_jsx_runtime.JSX.Element;
124
- declare namespace MultiSelect {
189
+ declare function AccordionItem({ title, children, defaultOpen }: Readonly<AccordionItemProps>): react_jsx_runtime.JSX.Element;
190
+ declare function Accordion({ children, className }: Readonly<AccordionProps>): react_jsx_runtime.JSX.Element;
191
+ declare namespace Accordion {
125
192
  var displayName: string;
126
193
  }
127
194
 
128
- type ValidationState$1 = 'default' | 'error' | 'success' | 'warning';
129
- type TextareaProps = {
130
- value?: string;
131
- onChange?: (e: React__default.ChangeEvent<HTMLTextAreaElement>) => void;
132
- placeholder?: string;
133
- disabled?: boolean;
195
+ type DividerProps = {
196
+ orientation?: 'horizontal' | 'vertical';
134
197
  className?: string;
135
- ariaLabel?: string;
136
- id?: string;
137
- name?: string;
138
- rows?: number;
139
- required?: boolean;
140
- validationState?: ValidationState$1;
198
+ } & React.HTMLAttributes<HTMLHRElement>;
199
+ declare function Divider({ orientation, className, ...props }: Readonly<DividerProps>): react_jsx_runtime.JSX.Element;
200
+ declare namespace Divider {
201
+ var displayName: string;
202
+ }
203
+
204
+ type DrawerProps = {
205
+ isOpen: boolean;
206
+ onClose: () => void;
207
+ children: ReactNode;
208
+ position?: 'left' | 'right' | 'top' | 'bottom';
209
+ className?: string;
210
+ title?: string;
211
+ size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
212
+ closeOnEscape?: boolean;
213
+ closeOnOutside?: boolean;
214
+ unmountOnExit?: boolean;
215
+ portalRoot?: HTMLElement | null;
216
+ noAnimation?: boolean;
141
217
  };
142
- declare function Textarea({ value, onChange, placeholder, disabled, className, ariaLabel, id, name, rows, required, validationState }: Readonly<TextareaProps>): react_jsx_runtime.JSX.Element;
143
- declare namespace Textarea {
218
+ declare function Drawer({ isOpen, onClose, children, position, className, title, size, closeOnEscape, closeOnOutside, unmountOnExit, portalRoot, noAnimation }: Readonly<DrawerProps>): react_jsx_runtime.JSX.Element | null;
219
+ declare namespace Drawer {
144
220
  var displayName: string;
145
221
  }
146
222
 
147
- type SwitchProps = {
148
- checked?: boolean;
149
- onChange?: (checked: boolean) => void;
150
- disabled?: boolean;
223
+ type CardProps = {
224
+ children: React__default.ReactNode;
151
225
  className?: string;
152
- ariaLabel?: string;
153
- id?: string;
154
- name?: string;
226
+ variant?: 'default' | 'bordered' | 'ghost' | 'filled';
155
227
  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
156
- variant?: 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'info' | 'error' | 'neutral';
228
+ width?: 'auto' | 'full' | 'fit';
229
+ hoverable?: boolean;
230
+ imagePosition?: 'top' | 'bottom' | 'side' | 'overlay';
231
+ centered?: boolean;
232
+ compact?: boolean;
233
+ } & React__default.HTMLAttributes<HTMLDivElement>;
234
+ declare function Card({ children, className, variant, size, width, hoverable, imagePosition, centered, compact, ...props }: Readonly<CardProps>): react_jsx_runtime.JSX.Element;
235
+ declare namespace Card {
236
+ var displayName: string;
237
+ }
238
+
239
+ type CardHeaderProps = {
240
+ children: ReactNode;
241
+ className?: string;
242
+ bordered?: boolean;
243
+ padding?: 'none' | 'sm' | 'md' | 'lg';
157
244
  };
158
- declare function Switch({ checked, onChange, disabled, className, ariaLabel, id, name, size, variant }: Readonly<SwitchProps>): react_jsx_runtime.JSX.Element;
159
- declare namespace Switch {
245
+ declare function CardHeader({ children, className, bordered, padding }: Readonly<CardHeaderProps>): react_jsx_runtime.JSX.Element;
246
+ declare namespace CardHeader {
160
247
  var displayName: string;
161
248
  }
162
249
 
163
- type SliderProps = {
164
- value?: number;
165
- onChange?: (value: number) => void;
166
- min?: number;
167
- max?: number;
168
- step?: number;
169
- disabled?: boolean;
250
+ interface CardBodyProps {
251
+ children: React.ReactNode;
252
+ padding?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
170
253
  className?: string;
171
- ariaLabel?: string;
172
- id?: string;
173
- name?: string;
174
- };
175
- declare function Slider({ value, onChange, min, max, step, disabled, className, ariaLabel, id, name }: Readonly<SliderProps>): react_jsx_runtime.JSX.Element;
176
- declare namespace Slider {
254
+ }
255
+ declare function CardBody({ children, padding, className }: CardBodyProps): react_jsx_runtime.JSX.Element;
256
+ declare namespace CardBody {
177
257
  var displayName: string;
178
258
  }
179
259
 
180
- type ButtonGroupProps = {
260
+ type CardFooterProps = {
181
261
  children: ReactNode;
182
262
  className?: string;
183
- variant?: 'default' | 'separated';
184
- orientation?: 'horizontal' | 'vertical';
263
+ bordered?: boolean;
264
+ padding?: 'none' | 'sm' | 'md' | 'lg';
265
+ align?: 'start' | 'center' | 'end';
185
266
  };
186
- declare function ButtonGroup({ children, className, variant, orientation }: Readonly<ButtonGroupProps>): react_jsx_runtime.JSX.Element;
187
- declare namespace ButtonGroup {
267
+ declare function CardFooter({ children, className, bordered, padding, align }: Readonly<CardFooterProps>): react_jsx_runtime.JSX.Element;
268
+ declare namespace CardFooter {
188
269
  var displayName: string;
189
270
  }
190
271
 
191
- type RadioGroupProps = {
272
+ type CardActionsProps = {
192
273
  children: ReactNode;
193
- name: string;
194
- label?: string;
195
- orientation?: 'horizontal' | 'vertical';
196
274
  className?: string;
197
- value?: string;
198
- onChange?: (value: string) => void;
275
+ align?: 'start' | 'center' | 'end' | 'stretch';
276
+ direction?: 'row' | 'column';
199
277
  };
200
- declare function RadioGroup({ children, name, label, orientation, className, value, onChange }: Readonly<RadioGroupProps>): react_jsx_runtime.JSX.Element;
201
- declare namespace RadioGroup {
278
+ declare function CardActions({ children, className, align, direction }: Readonly<CardActionsProps>): react_jsx_runtime.JSX.Element;
279
+ declare namespace CardActions {
202
280
  var displayName: string;
203
281
  }
204
282
 
205
- type ValidationState = 'default' | 'error' | 'success' | 'warning';
206
- type FormFieldProps = {
283
+ type CardFigureProps = {
207
284
  children: ReactNode;
208
- label?: string;
209
- htmlFor?: string;
210
- error?: string;
211
- helperText?: string;
212
- required?: boolean;
213
285
  className?: string;
214
- validationState?: ValidationState;
286
+ aspectRatio?: 'square' | 'video' | 'wide' | 'portrait' | 'auto';
215
287
  };
216
- declare function FormField({ children, label, htmlFor, error, helperText, required, className, validationState }: Readonly<FormFieldProps>): react_jsx_runtime.JSX.Element;
217
- declare namespace FormField {
288
+ declare function CardFigure({ children, className, aspectRatio }: Readonly<CardFigureProps>): react_jsx_runtime.JSX.Element;
289
+ declare namespace CardFigure {
218
290
  var displayName: string;
219
291
  }
220
292
 
221
- type InputGroupProps = {
293
+ type CardTitleProps = {
222
294
  children: ReactNode;
223
- prefix?: ReactNode;
224
- suffix?: ReactNode;
225
295
  className?: string;
296
+ as?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
297
+ size?: 'sm' | 'md' | 'lg' | 'xl';
226
298
  };
227
- declare function InputGroup({ children, prefix, suffix, className }: Readonly<InputGroupProps>): react_jsx_runtime.JSX.Element;
228
- declare namespace InputGroup {
299
+ declare function CardTitle({ children, className, as: Component, size }: Readonly<CardTitleProps>): react_jsx_runtime.JSX.Element;
300
+ declare namespace CardTitle {
229
301
  var displayName: string;
230
302
  }
231
303
 
232
- type CalendarProps = {
233
- value?: Date;
234
- onChange?: (date: Date) => void;
235
- minDate?: Date;
236
- maxDate?: Date;
237
- disabled?: boolean;
304
+ type LeftNavLayoutProps = {
305
+ nav: ReactNode;
306
+ children: ReactNode;
307
+ collapsed?: boolean;
308
+ onCollapsedChange?: (collapsed: boolean) => void;
309
+ showToggle?: boolean;
238
310
  className?: string;
311
+ navClassName?: string;
312
+ contentClassName?: string;
313
+ navWidth?: string;
314
+ navWidthCollapsed?: string;
315
+ mobileCollapsible?: boolean;
316
+ mobileMenuOpen?: boolean;
317
+ onMobileMenuOpenChange?: (open: boolean) => void;
318
+ embedded?: boolean;
319
+ mainContentRef?: React.RefObject<HTMLDivElement>;
239
320
  };
240
- declare function Calendar({ value, onChange, minDate, maxDate, disabled, className }: Readonly<CalendarProps>): react_jsx_runtime.JSX.Element;
241
- declare namespace Calendar {
321
+ declare function LeftNavLayout({ nav, children, collapsed: controlledCollapsed, onCollapsedChange, showToggle, className, navClassName, contentClassName, navWidth, navWidthCollapsed, mobileCollapsible, mobileMenuOpen: controlledMobileMenuOpen, embedded, mainContentRef }: Readonly<LeftNavLayoutProps>): react_jsx_runtime.JSX.Element;
322
+ declare namespace LeftNavLayout {
242
323
  var displayName: string;
243
324
  }
244
325
 
245
- type DatePickerProps = {
246
- value?: Date;
247
- onChange?: (date: Date | undefined) => void;
248
- minDate?: Date;
249
- maxDate?: Date;
250
- placeholder?: string;
251
- disabled?: boolean;
252
- dateFormat?: string;
253
- clearable?: boolean;
326
+ type LeftNavItemProps = {
327
+ icon?: ReactNode;
328
+ children: ReactNode;
329
+ active?: boolean;
254
330
  className?: string;
255
- size?: 'sm' | 'md' | 'lg';
331
+ badge?: ReactNode;
332
+ href?: string;
333
+ title?: string;
334
+ preventNavigation?: boolean;
256
335
  };
257
- declare function DatePicker({ value, onChange, minDate, maxDate, placeholder, disabled, dateFormat, clearable, className, size }: Readonly<DatePickerProps>): react_jsx_runtime.JSX.Element;
258
- declare namespace DatePicker {
336
+ declare function LeftNavItem({ icon, children, active, className, badge, href, title, preventNavigation }: Readonly<LeftNavItemProps>): react_jsx_runtime.JSX.Element;
337
+ declare namespace LeftNavItem {
259
338
  var displayName: string;
260
339
  }
261
340
 
262
- type NavProps = {
263
- children: React__default.ReactNode;
341
+ type LeftNavSectionProps = {
342
+ children: ReactNode;
343
+ label?: string;
264
344
  className?: string;
265
- ariaLabel?: string;
266
- direction?: 'horizontal' | 'vertical';
267
- spacing?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
268
- align?: 'start' | 'center' | 'end' | 'stretch';
269
345
  };
270
- declare function Nav({ children, className, ariaLabel, direction, spacing, align }: Readonly<NavProps>): react_jsx_runtime.JSX.Element;
271
- declare namespace Nav {
346
+ declare function LeftNavSection({ children, label, className }: Readonly<LeftNavSectionProps>): react_jsx_runtime.JSX.Element;
347
+ declare namespace LeftNavSection {
272
348
  var displayName: string;
273
349
  }
274
350
 
275
- type NavbarProps = {
276
- brand?: ReactNode;
277
- children: ReactNode;
278
- sticky?: boolean;
351
+ type HeroAction = {
352
+ label: string;
353
+ onClick: () => void;
354
+ variant?: 'primary' | 'secondary' | 'neutral' | 'error' | 'accent';
355
+ style?: 'solid' | 'outline' | 'ghost';
356
+ loading?: boolean;
357
+ icon?: ReactNode;
358
+ };
359
+ type HeroProps = {
360
+ title: string;
361
+ subtitle?: string;
362
+ description?: string;
363
+ primaryAction?: HeroAction;
364
+ secondaryAction?: HeroAction;
365
+ children?: ReactNode;
279
366
  className?: string;
280
- actions?: ReactNode;
281
- size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
282
- appearance?: 'solid' | 'blur' | 'transparent';
283
- border?: 'none' | 'bottom' | 'top' | 'both';
367
+ variant?: 'gradient' | 'solid' | 'minimal';
368
+ centered?: boolean;
369
+ size?: 'sm' | 'md' | 'lg';
284
370
  };
285
- declare function Navbar({ brand, children, sticky, className, actions, size, appearance, border }: Readonly<NavbarProps>): react_jsx_runtime.JSX.Element;
286
- declare namespace Navbar {
371
+ declare function Hero({ title, subtitle, description, primaryAction, secondaryAction, children, className, variant, centered, size }: Readonly<HeroProps>): react_jsx_runtime.JSX.Element;
372
+ declare namespace Hero {
287
373
  var displayName: string;
288
374
  }
289
375
 
290
- type NavbarBrandProps = {
291
- children: ReactNode;
292
- href?: string;
293
- external?: boolean;
294
- onClick?: () => void;
376
+ type Feature = {
377
+ icon: ReactNode;
378
+ title: string;
379
+ description: string;
380
+ };
381
+ type FeatureSectionProps = {
382
+ title?: string;
383
+ description?: string;
384
+ features: Feature[];
385
+ columns?: 2 | 3 | 4;
386
+ centered?: boolean;
295
387
  className?: string;
296
388
  };
297
- declare function NavbarBrand({ children, href, external, onClick, className }: Readonly<NavbarBrandProps>): react_jsx_runtime.JSX.Element;
298
- declare namespace NavbarBrand {
389
+ declare function FeatureSection({ title, description, features, columns, centered, className }: Readonly<FeatureSectionProps>): react_jsx_runtime.JSX.Element;
390
+ declare namespace FeatureSection {
299
391
  var displayName: string;
300
392
  }
301
393
 
302
- type NavbarLinkProps = {
303
- href: string;
304
- children: ReactNode;
305
- external?: boolean;
394
+ type FooterSection = {
395
+ title: string;
396
+ links: Array<{
397
+ label: string;
398
+ href: string;
399
+ external?: boolean;
400
+ }>;
401
+ };
402
+ type FooterProps = {
403
+ sections?: FooterSection[];
404
+ copyright?: string;
405
+ social?: ReactNode;
306
406
  className?: string;
307
- end?: boolean;
308
407
  };
309
- declare function NavbarLink({ href, children, external, className, end }: Readonly<NavbarLinkProps>): react_jsx_runtime.JSX.Element;
310
- declare namespace NavbarLink {
408
+ declare function Footer({ sections, copyright, social, className }: Readonly<FooterProps>): react_jsx_runtime.JSX.Element;
409
+ declare namespace Footer {
311
410
  var displayName: string;
312
411
  }
313
412
 
314
- interface NavbarToggleProps {
315
- mobileMenuOpen?: boolean;
316
- sidebarCollapsed?: boolean;
317
- onMobileMenuToggle?: () => void;
318
- onSidebarToggle?: () => void;
413
+ interface PageTransitionProps {
414
+ children: React__default.ReactNode;
415
+ duration?: number;
416
+ type?: 'fade' | 'slide' | 'scale' | 'none';
319
417
  className?: string;
320
418
  }
321
- declare function NavbarToggle({ mobileMenuOpen, sidebarCollapsed, onMobileMenuToggle, onSidebarToggle, className }: NavbarToggleProps): react_jsx_runtime.JSX.Element;
322
- declare namespace NavbarToggle {
323
- var displayName: string;
324
- }
419
+ declare const PageTransition: React__default.FC<PageTransitionProps>;
325
420
 
326
- type Tab = {
327
- id: string;
421
+ type BreadcrumbItem = {
328
422
  label: string;
329
- content: React__default.ReactNode;
423
+ href?: string;
330
424
  };
331
- type TabsProps = {
332
- tabs: Tab[];
333
- defaultTab?: string;
425
+ type BreadcrumbsProps = {
426
+ items: BreadcrumbItem[];
427
+ separator?: ReactNode;
334
428
  className?: string;
335
- ariaLabel?: string;
336
- noBorder?: boolean;
337
429
  };
338
- declare function Tabs({ tabs, defaultTab, className, ariaLabel, noBorder }: Readonly<TabsProps>): react_jsx_runtime.JSX.Element;
339
- declare namespace Tabs {
430
+ declare function Breadcrumbs({ items, separator, className }: Readonly<BreadcrumbsProps>): react_jsx_runtime.JSX.Element;
431
+ declare namespace Breadcrumbs {
340
432
  var displayName: string;
341
433
  }
342
434
 
435
+ type ButtonProps = {
436
+ children?: React__default.ReactNode;
437
+ onClick?: (e: React__default.MouseEvent<HTMLButtonElement>) => void;
438
+ ariaLabel?: string;
439
+ disabled?: boolean;
440
+ type?: 'button' | 'submit' | 'reset';
441
+ className?: string;
442
+ icon?: React__default.ReactNode;
443
+ iconPosition?: 'left' | 'right';
444
+ variant?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
445
+ style?: 'solid' | 'outline' | 'ghost' | 'link' | 'soft';
446
+ size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
447
+ rounded?: 'default' | 'pill' | 'square' | 'circle';
448
+ loading?: boolean;
449
+ fullWidth?: boolean;
450
+ wide?: boolean;
451
+ active?: boolean;
452
+ };
453
+ declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
454
+
343
455
  type DropdownTriggerProps = {
344
456
  title: string;
345
457
  subtitle?: string;
@@ -374,34 +486,21 @@ type DropdownItemProps = {
374
486
  icon?: string;
375
487
  endIcon?: string;
376
488
  size?: 'sm' | 'md';
377
- __dropdownIndex?: number;
378
- __registerItem?: (el: HTMLButtonElement | null, index: number) => void;
379
- };
380
- declare function DropdownItem({ children, onSelect, variant, disabled, className, description, icon, endIcon, size }: Readonly<DropdownItemProps>): react_jsx_runtime.JSX.Element;
381
-
382
- type BreadcrumbItem = {
383
- label: string;
384
- href?: string;
385
- };
386
- type BreadcrumbsProps = {
387
- items: BreadcrumbItem[];
388
- separator?: ReactNode;
389
- className?: string;
390
- };
391
- declare function Breadcrumbs({ items, separator, className }: Readonly<BreadcrumbsProps>): react_jsx_runtime.JSX.Element;
392
- declare namespace Breadcrumbs {
393
- var displayName: string;
394
- }
489
+ __dropdownIndex?: number;
490
+ __registerItem?: (el: HTMLButtonElement | null, index: number) => void;
491
+ };
492
+ declare function DropdownItem({ children, onSelect, variant, disabled, className, description, icon, endIcon, size }: Readonly<DropdownItemProps>): react_jsx_runtime.JSX.Element;
395
493
 
396
- type PaginationProps = {
397
- currentPage: number;
398
- totalPages: number;
399
- onPageChange: (page: number) => void;
400
- siblingCount?: number;
494
+ type NavProps = {
495
+ children: React__default.ReactNode;
401
496
  className?: string;
497
+ ariaLabel?: string;
498
+ direction?: 'horizontal' | 'vertical';
499
+ spacing?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
500
+ align?: 'start' | 'center' | 'end' | 'stretch';
402
501
  };
403
- declare function Pagination({ currentPage, totalPages, onPageChange, siblingCount, className }: Readonly<PaginationProps>): react_jsx_runtime.JSX.Element;
404
- declare namespace Pagination {
502
+ declare function Nav({ children, className, ariaLabel, direction, spacing, align }: Readonly<NavProps>): react_jsx_runtime.JSX.Element;
503
+ declare namespace Nav {
405
504
  var displayName: string;
406
505
  }
407
506
 
@@ -435,181 +534,104 @@ declare namespace Stepper {
435
534
  var displayName: string;
436
535
  }
437
536
 
438
- type ToastProps = {
439
- message?: string;
440
- children?: React.ReactNode;
441
- type?: 'info' | 'success' | 'warning' | 'error';
442
- onClose?: () => void;
443
- className?: string;
444
- duration?: number;
445
- };
446
- declare function Toast({ message, children, type, onClose, className, duration }: Readonly<ToastProps>): react_jsx_runtime.JSX.Element;
447
- declare namespace Toast {
448
- var displayName: string;
449
- }
450
-
451
- type TooltipProps = {
452
- children: ReactNode;
453
- content: string | ReactNode;
454
- position?: 'top' | 'bottom' | 'left' | 'right';
455
- variant?: 'default' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error' | 'neutral';
456
- open?: boolean;
457
- usePortal?: boolean;
458
- className?: string;
537
+ type Tab = {
538
+ id: string;
539
+ label: string;
540
+ content: React__default.ReactNode;
459
541
  };
460
- declare function Tooltip({ children, content, position, variant, open, usePortal, className }: Readonly<TooltipProps>): react_jsx_runtime.JSX.Element;
461
- declare namespace Tooltip {
462
- var displayName: string;
463
- }
464
-
465
- type ModalProps = {
466
- isOpen: boolean;
467
- onClose: () => void;
468
- children?: React__default.ReactNode;
469
- title?: React__default.ReactNode;
470
- description?: React__default.ReactNode;
471
- content?: React__default.ReactNode;
472
- actions?: React__default.ReactNode;
542
+ type TabsProps = {
543
+ tabs: Tab[];
544
+ defaultTab?: string;
473
545
  className?: string;
474
546
  ariaLabel?: string;
475
- align?: 'center' | 'top';
476
- portalRoot?: HTMLElement | null;
547
+ noBorder?: boolean;
477
548
  };
478
- declare function Modal({ isOpen, onClose, children, title, description, content, actions, className, ariaLabel, align, portalRoot }: Readonly<ModalProps>): react_jsx_runtime.JSX.Element | null;
479
- declare namespace Modal {
549
+ declare function Tabs({ tabs, defaultTab, className, ariaLabel, noBorder }: Readonly<TabsProps>): react_jsx_runtime.JSX.Element;
550
+ declare namespace Tabs {
480
551
  var displayName: string;
481
552
  }
482
553
 
483
- type DialogProps = {
484
- isOpen: boolean;
485
- onClose: () => void;
486
- title: string;
487
- children: React__default.ReactNode;
488
- actions?: React__default.ReactNode;
554
+ type PaginationProps = {
555
+ currentPage: number;
556
+ totalPages: number;
557
+ onPageChange: (page: number) => void;
558
+ siblingCount?: number;
489
559
  className?: string;
490
560
  };
491
- declare function Dialog({ isOpen, onClose, title, children, actions, className }: Readonly<DialogProps>): react_jsx_runtime.JSX.Element;
492
- declare namespace Dialog {
561
+ declare function Pagination({ currentPage, totalPages, onPageChange, siblingCount, className }: Readonly<PaginationProps>): react_jsx_runtime.JSX.Element;
562
+ declare namespace Pagination {
493
563
  var displayName: string;
494
564
  }
495
565
 
496
- type DeleteDialogProps = {
497
- isOpen: boolean;
498
- onClose: () => void;
499
- onConfirm: () => void;
500
- title?: string;
501
- description?: string;
502
- itemName?: string;
503
- isLoading?: boolean;
504
- confirmText?: string;
505
- cancelText?: string;
566
+ type NavbarProps = {
567
+ brand?: ReactNode;
568
+ children: ReactNode;
569
+ sticky?: boolean;
506
570
  className?: string;
571
+ actions?: ReactNode;
572
+ size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
573
+ appearance?: 'solid' | 'blur' | 'transparent';
574
+ border?: 'none' | 'bottom' | 'top' | 'both';
507
575
  };
508
- declare function DeleteDialog({ isOpen, onClose, onConfirm, title, description, itemName, isLoading, confirmText, cancelText, className }: Readonly<DeleteDialogProps>): react_jsx_runtime.JSX.Element;
509
- declare namespace DeleteDialog {
576
+ declare function Navbar({ brand, children, sticky, className, actions, size, appearance, border }: Readonly<NavbarProps>): react_jsx_runtime.JSX.Element;
577
+ declare namespace Navbar {
510
578
  var displayName: string;
511
579
  }
512
580
 
513
- type PopoverProps = {
514
- trigger?: React__default.ReactNode;
515
- children?: React__default.ReactNode;
516
- content: React__default.ReactNode;
517
- position?: 'top' | 'bottom' | 'left' | 'right';
581
+ type NavbarBrandProps = {
582
+ children: ReactNode;
583
+ href?: string;
584
+ external?: boolean;
585
+ onClick?: () => void;
518
586
  className?: string;
519
587
  };
520
- declare function Popover({ trigger, children, content, position, className }: Readonly<PopoverProps>): react_jsx_runtime.JSX.Element;
521
- declare namespace Popover {
588
+ declare function NavbarBrand({ children, href, external, onClick, className }: Readonly<NavbarBrandProps>): react_jsx_runtime.JSX.Element;
589
+ declare namespace NavbarBrand {
522
590
  var displayName: string;
523
591
  }
524
592
 
525
- type AlertProps = {
593
+ type NavbarLinkProps = {
594
+ href: string;
526
595
  children: ReactNode;
527
- type?: 'info' | 'success' | 'warning' | 'error';
528
- dismissible?: boolean;
529
- onClose?: () => void;
596
+ external?: boolean;
530
597
  className?: string;
531
- position?: 'top' | 'bottom' | 'relative';
532
- duration?: number;
598
+ end?: boolean;
533
599
  };
534
- declare function Alert({ children, type, dismissible, onClose, className, position, duration }: Readonly<AlertProps>): react_jsx_runtime.JSX.Element;
535
- declare namespace Alert {
536
- var displayName: string;
537
- }
538
-
539
- type SpinnerProps = {
540
- size?: 'sm' | 'md' | 'lg';
541
- variant?: 'primary' | 'accent' | 'secondary' | 'neutral';
542
- className?: string;
543
- speed?: string;
544
- } & React.HTMLAttributes<HTMLDivElement>;
545
- declare function Spinner({ size, variant, className, speed, ...props }: Readonly<SpinnerProps>): react_jsx_runtime.JSX.Element;
546
- declare namespace Spinner {
600
+ declare function NavbarLink({ href, children, external, className, end }: Readonly<NavbarLinkProps>): react_jsx_runtime.JSX.Element;
601
+ declare namespace NavbarLink {
547
602
  var displayName: string;
548
603
  }
549
604
 
550
- type ProgressBarProps = {
551
- value: number;
552
- max?: number;
553
- showLabel?: boolean;
554
- variant?: 'default' | 'success' | 'warning' | 'error';
605
+ interface NavbarToggleProps {
606
+ mobileMenuOpen?: boolean;
607
+ sidebarCollapsed?: boolean;
608
+ onMobileMenuToggle?: () => void;
609
+ onSidebarToggle?: () => void;
555
610
  className?: string;
556
- };
557
- declare function ProgressBar({ value, max, showLabel, variant, className }: Readonly<ProgressBarProps>): react_jsx_runtime.JSX.Element;
558
- declare namespace ProgressBar {
559
- var displayName: string;
560
611
  }
561
-
562
- type SkeletonProps = {
563
- variant?: 'text' | 'circular' | 'rectangular';
564
- width?: string;
565
- height?: string;
566
- className?: string;
567
- } & React.HTMLAttributes<HTMLDivElement>;
568
- declare function Skeleton({ variant, width, height, className, ...props }: Readonly<SkeletonProps>): react_jsx_runtime.JSX.Element;
569
- declare namespace Skeleton {
612
+ declare function NavbarToggle({ mobileMenuOpen, sidebarCollapsed, onMobileMenuToggle, onSidebarToggle, className }: NavbarToggleProps): react_jsx_runtime.JSX.Element;
613
+ declare namespace NavbarToggle {
570
614
  var displayName: string;
571
615
  }
572
616
 
573
- type TransitionType = 'fade' | 'slide-up' | 'slide-down' | 'slide-left' | 'slide-right' | 'scale' | 'scale-fade' | 'slide-fade-up' | 'slide-fade-down' | 'zoom';
574
- type TransitionDuration = 'fast' | 'normal' | 'slow' | number;
575
- type SmoothTransitionProps = {
576
- children: ReactNode;
577
- show?: boolean;
578
- type?: TransitionType;
579
- duration?: TransitionDuration;
580
- delay?: number;
617
+ type NavDropdownProps = {
618
+ label: string;
619
+ activePathPrefix: string;
620
+ children: React.ReactNode;
581
621
  className?: string;
582
- style?: CSSProperties;
583
- hover?: boolean;
584
- active?: boolean;
585
622
  };
586
- declare function SmoothTransition({ children, show, type, duration, delay, className, style, hover, active }: Readonly<SmoothTransitionProps>): react_jsx_runtime.JSX.Element;
587
- declare namespace SmoothTransition {
588
- var displayName: string;
589
- }
590
-
591
- declare function useStaggeredTransition(count: number, baseDelay?: number): number[];
592
-
593
- type BadgeProps = {
594
- children: ReactNode;
595
- variant?: 'default' | 'primary' | 'success' | 'warning' | 'error';
596
- size?: 'sm' | 'md' | 'lg';
597
- className?: string;
598
- } & React.HTMLAttributes<HTMLSpanElement>;
599
- declare function Badge({ children, variant, size, className, ...props }: Readonly<BadgeProps>): react_jsx_runtime.JSX.Element;
600
- declare namespace Badge {
623
+ declare function NavDropdown({ label, activePathPrefix, children, className }: Readonly<NavDropdownProps>): react_jsx_runtime.JSX.Element;
624
+ declare namespace NavDropdown {
601
625
  var displayName: string;
602
626
  }
603
627
 
604
- type StatusLabelProps = {
605
- children: ReactNode;
606
- status?: 'active' | 'inactive' | 'pending' | 'success' | 'error' | 'warning' | 'info';
607
- size?: 'sm' | 'md' | 'lg';
608
- variant?: 'filled' | 'outlined';
628
+ type NavDropdownItemProps = {
629
+ to: string;
630
+ children: React.ReactNode;
609
631
  className?: string;
610
632
  };
611
- declare function StatusLabel({ children, status, size, variant, className }: Readonly<StatusLabelProps>): react_jsx_runtime.JSX.Element;
612
- declare namespace StatusLabel {
633
+ declare function NavDropdownItem({ to, children, className }: Readonly<NavDropdownItemProps>): react_jsx_runtime.JSX.Element;
634
+ declare namespace NavDropdownItem {
613
635
  var displayName: string;
614
636
  }
615
637
 
@@ -625,80 +647,54 @@ declare namespace Avatar {
625
647
  var displayName: string;
626
648
  }
627
649
 
628
- type EmptyStateProps = {
629
- title: string;
630
- description?: string;
631
- icon?: ReactNode;
632
- action?: ReactNode;
633
- className?: string;
634
- };
635
- declare function EmptyState({ title, description, icon, action, className }: Readonly<EmptyStateProps>): react_jsx_runtime.JSX.Element;
636
- declare namespace EmptyState {
637
- var displayName: string;
638
- }
639
-
640
- type ListProps = {
641
- children: ReactNode;
642
- className?: string;
643
- ordered?: boolean;
644
- };
645
- type ListItemProps = {
646
- children: ReactNode;
647
- className?: string;
648
- };
649
- declare function List({ children, className, ordered }: Readonly<ListProps>): react_jsx_runtime.JSX.Element;
650
- declare namespace List {
651
- var displayName: string;
652
- }
653
- declare function ListItem({ children, className }: Readonly<ListItemProps>): react_jsx_runtime.JSX.Element;
654
- declare namespace ListItem {
655
- var displayName: string;
656
- }
657
-
658
- type TableProps = {
659
- children: ReactNode;
660
- className?: string;
661
- striped?: boolean;
662
- bordered?: boolean;
663
- hoverable?: boolean;
664
- compact?: boolean;
665
- caption?: string;
666
- } & HTMLAttributes<HTMLTableElement>;
667
- type TableHeaderProps = {
668
- children: ReactNode;
669
- className?: string;
670
- } & HTMLAttributes<HTMLTableSectionElement>;
671
- type TableBodyProps = {
672
- children: ReactNode;
673
- className?: string;
674
- } & HTMLAttributes<HTMLTableSectionElement>;
675
- type TableFooterProps = {
676
- children: ReactNode;
677
- className?: string;
678
- } & HTMLAttributes<HTMLTableSectionElement>;
679
- type TableRowProps = {
650
+ type BadgeProps = {
680
651
  children: ReactNode;
652
+ variant?: 'default' | 'primary' | 'success' | 'warning' | 'error';
653
+ size?: 'sm' | 'md' | 'lg';
681
654
  className?: string;
682
- selected?: boolean;
683
- } & HTMLAttributes<HTMLTableRowElement>;
684
- type TableHeadCellProps = {
655
+ } & React.HTMLAttributes<HTMLSpanElement>;
656
+ declare function Badge({ children, variant, size, className, ...props }: Readonly<BadgeProps>): react_jsx_runtime.JSX.Element;
657
+ declare namespace Badge {
658
+ var displayName: string;
659
+ }
660
+
661
+ type StatusLabelProps = {
685
662
  children: ReactNode;
663
+ status?: 'active' | 'inactive' | 'pending' | 'success' | 'error' | 'warning' | 'info';
664
+ size?: 'sm' | 'md' | 'lg';
665
+ variant?: 'filled' | 'outlined';
686
666
  className?: string;
687
- align?: 'left' | 'center' | 'right';
688
- scope?: 'col' | 'row';
689
- } & HTMLAttributes<HTMLTableCellElement>;
690
- type TableCellProps = {
667
+ };
668
+ declare function StatusLabel({ children, status, size, variant, className }: Readonly<StatusLabelProps>): react_jsx_runtime.JSX.Element;
669
+ declare namespace StatusLabel {
670
+ var displayName: string;
671
+ }
672
+
673
+ type ChipProps = {
691
674
  children: ReactNode;
692
675
  className?: string;
693
- align?: 'left' | 'center' | 'right';
694
- } & HTMLAttributes<HTMLTableCellElement>;
695
- declare function Table({ children, className, striped, bordered, hoverable, compact, caption, ...props }: Readonly<TableProps>): react_jsx_runtime.JSX.Element;
696
- declare function TableHeader({ children, className, ...props }: Readonly<TableHeaderProps>): react_jsx_runtime.JSX.Element;
697
- declare function TableBody({ children, className, ...props }: Readonly<TableBodyProps>): react_jsx_runtime.JSX.Element;
698
- declare function TableFooter({ children, className, ...props }: Readonly<TableFooterProps>): react_jsx_runtime.JSX.Element;
699
- declare function TableRow({ children, className, selected, ...props }: Readonly<TableRowProps>): react_jsx_runtime.JSX.Element;
700
- declare function TableHeadCell({ children, className, align, scope, ...props }: Readonly<TableHeadCellProps>): react_jsx_runtime.JSX.Element;
701
- declare function TableCell({ children, className, align, ...props }: Readonly<TableCellProps>): react_jsx_runtime.JSX.Element;
676
+ variant?: 'default' | 'primary' | 'success' | 'warning' | 'error';
677
+ size?: 'sm' | 'md' | 'lg';
678
+ onRemove?: (e: MouseEvent<HTMLButtonElement>) => void;
679
+ icon?: ReactNode;
680
+ disabled?: boolean;
681
+ clickable?: boolean;
682
+ onClick?: (e: MouseEvent<HTMLDivElement>) => void;
683
+ };
684
+ declare function Chip({ children, className, variant, size, onRemove, icon, disabled, clickable, onClick }: Readonly<ChipProps>): react_jsx_runtime.JSX.Element;
685
+ declare namespace Chip {
686
+ var displayName: string;
687
+ }
688
+
689
+ type CodeBlockProps = {
690
+ code: string;
691
+ className?: string;
692
+ showCopy?: boolean;
693
+ };
694
+ declare function CodeBlock({ code, className, showCopy }: Readonly<CodeBlockProps>): react_jsx_runtime.JSX.Element;
695
+ declare namespace CodeBlock {
696
+ var displayName: string;
697
+ }
702
698
 
703
699
  type DataTableAction<T> = {
704
700
  icon: ReactNode;
@@ -779,19 +775,33 @@ type UseTableReturn<T> = {
779
775
  };
780
776
  declare function useTable<T>({ data, initialSort, pageSize }: UseTableOptions<T>): UseTableReturn<T>;
781
777
 
782
- type ChipProps = {
778
+ type EmptyStateProps = {
779
+ title: string;
780
+ description?: string;
781
+ icon?: ReactNode;
782
+ action?: ReactNode;
783
+ className?: string;
784
+ };
785
+ declare function EmptyState({ title, description, icon, action, className }: Readonly<EmptyStateProps>): react_jsx_runtime.JSX.Element;
786
+ declare namespace EmptyState {
787
+ var displayName: string;
788
+ }
789
+
790
+ type ListProps = {
783
791
  children: ReactNode;
784
792
  className?: string;
785
- variant?: 'default' | 'primary' | 'success' | 'warning' | 'error';
786
- size?: 'sm' | 'md' | 'lg';
787
- onRemove?: (e: MouseEvent<HTMLButtonElement>) => void;
788
- icon?: ReactNode;
789
- disabled?: boolean;
790
- clickable?: boolean;
791
- onClick?: (e: MouseEvent<HTMLDivElement>) => void;
793
+ ordered?: boolean;
792
794
  };
793
- declare function Chip({ children, className, variant, size, onRemove, icon, disabled, clickable, onClick }: Readonly<ChipProps>): react_jsx_runtime.JSX.Element;
794
- declare namespace Chip {
795
+ type ListItemProps = {
796
+ children: ReactNode;
797
+ className?: string;
798
+ };
799
+ declare function List({ children, className, ordered }: Readonly<ListProps>): react_jsx_runtime.JSX.Element;
800
+ declare namespace List {
801
+ var displayName: string;
802
+ }
803
+ declare function ListItem({ children, className }: Readonly<ListItemProps>): react_jsx_runtime.JSX.Element;
804
+ declare namespace ListItem {
795
805
  var displayName: string;
796
806
  }
797
807
 
@@ -816,6 +826,17 @@ declare namespace Timeline {
816
826
  var displayName: string;
817
827
  }
818
828
 
829
+ type PriceDisplayProps = {
830
+ amount: string | number;
831
+ period?: string;
832
+ currency?: string;
833
+ className?: string;
834
+ };
835
+ declare function PriceDisplay({ amount, period, currency, className }: Readonly<PriceDisplayProps>): react_jsx_runtime.JSX.Element;
836
+ declare namespace PriceDisplay {
837
+ var displayName: string;
838
+ }
839
+
819
840
  type PricingTableProps = {
820
841
  title?: string;
821
842
  description?: string;
@@ -849,303 +870,526 @@ declare namespace PricingTier {
849
870
  var displayName: string;
850
871
  }
851
872
 
852
- type CodeBlockProps = {
853
- code: string;
873
+ type TableProps = {
874
+ children: ReactNode;
875
+ className?: string;
876
+ striped?: boolean;
877
+ bordered?: boolean;
878
+ hoverable?: boolean;
879
+ compact?: boolean;
880
+ caption?: string;
881
+ } & HTMLAttributes<HTMLTableElement>;
882
+ type TableHeaderProps = {
883
+ children: ReactNode;
884
+ className?: string;
885
+ } & HTMLAttributes<HTMLTableSectionElement>;
886
+ type TableBodyProps = {
887
+ children: ReactNode;
888
+ className?: string;
889
+ } & HTMLAttributes<HTMLTableSectionElement>;
890
+ type TableFooterProps = {
891
+ children: ReactNode;
892
+ className?: string;
893
+ } & HTMLAttributes<HTMLTableSectionElement>;
894
+ type TableRowProps = {
895
+ children: ReactNode;
896
+ className?: string;
897
+ selected?: boolean;
898
+ } & HTMLAttributes<HTMLTableRowElement>;
899
+ type TableHeadCellProps = {
900
+ children: ReactNode;
901
+ className?: string;
902
+ align?: 'left' | 'center' | 'right';
903
+ scope?: 'col' | 'row';
904
+ } & HTMLAttributes<HTMLTableCellElement>;
905
+ type TableCellProps = {
906
+ children: ReactNode;
907
+ className?: string;
908
+ align?: 'left' | 'center' | 'right';
909
+ } & HTMLAttributes<HTMLTableCellElement>;
910
+ declare function Table({ children, className, striped, bordered, hoverable, compact, caption, ...props }: Readonly<TableProps>): react_jsx_runtime.JSX.Element;
911
+ declare function TableHeader({ children, className, ...props }: Readonly<TableHeaderProps>): react_jsx_runtime.JSX.Element;
912
+ declare function TableBody({ children, className, ...props }: Readonly<TableBodyProps>): react_jsx_runtime.JSX.Element;
913
+ declare function TableFooter({ children, className, ...props }: Readonly<TableFooterProps>): react_jsx_runtime.JSX.Element;
914
+ declare function TableRow({ children, className, selected, ...props }: Readonly<TableRowProps>): react_jsx_runtime.JSX.Element;
915
+ declare function TableHeadCell({ children, className, align, scope, ...props }: Readonly<TableHeadCellProps>): react_jsx_runtime.JSX.Element;
916
+ declare function TableCell({ children, className, align, ...props }: Readonly<TableCellProps>): react_jsx_runtime.JSX.Element;
917
+
918
+ type AlertProps = {
919
+ children: ReactNode;
920
+ type?: 'info' | 'success' | 'warning' | 'error';
921
+ dismissible?: boolean;
922
+ onClose?: () => void;
923
+ className?: string;
924
+ position?: 'top' | 'bottom' | 'relative';
925
+ duration?: number;
926
+ };
927
+ declare function Alert({ children, type, dismissible, onClose, className, position, duration }: Readonly<AlertProps>): react_jsx_runtime.JSX.Element;
928
+ declare namespace Alert {
929
+ var displayName: string;
930
+ }
931
+
932
+ type DialogProps = {
933
+ isOpen: boolean;
934
+ onClose: () => void;
935
+ title: string;
936
+ children: React__default.ReactNode;
937
+ actions?: React__default.ReactNode;
938
+ className?: string;
939
+ };
940
+ declare function Dialog({ isOpen, onClose, title, children, actions, className }: Readonly<DialogProps>): react_jsx_runtime.JSX.Element;
941
+ declare namespace Dialog {
942
+ var displayName: string;
943
+ }
944
+
945
+ type DeleteDialogProps = {
946
+ isOpen: boolean;
947
+ onClose: () => void;
948
+ onConfirm: () => void;
949
+ title?: string;
950
+ description?: string;
951
+ itemName?: string;
952
+ isLoading?: boolean;
953
+ confirmText?: string;
954
+ cancelText?: string;
955
+ className?: string;
956
+ };
957
+ declare function DeleteDialog({ isOpen, onClose, onConfirm, title, description, itemName, isLoading, confirmText, cancelText, className }: Readonly<DeleteDialogProps>): react_jsx_runtime.JSX.Element;
958
+ declare namespace DeleteDialog {
959
+ var displayName: string;
960
+ }
961
+
962
+ type ModalProps = {
963
+ isOpen: boolean;
964
+ onClose: () => void;
965
+ children?: React__default.ReactNode;
966
+ title?: React__default.ReactNode;
967
+ description?: React__default.ReactNode;
968
+ content?: React__default.ReactNode;
969
+ actions?: React__default.ReactNode;
970
+ className?: string;
971
+ ariaLabel?: string;
972
+ align?: 'center' | 'top';
973
+ portalRoot?: HTMLElement | null;
974
+ };
975
+ declare function Modal({ isOpen, onClose, children, title, description, content, actions, className, ariaLabel, align, portalRoot }: Readonly<ModalProps>): react_jsx_runtime.JSX.Element | null;
976
+ declare namespace Modal {
977
+ var displayName: string;
978
+ }
979
+
980
+ type OverlayPhase = 'mount' | 'animating-in' | 'visible' | 'animating-out';
981
+ interface UseOverlayOptions {
982
+ isOpen: boolean;
983
+ onClose?: () => void;
984
+ focusTrap?: boolean;
985
+ lockScroll?: boolean;
986
+ animationFrames?: number;
987
+ restoreFocus?: boolean;
988
+ exitDuration?: number;
989
+ unmountOnExit?: boolean;
990
+ }
991
+ interface UseOverlayResult<T extends HTMLElement> {
992
+ phase: OverlayPhase;
993
+ shouldRender: boolean;
994
+ ref: React.RefObject<T>;
995
+ getPhaseClass: (openClass: string, closedClass: string) => string;
996
+ }
997
+ declare function useOverlay<T extends HTMLElement>(options: UseOverlayOptions): UseOverlayResult<T>;
998
+
999
+ type PopoverProps = {
1000
+ trigger?: React__default.ReactNode;
1001
+ children?: React__default.ReactNode;
1002
+ content: React__default.ReactNode;
1003
+ position?: 'top' | 'bottom' | 'left' | 'right';
1004
+ className?: string;
1005
+ };
1006
+ declare function Popover({ trigger, children, content, position, className }: Readonly<PopoverProps>): react_jsx_runtime.JSX.Element;
1007
+ declare namespace Popover {
1008
+ var displayName: string;
1009
+ }
1010
+
1011
+ type ProgressBarProps = {
1012
+ value: number;
1013
+ max?: number;
1014
+ showLabel?: boolean;
1015
+ variant?: 'default' | 'success' | 'warning' | 'error';
1016
+ className?: string;
1017
+ };
1018
+ declare function ProgressBar({ value, max, showLabel, variant, className }: Readonly<ProgressBarProps>): react_jsx_runtime.JSX.Element;
1019
+ declare namespace ProgressBar {
1020
+ var displayName: string;
1021
+ }
1022
+
1023
+ type SkeletonProps = {
1024
+ variant?: 'text' | 'circular' | 'rectangular';
1025
+ width?: string;
1026
+ height?: string;
1027
+ className?: string;
1028
+ } & React.HTMLAttributes<HTMLDivElement>;
1029
+ declare function Skeleton({ variant, width, height, className, ...props }: Readonly<SkeletonProps>): react_jsx_runtime.JSX.Element;
1030
+ declare namespace Skeleton {
1031
+ var displayName: string;
1032
+ }
1033
+
1034
+ type TransitionType = 'fade' | 'slide-up' | 'slide-down' | 'slide-left' | 'slide-right' | 'scale' | 'scale-fade' | 'slide-fade-up' | 'slide-fade-down' | 'zoom';
1035
+ type TransitionDuration = 'fast' | 'normal' | 'slow' | number;
1036
+ type SmoothTransitionProps = {
1037
+ children: ReactNode;
1038
+ show?: boolean;
1039
+ type?: TransitionType;
1040
+ duration?: TransitionDuration;
1041
+ delay?: number;
854
1042
  className?: string;
855
- showCopy?: boolean;
1043
+ style?: CSSProperties;
1044
+ hover?: boolean;
1045
+ active?: boolean;
856
1046
  };
857
- declare function CodeBlock({ code, className, showCopy }: Readonly<CodeBlockProps>): react_jsx_runtime.JSX.Element;
858
- declare namespace CodeBlock {
1047
+ declare function SmoothTransition({ children, show, type, duration, delay, className, style, hover, active }: Readonly<SmoothTransitionProps>): react_jsx_runtime.JSX.Element;
1048
+ declare namespace SmoothTransition {
859
1049
  var displayName: string;
860
1050
  }
861
1051
 
862
- type CardProps = {
863
- children: React__default.ReactNode;
1052
+ declare function useStaggeredTransition(count: number, baseDelay?: number): number[];
1053
+
1054
+ type SpinnerProps = {
1055
+ size?: 'sm' | 'md' | 'lg';
1056
+ variant?: 'primary' | 'accent' | 'secondary' | 'neutral';
864
1057
  className?: string;
865
- variant?: 'default' | 'bordered' | 'ghost' | 'filled';
866
- size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
867
- width?: 'auto' | 'full' | 'fit';
868
- hoverable?: boolean;
869
- imagePosition?: 'top' | 'bottom' | 'side' | 'overlay';
870
- centered?: boolean;
871
- compact?: boolean;
872
- } & React__default.HTMLAttributes<HTMLDivElement>;
873
- declare function Card({ children, className, variant, size, width, hoverable, imagePosition, centered, compact, ...props }: Readonly<CardProps>): react_jsx_runtime.JSX.Element;
874
- declare namespace Card {
1058
+ speed?: string;
1059
+ } & React.HTMLAttributes<HTMLDivElement>;
1060
+ declare function Spinner({ size, variant, className, speed, ...props }: Readonly<SpinnerProps>): react_jsx_runtime.JSX.Element;
1061
+ declare namespace Spinner {
875
1062
  var displayName: string;
876
1063
  }
877
1064
 
878
- type CardHeaderProps = {
879
- children: ReactNode;
1065
+ type ToastProps = {
1066
+ message?: string;
1067
+ children?: React.ReactNode;
1068
+ type?: 'info' | 'success' | 'warning' | 'error';
1069
+ onClose?: () => void;
880
1070
  className?: string;
881
- bordered?: boolean;
882
- padding?: 'none' | 'sm' | 'md' | 'lg';
1071
+ duration?: number;
883
1072
  };
884
- declare function CardHeader({ children, className, bordered, padding }: Readonly<CardHeaderProps>): react_jsx_runtime.JSX.Element;
885
- declare namespace CardHeader {
1073
+ declare function Toast({ message, children, type, onClose, className, duration }: Readonly<ToastProps>): react_jsx_runtime.JSX.Element;
1074
+ declare namespace Toast {
886
1075
  var displayName: string;
887
1076
  }
888
1077
 
889
- interface CardBodyProps {
890
- children: React.ReactNode;
891
- padding?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
1078
+ type TooltipProps = {
1079
+ children: ReactNode;
1080
+ content: string | ReactNode;
1081
+ position?: 'top' | 'bottom' | 'left' | 'right';
1082
+ variant?: 'default' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error' | 'neutral';
1083
+ open?: boolean;
1084
+ usePortal?: boolean;
892
1085
  className?: string;
893
- }
894
- declare function CardBody({ children, padding, className }: CardBodyProps): react_jsx_runtime.JSX.Element;
895
- declare namespace CardBody {
1086
+ };
1087
+ declare function Tooltip({ children, content, position, variant, open, usePortal, className }: Readonly<TooltipProps>): react_jsx_runtime.JSX.Element;
1088
+ declare namespace Tooltip {
896
1089
  var displayName: string;
897
1090
  }
898
1091
 
899
- type CardFooterProps = {
1092
+ type ButtonGroupProps = {
900
1093
  children: ReactNode;
901
1094
  className?: string;
902
- bordered?: boolean;
903
- padding?: 'none' | 'sm' | 'md' | 'lg';
904
- align?: 'start' | 'center' | 'end';
1095
+ variant?: 'default' | 'separated';
1096
+ orientation?: 'horizontal' | 'vertical';
905
1097
  };
906
- declare function CardFooter({ children, className, bordered, padding, align }: Readonly<CardFooterProps>): react_jsx_runtime.JSX.Element;
907
- declare namespace CardFooter {
1098
+ declare function ButtonGroup({ children, className, variant, orientation }: Readonly<ButtonGroupProps>): react_jsx_runtime.JSX.Element;
1099
+ declare namespace ButtonGroup {
908
1100
  var displayName: string;
909
1101
  }
910
1102
 
911
- type CardTitleProps = {
912
- children: ReactNode;
1103
+ interface ButtonWithIconProps extends Omit<ButtonProps, 'icon' | 'style'> {
1104
+ icon?: string;
1105
+ iconSize?: IconSize;
1106
+ iconColor?: string;
1107
+ buttonStyle?: ButtonProps['style'];
1108
+ children?: React__default.ReactNode;
1109
+ }
1110
+ declare const ButtonWithIcon: React__default.ForwardRefExoticComponent<ButtonWithIconProps & React__default.RefAttributes<HTMLButtonElement>>;
1111
+
1112
+ interface IconButtonProps extends Omit<ButtonProps, 'icon' | 'style' | 'children'> {
1113
+ icon: string;
1114
+ ariaLabel: string;
1115
+ iconSize?: IconSize;
1116
+ iconColor?: string;
1117
+ buttonStyle?: ButtonProps['style'];
1118
+ children?: never;
1119
+ }
1120
+ declare const IconButton: React__default.ForwardRefExoticComponent<IconButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
1121
+
1122
+ type CalendarProps = {
1123
+ value?: Date;
1124
+ onChange?: (date: Date) => void;
1125
+ minDate?: Date;
1126
+ maxDate?: Date;
1127
+ disabled?: boolean;
913
1128
  className?: string;
914
- as?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
915
- size?: 'sm' | 'md' | 'lg' | 'xl';
916
1129
  };
917
- declare function CardTitle({ children, className, as: Component, size }: Readonly<CardTitleProps>): react_jsx_runtime.JSX.Element;
918
- declare namespace CardTitle {
1130
+ declare function Calendar({ value, onChange, minDate, maxDate, disabled, className }: Readonly<CalendarProps>): react_jsx_runtime.JSX.Element;
1131
+ declare namespace Calendar {
919
1132
  var displayName: string;
920
1133
  }
921
1134
 
922
- type CardActionsProps = {
923
- children: ReactNode;
1135
+ type DatePickerProps = {
1136
+ value?: Date;
1137
+ onChange?: (date: Date | undefined) => void;
1138
+ minDate?: Date;
1139
+ maxDate?: Date;
1140
+ placeholder?: string;
1141
+ disabled?: boolean;
1142
+ dateFormat?: string;
1143
+ clearable?: boolean;
924
1144
  className?: string;
925
- align?: 'start' | 'center' | 'end' | 'stretch';
926
- direction?: 'row' | 'column';
1145
+ size?: 'sm' | 'md' | 'lg';
927
1146
  };
928
- declare function CardActions({ children, className, align, direction }: Readonly<CardActionsProps>): react_jsx_runtime.JSX.Element;
929
- declare namespace CardActions {
1147
+ declare function DatePicker({ value, onChange, minDate, maxDate, placeholder, disabled, dateFormat, clearable, className, size }: Readonly<DatePickerProps>): react_jsx_runtime.JSX.Element;
1148
+ declare namespace DatePicker {
930
1149
  var displayName: string;
931
1150
  }
932
1151
 
933
- type CardFigureProps = {
934
- children: ReactNode;
1152
+ type ValidationState$5 = 'default' | 'error' | 'success' | 'warning';
1153
+ type CheckboxProps = {
1154
+ checked?: boolean;
1155
+ onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
1156
+ disabled?: boolean;
935
1157
  className?: string;
936
- aspectRatio?: 'square' | 'video' | 'wide' | 'portrait' | 'auto';
1158
+ ariaLabel?: string;
1159
+ id?: string;
1160
+ name?: string;
1161
+ validationState?: ValidationState$5;
937
1162
  };
938
- declare function CardFigure({ children, className, aspectRatio }: Readonly<CardFigureProps>): react_jsx_runtime.JSX.Element;
939
- declare namespace CardFigure {
1163
+ declare function Checkbox({ checked, onChange, disabled, className, ariaLabel, id, name, validationState }: Readonly<CheckboxProps>): react_jsx_runtime.JSX.Element;
1164
+ declare namespace Checkbox {
940
1165
  var displayName: string;
941
1166
  }
942
1167
 
943
- type ContainerProps = {
944
- children: React__default.ReactNode;
1168
+ type CodeProps$1 = {
1169
+ children: React.ReactNode;
1170
+ size?: 'sm' | 'md' | 'lg';
1171
+ variant?: 'default' | 'primary' | 'success' | 'warning' | 'error';
945
1172
  className?: string;
946
- size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
947
- padding?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
948
- align?: 'start' | 'center' | 'end';
949
- minWidth?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | 'full' | string;
950
- minHeight?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | 'screen' | string;
951
1173
  };
952
- declare function Container({ children, className, size, padding, align, minWidth, minHeight }: Readonly<ContainerProps>): react_jsx_runtime.JSX.Element;
953
- declare namespace Container {
1174
+ declare function Code$1({ children, size, variant, className }: Readonly<CodeProps$1>): react_jsx_runtime.JSX.Element;
1175
+ declare namespace Code$1 {
954
1176
  var displayName: string;
955
1177
  }
956
1178
 
957
- type GridProps = {
958
- children: React__default.ReactNode;
1179
+ type FieldsetProps = {
1180
+ children: ReactNode;
1181
+ legend?: string;
1182
+ disabled?: boolean;
959
1183
  className?: string;
960
- itemSize?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
961
- maxCols?: number;
962
- gap?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
963
- responsive?: {
964
- sm?: number;
965
- md?: number;
966
- lg?: number;
967
- xl?: number;
968
- };
969
- alignItems?: 'start' | 'center' | 'end' | 'stretch';
970
- justifyItems?: 'start' | 'center' | 'end' | 'stretch';
1184
+ legendClassName?: string;
1185
+ id?: string;
1186
+ direction?: 'horizontal' | 'vertical';
1187
+ spacing?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
1188
+ align?: 'start' | 'center' | 'end' | 'stretch';
1189
+ justify?: 'start' | 'center' | 'end' | 'between' | 'around';
971
1190
  };
972
- declare function Grid({ children, className, itemSize, maxCols, gap, responsive, alignItems, justifyItems }: Readonly<GridProps>): react_jsx_runtime.JSX.Element;
973
- declare namespace Grid {
1191
+ declare function Fieldset({ children, legend, disabled, className, legendClassName, id, direction, spacing, align, justify }: Readonly<FieldsetProps>): react_jsx_runtime.JSX.Element;
1192
+ declare namespace Fieldset {
974
1193
  var displayName: string;
975
1194
  }
976
1195
 
977
- type StackProps = {
978
- children: React__default.ReactNode;
1196
+ type FormProps = {
1197
+ children: ReactNode;
1198
+ onSubmit?: (e: FormEvent<HTMLFormElement>) => void;
979
1199
  className?: string;
1200
+ method?: 'get' | 'post';
1201
+ action?: string;
1202
+ noValidate?: boolean;
1203
+ id?: string;
1204
+ ariaLabel?: string;
1205
+ ariaLabelledBy?: string;
980
1206
  direction?: 'horizontal' | 'vertical';
981
1207
  spacing?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
982
1208
  align?: 'start' | 'center' | 'end' | 'stretch';
983
1209
  justify?: 'start' | 'center' | 'end' | 'between' | 'around';
984
1210
  };
985
- declare function Stack({ children, className, direction, spacing, align, justify }: Readonly<StackProps>): react_jsx_runtime.JSX.Element;
986
- declare namespace Stack {
1211
+ declare function Form({ children, onSubmit, className, method, action, noValidate, id, ariaLabel, ariaLabelledBy, direction, spacing, align, justify }: Readonly<FormProps>): react_jsx_runtime.JSX.Element;
1212
+ declare namespace Form {
987
1213
  var displayName: string;
988
1214
  }
989
1215
 
990
- type DividerProps = {
991
- orientation?: 'horizontal' | 'vertical';
1216
+ type ValidationState$4 = 'default' | 'error' | 'success' | 'warning';
1217
+ type FormFieldProps = {
1218
+ children: ReactNode;
1219
+ label?: string;
1220
+ htmlFor?: string;
1221
+ error?: string;
1222
+ helperText?: string;
1223
+ required?: boolean;
992
1224
  className?: string;
993
- } & React.HTMLAttributes<HTMLHRElement>;
994
- declare function Divider({ orientation, className, ...props }: Readonly<DividerProps>): react_jsx_runtime.JSX.Element;
995
- declare namespace Divider {
1225
+ validationState?: ValidationState$4;
1226
+ };
1227
+ declare function FormField({ children, label, htmlFor, error, helperText, required, className, validationState }: Readonly<FormFieldProps>): react_jsx_runtime.JSX.Element;
1228
+ declare namespace FormField {
996
1229
  var displayName: string;
997
1230
  }
998
1231
 
999
- type DrawerProps = {
1000
- isOpen: boolean;
1001
- onClose: () => void;
1002
- children: ReactNode;
1003
- position?: 'left' | 'right' | 'top' | 'bottom';
1232
+ type ValidationState$3 = 'default' | 'error' | 'success' | 'warning';
1233
+ type InputProps = {
1234
+ value?: string;
1235
+ onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
1236
+ onFocus?: (e: React__default.FocusEvent<HTMLInputElement>) => void;
1237
+ placeholder?: string;
1238
+ disabled?: boolean;
1239
+ type?: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url';
1004
1240
  className?: string;
1005
- title?: string;
1006
- size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
1007
- closeOnEscape?: boolean;
1008
- closeOnOutside?: boolean;
1009
- unmountOnExit?: boolean;
1010
- portalRoot?: HTMLElement | null;
1011
- noAnimation?: boolean;
1241
+ ariaLabel?: string;
1242
+ ref?: React__default.Ref<HTMLInputElement>;
1243
+ id?: string;
1244
+ name?: string;
1245
+ required?: boolean;
1246
+ size?: 'sm' | 'md' | 'lg';
1247
+ validationState?: ValidationState$3;
1012
1248
  };
1013
- declare function Drawer({ isOpen, onClose, children, position, className, title, size, closeOnEscape, closeOnOutside, unmountOnExit, portalRoot, noAnimation }: Readonly<DrawerProps>): react_jsx_runtime.JSX.Element | null;
1014
- declare namespace Drawer {
1249
+ declare function Input({ value, onChange, onFocus, placeholder, disabled, type, className, ariaLabel, ref, id, name, required, size, validationState }: Readonly<InputProps>): react_jsx_runtime.JSX.Element;
1250
+ declare namespace Input {
1015
1251
  var displayName: string;
1016
1252
  }
1017
1253
 
1018
- type PageProps = {
1019
- children: React__default.ReactNode;
1254
+ type InputGroupProps = {
1255
+ children: ReactNode;
1256
+ prefix?: ReactNode;
1257
+ suffix?: ReactNode;
1020
1258
  className?: string;
1021
1259
  };
1022
- declare function Page({ children, className }: Readonly<PageProps>): react_jsx_runtime.JSX.Element;
1023
- declare namespace Page {
1260
+ declare function InputGroup({ children, prefix, suffix, className }: Readonly<InputGroupProps>): react_jsx_runtime.JSX.Element;
1261
+ declare namespace InputGroup {
1024
1262
  var displayName: string;
1025
1263
  }
1026
1264
 
1027
- type AccordionItemProps = {
1028
- title: string;
1029
- children: ReactNode;
1030
- defaultOpen?: boolean;
1265
+ type MultiSelectOption = {
1266
+ value: string;
1267
+ label: string;
1031
1268
  };
1032
- type AccordionProps = {
1033
- children: ReactNode;
1269
+ type MultiSelectProps = {
1270
+ options: MultiSelectOption[];
1271
+ value?: string[];
1272
+ onChange?: (values: string[]) => void;
1273
+ placeholder?: string;
1274
+ disabled?: boolean;
1275
+ maxSelections?: number;
1276
+ size?: 'sm' | 'md' | 'lg';
1034
1277
  className?: string;
1035
- allowMultiple?: boolean;
1036
1278
  };
1037
- declare function AccordionItem({ title, children, defaultOpen }: Readonly<AccordionItemProps>): react_jsx_runtime.JSX.Element;
1038
- declare function Accordion({ children, className }: Readonly<AccordionProps>): react_jsx_runtime.JSX.Element;
1039
- declare namespace Accordion {
1279
+ declare function MultiSelect({ options, value, onChange, placeholder, disabled, maxSelections, size, className }: Readonly<MultiSelectProps>): react_jsx_runtime.JSX.Element;
1280
+ declare namespace MultiSelect {
1281
+ var displayName: string;
1282
+ }
1283
+
1284
+ type ValidationState$2 = 'default' | 'error' | 'success' | 'warning';
1285
+ type RadioProps = {
1286
+ checked?: boolean;
1287
+ onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
1288
+ disabled?: boolean;
1289
+ className?: string;
1290
+ ariaLabel?: string;
1291
+ id?: string;
1292
+ name?: string;
1293
+ value?: string;
1294
+ validationState?: ValidationState$2;
1295
+ };
1296
+ declare function Radio({ checked, onChange, disabled, className, ariaLabel, id, name: nameProp, value, validationState }: Readonly<RadioProps>): react_jsx_runtime.JSX.Element;
1297
+ declare namespace Radio {
1040
1298
  var displayName: string;
1041
1299
  }
1042
1300
 
1043
- type HeroAction = {
1044
- label: string;
1045
- onClick: () => void;
1046
- variant?: 'primary' | 'secondary' | 'neutral' | 'error' | 'accent';
1047
- style?: 'solid' | 'outline' | 'ghost';
1048
- loading?: boolean;
1049
- icon?: ReactNode;
1050
- };
1051
- type HeroProps = {
1052
- title: string;
1053
- subtitle?: string;
1054
- description?: string;
1055
- primaryAction?: HeroAction;
1056
- secondaryAction?: HeroAction;
1057
- children?: ReactNode;
1301
+ type RadioGroupProps = {
1302
+ children: ReactNode;
1303
+ name: string;
1304
+ label?: string;
1305
+ orientation?: 'horizontal' | 'vertical';
1058
1306
  className?: string;
1059
- variant?: 'gradient' | 'solid' | 'minimal';
1060
- centered?: boolean;
1061
- size?: 'sm' | 'md' | 'lg';
1307
+ value?: string;
1308
+ onChange?: (value: string) => void;
1062
1309
  };
1063
- declare function Hero({ title, subtitle, description, primaryAction, secondaryAction, children, className, variant, centered, size }: Readonly<HeroProps>): react_jsx_runtime.JSX.Element;
1064
- declare namespace Hero {
1310
+ declare function RadioGroup({ children, name, label, orientation, className, value, onChange }: Readonly<RadioGroupProps>): react_jsx_runtime.JSX.Element;
1311
+ declare namespace RadioGroup {
1065
1312
  var displayName: string;
1066
1313
  }
1067
1314
 
1068
- type Feature = {
1069
- icon: ReactNode;
1070
- title: string;
1071
- description: string;
1072
- };
1073
- type FeatureSectionProps = {
1074
- title?: string;
1075
- description?: string;
1076
- features: Feature[];
1077
- columns?: 2 | 3 | 4;
1078
- centered?: boolean;
1315
+ type ValidationState$1 = 'default' | 'error' | 'success' | 'warning';
1316
+ type SelectProps = {
1317
+ value?: string;
1318
+ onChange?: (e: React__default.ChangeEvent<HTMLSelectElement>) => void;
1319
+ disabled?: boolean;
1079
1320
  className?: string;
1321
+ ariaLabel?: string;
1322
+ id?: string;
1323
+ name?: string;
1324
+ children: React__default.ReactNode;
1325
+ required?: boolean;
1326
+ size?: 'sm' | 'md' | 'lg';
1327
+ validationState?: ValidationState$1;
1080
1328
  };
1081
- declare function FeatureSection({ title, description, features, columns, centered, className }: Readonly<FeatureSectionProps>): react_jsx_runtime.JSX.Element;
1082
- declare namespace FeatureSection {
1329
+ declare function Select({ value, onChange, disabled, className, ariaLabel, id, name, children, required, size, validationState }: Readonly<SelectProps>): react_jsx_runtime.JSX.Element;
1330
+ declare namespace Select {
1083
1331
  var displayName: string;
1084
1332
  }
1085
1333
 
1086
- type FooterSection = {
1087
- title: string;
1088
- links: Array<{
1089
- label: string;
1090
- href: string;
1091
- external?: boolean;
1092
- }>;
1093
- };
1094
- type FooterProps = {
1095
- sections?: FooterSection[];
1096
- copyright?: string;
1097
- social?: ReactNode;
1098
- className?: string;
1334
+ type SelectItemProps = {
1335
+ value?: string;
1336
+ disabled?: boolean;
1337
+ children: React__default.ReactNode;
1099
1338
  };
1100
- declare function Footer({ sections, copyright, social, className }: Readonly<FooterProps>): react_jsx_runtime.JSX.Element;
1101
- declare namespace Footer {
1339
+ declare function SelectItem({ value, disabled, children }: Readonly<SelectItemProps>): react_jsx_runtime.JSX.Element;
1340
+ declare namespace SelectItem {
1102
1341
  var displayName: string;
1103
1342
  }
1104
1343
 
1105
- type LeftNavLayoutProps = {
1106
- nav: ReactNode;
1107
- children: ReactNode;
1108
- collapsed?: boolean;
1109
- onCollapsedChange?: (collapsed: boolean) => void;
1110
- showToggle?: boolean;
1344
+ type SliderProps = {
1345
+ value?: number;
1346
+ onChange?: (value: number) => void;
1347
+ min?: number;
1348
+ max?: number;
1349
+ step?: number;
1350
+ disabled?: boolean;
1111
1351
  className?: string;
1112
- navClassName?: string;
1113
- contentClassName?: string;
1114
- navWidth?: string;
1115
- navWidthCollapsed?: string;
1116
- mobileCollapsible?: boolean;
1117
- mobileMenuOpen?: boolean;
1118
- onMobileMenuOpenChange?: (open: boolean) => void;
1119
- embedded?: boolean;
1120
- mainContentRef?: React.RefObject<HTMLDivElement>;
1352
+ ariaLabel?: string;
1353
+ id?: string;
1354
+ name?: string;
1121
1355
  };
1122
- declare function LeftNavLayout({ nav, children, collapsed: controlledCollapsed, onCollapsedChange, showToggle, className, navClassName, contentClassName, navWidth, navWidthCollapsed, mobileCollapsible, mobileMenuOpen: controlledMobileMenuOpen, embedded, mainContentRef }: Readonly<LeftNavLayoutProps>): react_jsx_runtime.JSX.Element;
1123
- declare namespace LeftNavLayout {
1356
+ declare function Slider({ value, onChange, min, max, step, disabled, className, ariaLabel, id, name }: Readonly<SliderProps>): react_jsx_runtime.JSX.Element;
1357
+ declare namespace Slider {
1124
1358
  var displayName: string;
1125
1359
  }
1126
1360
 
1127
- type LeftNavItemProps = {
1128
- icon?: ReactNode;
1129
- children: ReactNode;
1130
- active?: boolean;
1361
+ type SwitchProps = {
1362
+ checked?: boolean;
1363
+ onChange?: (checked: boolean) => void;
1364
+ disabled?: boolean;
1131
1365
  className?: string;
1132
- badge?: ReactNode;
1133
- href?: string;
1134
- title?: string;
1135
- preventNavigation?: boolean;
1366
+ ariaLabel?: string;
1367
+ id?: string;
1368
+ name?: string;
1369
+ size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1370
+ variant?: 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'info' | 'error' | 'neutral';
1136
1371
  };
1137
- declare function LeftNavItem({ icon, children, active, className, badge, href, title, preventNavigation }: Readonly<LeftNavItemProps>): react_jsx_runtime.JSX.Element;
1138
- declare namespace LeftNavItem {
1372
+ declare function Switch({ checked, onChange, disabled, className, ariaLabel, id, name, size, variant }: Readonly<SwitchProps>): react_jsx_runtime.JSX.Element;
1373
+ declare namespace Switch {
1139
1374
  var displayName: string;
1140
1375
  }
1141
1376
 
1142
- type LeftNavSectionProps = {
1143
- children: ReactNode;
1144
- label?: string;
1377
+ type ValidationState = 'default' | 'error' | 'success' | 'warning';
1378
+ type TextareaProps = {
1379
+ value?: string;
1380
+ onChange?: (e: React__default.ChangeEvent<HTMLTextAreaElement>) => void;
1381
+ placeholder?: string;
1382
+ disabled?: boolean;
1145
1383
  className?: string;
1384
+ ariaLabel?: string;
1385
+ id?: string;
1386
+ name?: string;
1387
+ rows?: number;
1388
+ required?: boolean;
1389
+ validationState?: ValidationState;
1146
1390
  };
1147
- declare function LeftNavSection({ children, label, className }: Readonly<LeftNavSectionProps>): react_jsx_runtime.JSX.Element;
1148
- declare namespace LeftNavSection {
1391
+ declare function Textarea({ value, onChange, placeholder, disabled, className, ariaLabel, id, name, rows, required, validationState }: Readonly<TextareaProps>): react_jsx_runtime.JSX.Element;
1392
+ declare namespace Textarea {
1149
1393
  var displayName: string;
1150
1394
  }
1151
1395
 
@@ -1162,6 +1406,21 @@ declare namespace Heading {
1162
1406
  var displayName: string;
1163
1407
  }
1164
1408
 
1409
+ type LinkProps = {
1410
+ children: ReactNode;
1411
+ href: string;
1412
+ external?: boolean;
1413
+ variant?: 'default' | 'muted' | 'secondary' | 'inherit';
1414
+ underline?: 'hover' | 'always' | 'none';
1415
+ size?: 'sm' | 'md' | 'lg';
1416
+ display?: 'inline' | 'block';
1417
+ className?: string;
1418
+ };
1419
+ declare function Link({ children, href, external, variant, underline, size, display, className }: Readonly<LinkProps>): react_jsx_runtime.JSX.Element;
1420
+ declare namespace Link {
1421
+ var displayName: string;
1422
+ }
1423
+
1165
1424
  type TextProps = {
1166
1425
  children: ReactNode;
1167
1426
  as?: 'p' | 'span' | 'label' | 'strong' | 'em' | 'small' | 'mark' | 'del' | 'ins' | 'sub' | 'sup' | 'abbr' | 'cite' | 'q';
@@ -1201,91 +1460,6 @@ declare namespace Code {
1201
1460
  var displayName: string;
1202
1461
  }
1203
1462
 
1204
- type LinkProps = {
1205
- children: ReactNode;
1206
- href: string;
1207
- external?: boolean;
1208
- variant?: 'default' | 'muted' | 'secondary' | 'inherit';
1209
- underline?: 'hover' | 'always' | 'none';
1210
- size?: 'sm' | 'md' | 'lg';
1211
- display?: 'inline' | 'block';
1212
- className?: string;
1213
- };
1214
- declare function Link({ children, href, external, variant, underline, size, display, className }: Readonly<LinkProps>): react_jsx_runtime.JSX.Element;
1215
- declare namespace Link {
1216
- var displayName: string;
1217
- }
1218
-
1219
- type LogoProps = {
1220
- size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
1221
- className?: string;
1222
- };
1223
- declare function Logo({ size, className }: Readonly<LogoProps>): react_jsx_runtime.JSX.Element;
1224
-
1225
- type Theme = 'light' | 'dark';
1226
- type ThemeContextType = {
1227
- theme: Theme;
1228
- setTheme: (theme: Theme) => void;
1229
- availableThemes: Theme[];
1230
- };
1231
- type ThemeProviderProps = {
1232
- children: ReactNode;
1233
- defaultTheme?: Theme;
1234
- storageKey?: string;
1235
- themes?: Theme[];
1236
- };
1237
- declare function ThemeProvider({ children, defaultTheme, storageKey, themes }: Readonly<ThemeProviderProps>): react_jsx_runtime.JSX.Element;
1238
- declare function useTheme(): ThemeContextType;
1239
-
1240
- type ColorModeToggleProps = {
1241
- className?: string;
1242
- };
1243
- declare function ColorModeToggle({ className }: Readonly<ColorModeToggleProps>): react_jsx_runtime.JSX.Element;
1244
- declare namespace ColorModeToggle {
1245
- var displayName: string;
1246
- }
1247
-
1248
- interface AuthUser {
1249
- id: string;
1250
- [key: string]: unknown;
1251
- }
1252
- interface AuthState {
1253
- user: AuthUser | null;
1254
- isLoading: boolean;
1255
- isAuthenticated: boolean;
1256
- error: Error | null;
1257
- }
1258
- interface AuthActions {
1259
- login: (credentials: unknown) => Promise<void>;
1260
- logout: () => Promise<void>;
1261
- refresh: () => Promise<void>;
1262
- clearError: () => void;
1263
- updateUser: (updates: Partial<AuthUser>) => void;
1264
- }
1265
- type AuthContextType = AuthState & AuthActions;
1266
- interface AuthProviderConfig {
1267
- onLogin: (credentials: unknown) => Promise<AuthUser>;
1268
- onLogout?: () => Promise<void>;
1269
- onRefresh?: () => Promise<AuthUser | null>;
1270
- storageKey?: string;
1271
- useSessionStorage?: boolean;
1272
- autoRefresh?: boolean;
1273
- authUrl?: string;
1274
- withCredentials?: boolean;
1275
- }
1276
- interface AuthProviderProps {
1277
- config: AuthProviderConfig;
1278
- children: ReactNode;
1279
- }
1280
- declare function AuthProvider({ config, children }: Readonly<AuthProviderProps>): react_jsx_runtime.JSX.Element;
1281
- declare function useAuth(): AuthContextType;
1282
-
1283
- declare function authFetch(url: string, options?: RequestInit, withCredentials?: boolean): Promise<Response>;
1284
- declare function checkAuthStatus(authUrl: string): Promise<boolean>;
1285
- declare function getCurrentUser(authUrl: string): Promise<any | null>;
1286
- declare function loginExternal(authUrl: string, credentials: unknown): Promise<any>;
1287
- declare function logoutExternal(authUrl: string): Promise<void>;
1288
- declare function redirectToLogin(authUrl: string, returnUrl?: string): void;
1289
- declare function openLoginPopup(authUrl: string, onSuccess?: () => void): Window | null;
1463
+ declare function useScrollReset(deps: unknown[], container?: HTMLElement | null | RefObject<HTMLElement | null>): void;
1290
1464
 
1291
- export { Accordion, AccordionItem, type AccordionItemProps, type AccordionProps, Alert, type AlertProps, type AuthActions, type AuthContextType, AuthProvider, type AuthProviderConfig, type AuthProviderProps, type AuthState, type AuthUser, Avatar, type AvatarProps, Badge, type BadgeProps, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, Calendar, type CalendarProps, Card, CardActions, type CardActionsProps, CardBody, type CardBodyProps, CardFigure, type CardFigureProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Checkbox, type CheckboxProps, Chip, type ChipProps, Code, CodeBlock, type CodeBlockProps, type CodeProps, ColorModeToggle, type ColorModeToggleProps, type ColumnDef, Container, type ContainerProps, DataTable, type DataTableProps, DatePicker, type DatePickerProps, DeleteDialog, Dialog, type DialogProps, Divider, type DividerProps, Drawer, type DrawerProps, Dropdown, DropdownItem, type DropdownItemProps, type DropdownProps, EmptyState, type EmptyStateProps, type Feature, FeatureSection, type FeatureSectionProps, Footer, type FooterProps, type FooterSection, FormField, type FormFieldProps, Grid, type GridProps, Heading, type HeadingProps, Hero, type HeroAction, type HeroProps, Input, InputGroup, type InputGroupProps, type InputProps, LeftNavItem, type LeftNavItemProps, LeftNavLayout, type LeftNavLayoutProps, LeftNavSection, type LeftNavSectionProps, Link, type LinkProps, List, ListItem, type ListItemProps, type ListProps, Logo, type LogoProps, Modal, type ModalProps, MultiSelect, type MultiSelectOption, type MultiSelectProps, Nav, type NavProps, Navbar, NavbarBrand, type NavbarBrandProps, NavbarLink, type NavbarLinkProps, type NavbarProps, NavbarToggle, type NavbarToggleProps, Page, type PageProps, Pagination, type PaginationProps, Popover, type PopoverProps, type PricingFeature, PricingTable, type PricingTableProps, PricingTier, type PricingTierProps, ProgressBar, type ProgressBarProps, Radio, RadioGroup, type RadioGroupProps, type RadioProps, Select, SelectItem, type SelectItemProps, type SelectProps, Sidebar, type SidebarProps, Skeleton, type SkeletonProps, Slider, type SliderProps, SmoothTransition, type SmoothTransitionProps, type SortConfig, type SortDirection, Spinner, type SpinnerProps, Stack, type StackProps, StatusLabel, type StepProps, Stepper, type StepperProps, Switch, type SwitchProps, type Tab, Table, TableBody, type TableBodyProps, TableCell, type TableCellProps, TableFooter, type TableFooterProps, TableHeadCell, type TableHeadCellProps, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, type TabsProps, Text, type TextProps, Textarea, type TextareaProps, type Theme, type ThemeContextType, ThemeProvider, type ThemeProviderProps, Timeline, TimelineItem, type TimelineItemProps, type TimelineProps, Toast, type ToastProps, Tooltip, type TooltipProps, type TransitionDuration, type TransitionType, type UseTableOptions, type UseTableReturn, authFetch, checkAuthStatus, getCurrentUser, loginExternal, logoutExternal, openLoginPopup, redirectToLogin, useAuth, useStaggeredTransition, useTable, useTheme };
1465
+ export { Accordion, AccordionItem, type AccordionItemProps, type AccordionProps, Alert, type AlertProps, type AuthActions, type AuthContextType, AuthProvider, type AuthProviderConfig, type AuthProviderProps, type AuthState, type AuthUser, Avatar, type AvatarProps, Badge, type BadgeProps, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, ButtonWithIcon, Calendar, type CalendarProps, Card, CardActions, type CardActionsProps, CardBody, type CardBodyProps, CardFigure, type CardFigureProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Checkbox, type CheckboxProps, Chip, type ChipProps, Code, CodeBlock, type CodeBlockProps, Code$1 as CodeInput, type CodeProps, ColorModeToggle, type ColorModeToggleProps, type ColumnDef, Container, type ContainerProps, DataTable, type DataTableAction, type DataTableActionItem, type DataTableProps, DatePicker, type DatePickerProps, DeleteDialog, Dialog, type DialogProps, Divider, type DividerProps, Drawer, type DrawerProps, Dropdown, DropdownItem, type DropdownItemProps, type DropdownProps, EmptyState, type EmptyStateProps, type Feature, FeatureSection, type FeatureSectionProps, Fieldset, Footer, type FooterProps, type FooterSection, Form, FormField, type FormFieldProps, Grid, type GridProps, Heading, type HeadingProps, Hero, type HeroAction, type HeroProps, Icon, IconButton, Input, InputGroup, type InputGroupProps, type InputProps, LeftNavItem, type LeftNavItemProps, LeftNavLayout, type LeftNavLayoutProps, LeftNavSection, type LeftNavSectionProps, Link, type LinkProps, List, ListItem, type ListItemProps, type ListProps, Logo, type LogoProps, Modal, type ModalProps, MultiSelect, type MultiSelectOption, type MultiSelectProps, Nav, NavDropdown, NavDropdownItem, type NavProps, Navbar, NavbarBrand, type NavbarBrandProps, NavbarLink, type NavbarLinkProps, type NavbarProps, NavbarToggle, type NavbarToggleProps, useOverlay as OverlayProvider, Page, PageHeader, type PageProps, PageTransition, Pagination, type PaginationProps, Popover, type PopoverProps, PriceDisplay, type PricingFeature, PricingTable, type PricingTableProps, PricingTier, type PricingTierProps, ProgressBar, type ProgressBarProps, Radio, RadioGroup, type RadioGroupProps, type RadioProps, Section, SectionHeader, Select, SelectItem, type SelectProps, Sidebar, type SidebarProps, Skeleton, type SkeletonProps, Slider, type SliderProps, SmoothTransition, type SmoothTransitionProps, type SortConfig, type SortDirection, Spinner, type SpinnerProps, Stack, type StackProps, StatusLabel, type StepProps, Stepper, type StepperProps, Switch, type SwitchProps, type Tab, Table, TableBody, type TableBodyProps, TableCell, type TableCellProps, TableFooter, type TableFooterProps, TableHeadCell, type TableHeadCellProps, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, type TabsProps, Text, type TextProps, Textarea, type TextareaProps, type Theme, type ThemeContextType, ThemeProvider, type ThemeProviderProps, Timeline, TimelineItem, type TimelineItemProps, type TimelineProps, Toast, type ToastProps, Tooltip, type TooltipProps, type TransitionDuration, type TransitionType, type UseTableOptions, type UseTableReturn, authFetch, checkAuthStatus, getCurrentUser, loginExternal, logoutExternal, openLoginPopup, redirectToLogin, useAuth, useScrollReset, useStaggeredTransition, useTable, useTheme };