@ballistix.digital/react-components 0.4.112 → 0.4.114

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.d.ts +907 -869
  2. package/dist/index.esm.js +2399 -11205
  3. package/dist/index.esm.js.map +1 -1
  4. package/dist/index.js +2397 -11212
  5. package/dist/index.js.map +1 -1
  6. package/dist/lib/tsconfig.tsbuildinfo +1 -0
  7. package/package.json +111 -110
package/dist/index.d.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  import React, { FC, ReactNode, RefObject, ReactElement, HTMLInputTypeAttribute, Dispatch, SetStateAction, ElementType, ChangeEvent } from 'react';
2
- import { DeepPartial as DeepPartial$1 } from 'types/DeepPartial';
2
+ import { DeepPartialType as DeepPartialType$1 } from 'types/DeepPartialType';
3
3
  import { Menu } from '@headlessui/react';
4
4
  import { IconName } from '@fortawesome/fontawesome-svg-core';
5
5
  import { ColumnDef, SortingState, ColumnOrderState, Table } from '@tanstack/react-table';
@@ -7,919 +7,957 @@ import { TButtonElementStyles as TButtonElementStyles$1 } from 'components/Eleme
7
7
  import { TDropdownElementStyles as TDropdownElementStyles$1 } from 'components/Element/Dropdown';
8
8
  import { TPagePaginationNavigationStyles as TPagePaginationNavigationStyles$1 } from 'components/Navigation/PagePagination';
9
9
  export { createColumnHelper } from 'helpers/table';
10
+ import * as react_jsx_runtime from 'react/jsx-runtime';
10
11
  import { Option, SelectValue } from 'react-tailwindcss-select/dist/components/type';
11
12
  export { fromSelectMenuOptionToStringValue } from 'helpers/format';
12
13
  import { FormikProps, FormikValues } from 'formik';
13
14
 
14
- declare const base$l: {
15
- loading: string;
16
- spinner: string;
17
- empty: string;
18
- placeholder: string;
19
- container: string;
20
- indicator: string;
21
- };
22
- type TAvatarElementStyles = DeepPartial$1<typeof base$l>;
23
-
24
- type TProps$f = {
25
- src?: string | undefined;
26
- placeholder?: string | undefined;
27
- children?: ReactNode | ReactNode[] | string;
28
- url?: string;
29
- size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
30
- figure?: 'block' | 'rounded';
31
- status?: 'offline' | 'online' | 'blocked';
32
- isDisabled?: boolean;
33
- isLoading?: boolean;
34
- styles?: TAvatarElementStyles;
35
- };
15
+ declare const base$m: {
16
+ loading: string;
17
+ spinner: string;
18
+ empty: string;
19
+ placeholder: string;
20
+ container: string;
21
+ indicator: string;
22
+ };
23
+ type TAvatarElementStyles = DeepPartialType$1<typeof base$m>;
24
+
25
+ type TProps$f = {
26
+ src?: string | undefined;
27
+ placeholder?: string | undefined;
28
+ children?: ReactNode | ReactNode[] | string;
29
+ url?: string;
30
+ size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
31
+ figure?: 'block' | 'rounded';
32
+ status?: 'offline' | 'online' | 'blocked';
33
+ isDisabled?: boolean;
34
+ isLoading?: boolean;
35
+ styles?: TAvatarElementStyles;
36
+ };
36
37
  declare const AvatarElement: FC<TProps$f>;
37
38
 
38
- declare const base$k: {
39
- container: string;
40
- indicator: string;
41
- button: string;
42
- };
43
- type TBadgeElementStyles = DeepPartial$1<typeof base$k>;
44
-
45
- type TProps$e = {
46
- children: string | ReactNode;
47
- color?: 'gray' | 'red' | 'yellow' | 'green' | 'blue' | 'indigo' | 'purple' | 'pink';
48
- type?: 'normal' | 'indicator' | 'close';
49
- size?: 'sm' | 'lg';
50
- figure?: 'block' | 'rounded';
51
- isDisabled?: boolean;
52
- isLoading?: boolean;
53
- onClose?: () => void;
54
- styles?: TBadgeElementStyles;
55
- };
39
+ declare const base$l: {
40
+ container: string;
41
+ indicator: string;
42
+ button: string;
43
+ };
44
+ type TBadgeElementStyles = DeepPartialType$1<typeof base$l>;
45
+
46
+ type TProps$e = {
47
+ children: string | ReactNode;
48
+ color?: 'gray' | 'red' | 'yellow' | 'green' | 'blue' | 'indigo' | 'purple' | 'pink';
49
+ type?: 'normal' | 'indicator' | 'close';
50
+ size?: 'sm' | 'lg';
51
+ figure?: 'block' | 'rounded';
52
+ isDisabled?: boolean;
53
+ isLoading?: boolean;
54
+ onClose?: () => void;
55
+ styles?: TBadgeElementStyles;
56
+ };
56
57
  declare const BadgeElement: FC<TProps$e>;
57
58
 
58
- type TButtonElementProps = {
59
- children: string | ReactNode;
60
- innerRef?: RefObject<HTMLButtonElement>;
61
- htmlType?: 'button' | 'submit';
62
- type?: 'primary' | 'secondary' | 'outline';
63
- size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
64
- figure?: 'block' | 'rounded';
65
- status?: 'idle' | 'loading' | 'success' | 'error';
66
- isDisabled?: boolean;
67
- styles?: TButtonElementStyles;
68
- onClick?: () => void;
69
- };
59
+ type TButtonElementProps = {
60
+ children: string | ReactNode;
61
+ innerRef?: RefObject<HTMLButtonElement>;
62
+ htmlType?: 'button' | 'submit';
63
+ type?: 'primary' | 'secondary' | 'outline';
64
+ size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
65
+ figure?: 'block' | 'rounded';
66
+ status?: 'idle' | 'loading' | 'success' | 'error';
67
+ isDisabled?: boolean;
68
+ styles?: TButtonElementStyles;
69
+ onClick?: () => void;
70
+ };
70
71
  declare const ButtonElement: FC<TButtonElementProps>;
71
72
 
72
- declare const base$j: {
73
- container: string;
74
- content: string;
75
- icon: string;
76
- spinner: string;
77
- };
78
- type TButtonElementStyles = DeepPartial$1<typeof base$j>;
79
-
80
- declare const base$i: {
81
- container: string;
82
- firstButton: string;
83
- button: string;
84
- lastButton: string;
85
- };
86
- type TButtonGroupElementStyles = DeepPartial$1<typeof base$i>;
87
-
88
- type TProps$d = {
89
- children: ReactElement[];
90
- styles?: TButtonGroupElementStyles;
91
- };
73
+ declare const base$k: {
74
+ container: string;
75
+ content: string;
76
+ icon: string;
77
+ spinner: string;
78
+ };
79
+ type TButtonElementStyles = DeepPartialType$1<typeof base$k>;
80
+
81
+ declare const base$j: {
82
+ container: string;
83
+ firstButton: string;
84
+ button: string;
85
+ lastButton: string;
86
+ };
87
+ type TButtonGroupElementStyles = DeepPartialType$1<typeof base$j>;
88
+
89
+ type TProps$d = {
90
+ children: ReactElement[];
91
+ styles?: TButtonGroupElementStyles;
92
+ };
92
93
  declare const ButtonGroupElement: FC<TProps$d>;
93
94
 
94
- declare const base$h: {
95
- container: string;
96
- button: string;
97
- compact: string;
98
- dots: string;
99
- items: string;
100
- };
101
- type TDropdownElementStyles = DeepPartial$1<typeof base$h>;
102
-
103
- type TProps$c = {
104
- children: ReactElement | ReactElement[];
105
- label?: string | ReactElement;
106
- trigger?: ReactNode;
107
- type?: 'button' | 'compact';
108
- direction?: 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
109
- isEscapingOverflow?: boolean;
110
- styles?: TDropdownElementStyles;
111
- };
112
- declare const DropdownElement: {
113
- Container: FC<TProps$c>;
114
- Item: typeof Menu.Item;
115
- };
116
-
117
- type TProps$b = {
118
- accessor: IconName;
119
- type?: 'brands' | 'light' | 'regular' | 'solid';
120
- className?: string;
121
- };
95
+ declare const base$i: {
96
+ container: string;
97
+ button: string;
98
+ compact: string;
99
+ dots: string;
100
+ items: string;
101
+ };
102
+ type TDropdownElementStyles = DeepPartialType$1<typeof base$i>;
103
+
104
+ type TProps$c = {
105
+ children: ReactElement | ReactElement[];
106
+ label?: string | ReactElement;
107
+ trigger?: ReactNode;
108
+ type?: 'button' | 'compact';
109
+ direction?: 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
110
+ isEscapingOverflow?: boolean;
111
+ styles?: TDropdownElementStyles;
112
+ };
113
+ declare const DropdownElement: {
114
+ Container: FC<TProps$c>;
115
+ Item: typeof Menu.Item;
116
+ };
117
+
118
+ type TProps$b = {
119
+ accessor: IconName;
120
+ type?: 'brands' | 'light' | 'regular' | 'solid';
121
+ className?: string;
122
+ };
122
123
  declare const IconElement: FC<TProps$b>;
123
124
 
124
- type TInputGroupFormProps = {
125
- name: string;
126
- htmlType: HTMLInputTypeAttribute | 'area';
127
- label?: string | ReactNode;
128
- description?: string;
129
- placeholder?: string;
130
- leading?: string | ReactNode;
131
- trailing?: string | ReactNode;
132
- required?: ({ isRequired }: {
133
- isRequired: boolean;
134
- }) => string | ReactNode;
135
- value: string;
136
- error?: string;
137
- mask?: {
138
- mask: string;
139
- replacementCharacter?: string;
140
- };
141
- min?: number;
142
- max?: number;
143
- maxLength?: number;
144
- rows?: number;
145
- type: 'normal' | 'inset' | 'overlapping' | 'pill' | 'floored';
146
- isValid?: boolean;
147
- isDisabled?: boolean;
148
- isRequired?: boolean;
149
- isTouched?: boolean;
150
- isSolo?: boolean;
151
- onChange: any;
152
- onBlur: any;
153
- styles?: TInputGroupStyles;
154
- };
125
+ type TInputGroupFormProps = {
126
+ name: string;
127
+ htmlType: HTMLInputTypeAttribute | 'area';
128
+ label?: string | ReactNode;
129
+ description?: string;
130
+ placeholder?: string;
131
+ leading?: string | ReactNode;
132
+ trailing?: string | ReactNode;
133
+ required?: ({ isRequired }: {
134
+ isRequired: boolean;
135
+ }) => string | ReactNode;
136
+ value: string;
137
+ error?: string;
138
+ mask?: {
139
+ mask: string;
140
+ replacementCharacter?: string;
141
+ };
142
+ min?: number;
143
+ max?: number;
144
+ maxLength?: number;
145
+ rows?: number;
146
+ type: 'normal' | 'inset' | 'overlapping' | 'pill' | 'floored';
147
+ isValid?: boolean;
148
+ isDisabled?: boolean;
149
+ isRequired?: boolean;
150
+ isTouched?: boolean;
151
+ isSolo?: boolean;
152
+ onChange: any;
153
+ onBlur: any;
154
+ styles?: TInputGroupStyles;
155
+ };
155
156
  declare const InputGroupForm: FC<TInputGroupFormProps>;
156
157
 
157
- declare const base$g: {
158
- container: string;
159
- head: string;
160
- body: string;
161
- foot: string;
162
- label: string;
163
- hint: string;
164
- leading: string;
165
- input: string;
166
- trailing: string;
167
- description: string;
168
- error: string;
169
- };
170
- type TInputGroupStyles = DeepPartial$1<typeof base$g>;
171
-
172
- declare const base$f: {
173
- container: string;
174
- content: string;
175
- };
176
- type TContainerLayoutStyles = DeepPartial$1<typeof base$f>;
177
-
178
- type TProps$a = {
179
- children: ReactNode;
180
- type?: 'break' | 'center' | 'fill';
181
- styles?: TContainerLayoutStyles;
182
- };
158
+ declare const base$h: {
159
+ container: string;
160
+ head: string;
161
+ body: string;
162
+ foot: string;
163
+ label: string;
164
+ hint: string;
165
+ leading: string;
166
+ input: string;
167
+ trailing: string;
168
+ description: string;
169
+ error: string;
170
+ };
171
+ type TInputGroupStyles = DeepPartialType$1<typeof base$h>;
172
+
173
+ declare const base$g: {
174
+ container: string;
175
+ content: string;
176
+ };
177
+ type TContainerLayoutStyles = DeepPartialType$1<typeof base$g>;
178
+
179
+ type TProps$a = {
180
+ children: ReactNode;
181
+ type?: 'break' | 'center' | 'fill';
182
+ styles?: TContainerLayoutStyles;
183
+ };
183
184
  declare const ContainerLayout: FC<TProps$a>;
184
185
 
185
- declare const base$e: {
186
- container: string;
187
- head: string;
188
- line: string;
189
- body: string;
190
- content: string;
191
- };
192
- type TDividerLayoutStyles = DeepPartial$1<typeof base$e>;
193
-
194
- type TProps$9 = {
195
- children?: ReactNode;
196
- type?: 'left' | 'center' | 'right';
197
- styles?: TDividerLayoutStyles;
198
- };
186
+ declare const base$f: {
187
+ container: string;
188
+ head: string;
189
+ line: string;
190
+ body: string;
191
+ content: string;
192
+ };
193
+ type TDividerLayoutStyles = DeepPartialType$1<typeof base$f>;
194
+
195
+ type TProps$9 = {
196
+ children?: ReactNode;
197
+ type?: 'left' | 'center' | 'right';
198
+ styles?: TDividerLayoutStyles;
199
+ };
199
200
  declare const DividerLayout: FC<TProps$9>;
200
201
 
201
- declare const base$d: {
202
- container: string;
203
- list: string;
204
- item: string;
205
- };
206
- type TListContainerLayoutStyles = DeepPartial$1<typeof base$d>;
207
-
208
- type TProps$8 = {
209
- children: ReactElement | ReactElement[];
210
- type?: 'fill' | 'fill-sticky' | 'center' | 'center-sticky' | 'card' | 'card-sticky';
211
- styles?: TListContainerLayoutStyles;
212
- };
202
+ declare const base$e: {
203
+ container: string;
204
+ list: string;
205
+ item: string;
206
+ };
207
+ type TListContainerLayoutStyles = DeepPartialType$1<typeof base$e>;
208
+
209
+ type TProps$8 = {
210
+ children: ReactElement | ReactElement[];
211
+ type?: 'fill' | 'fill-sticky' | 'center' | 'center-sticky' | 'card' | 'card-sticky';
212
+ styles?: TListContainerLayoutStyles;
213
+ };
213
214
  declare const ListContainerLayout: FC<TProps$8>;
214
215
 
215
- declare const base$c: {
216
- container: string;
217
- figure: string;
218
- svg: string;
219
- title: string;
220
- paragraph: string;
221
- };
222
- type TMediaObjectLayoutStyles = DeepPartial$1<typeof base$c>;
223
-
224
- type TProps$7 = {
225
- title: string;
226
- paragraph: string;
227
- figure?: ReactNode;
228
- type?: 'top' | 'top-reversed' | 'center' | 'center-reversed' | 'bottom' | 'bottom-reversed' | 'stretch' | 'stretch-reversed' | 'responsive' | 'responsive-reversed' | 'wide' | 'wide-reversed';
229
- styles?: TMediaObjectLayoutStyles;
230
- };
216
+ declare const base$d: {
217
+ container: string;
218
+ figure: string;
219
+ svg: string;
220
+ title: string;
221
+ paragraph: string;
222
+ };
223
+ type TMediaObjectLayoutStyles = DeepPartialType$1<typeof base$d>;
224
+
225
+ type TProps$7 = {
226
+ title: string;
227
+ paragraph: string;
228
+ figure?: ReactNode;
229
+ type?: 'top' | 'top-reversed' | 'center' | 'center-reversed' | 'bottom' | 'bottom-reversed' | 'stretch' | 'stretch-reversed' | 'responsive' | 'responsive-reversed' | 'wide' | 'wide-reversed';
230
+ styles?: TMediaObjectLayoutStyles;
231
+ };
231
232
  declare const MediaObjectLayout: FC<TProps$7>;
232
233
 
233
- declare const base$b: {
234
- container: string;
235
- section: string;
236
- };
237
- type TPanelLayoutStyles = DeepPartial$1<typeof base$b>;
238
-
239
- type TContainerProps$2 = {
240
- children: ReactNode;
241
- type?: 'normal' | 'sticky';
242
- styles?: TPanelLayoutStyles;
243
- };
244
- type TSectionProps = {
245
- children: ReactNode;
246
- styles?: {
247
- section: string;
248
- };
249
- };
250
- declare const LayoutPanel: {
251
- Container: React.FC<TContainerProps$2>;
252
- Section: React.FC<TSectionProps>;
253
- };
254
-
255
- type TData$1 = any;
256
- type VisibilityState$1 = {
257
- [key: string]: boolean;
258
- };
259
- type TTableListProps$1<TData> = {
260
- id: string;
261
- columns: ColumnDef<TData>[];
262
- data: TData[];
263
- page: {
264
- current?: number;
265
- total: number;
266
- };
267
- defaultOrder?: string[];
268
- defaultVisibility?: string[];
269
- customControls?: ReactNode | ReactNode[];
270
- children: ({ min, max, current, }: {
271
- min: number;
272
- max: number;
273
- current: number;
274
- }) => ReactNode;
275
- type?: 'normal' | 'panel' | 'full';
276
- exportFileName?: string;
277
- isLoading?: boolean;
278
- isStriped?: boolean;
279
- hasStickyHeader?: boolean;
280
- hasVerticalSeparators?: boolean;
281
- areControlsVisible?: boolean;
282
- styles?: TTableListStyles & {
283
- components: {
284
- buttonElement: TButtonElementStyles$1;
285
- dropdownElement: TDropdownElementStyles$1;
286
- panelPaginationNavigation: TPagePaginationNavigationStyles$1;
287
- };
288
- };
289
- onChange?: ({ sorting, visibility, order, }: {
290
- sorting: SortingState;
291
- visibility: VisibilityState$1;
292
- order: ColumnOrderState;
293
- }) => void;
294
- onPaginate?: (current: number) => void;
295
- };
234
+ declare const base$c: {
235
+ container: string;
236
+ section: string;
237
+ };
238
+ type TPanelLayoutStyles = DeepPartialType$1<typeof base$c>;
239
+
240
+ type TContainerProps$2 = {
241
+ children: ReactNode;
242
+ type?: 'normal' | 'sticky';
243
+ styles?: TPanelLayoutStyles;
244
+ };
245
+ type TSectionProps = {
246
+ children: ReactNode;
247
+ styles?: {
248
+ section: string;
249
+ };
250
+ };
251
+ declare const LayoutPanel: {
252
+ Container: React.FC<TContainerProps$2>;
253
+ Section: React.FC<TSectionProps>;
254
+ };
255
+
256
+ type TData$1 = any;
257
+ type VisibilityState$1 = {
258
+ [key: string]: boolean;
259
+ };
260
+ type TTableListProps$1<TData> = {
261
+ id: string;
262
+ columns: ColumnDef<TData>[];
263
+ data: TData[];
264
+ page: {
265
+ current?: number;
266
+ total: number;
267
+ };
268
+ defaultOrder?: string[];
269
+ defaultVisibility?: string[];
270
+ customControls?: ReactNode | ReactNode[];
271
+ children: ({ min, max, current, }: {
272
+ min: number;
273
+ max: number;
274
+ current: number;
275
+ }) => ReactNode;
276
+ type?: 'normal' | 'panel' | 'full';
277
+ exportFileName?: string;
278
+ isLoading?: boolean;
279
+ isStriped?: boolean;
280
+ hasStickyHeader?: boolean;
281
+ hasVerticalSeparators?: boolean;
282
+ areControlsVisible?: boolean;
283
+ styles?: TTableListStyles$1 & {
284
+ components: {
285
+ buttonElement: TButtonElementStyles$1;
286
+ dropdownElement: TDropdownElementStyles$1;
287
+ panelPaginationNavigation: TPagePaginationNavigationStyles$1;
288
+ };
289
+ };
290
+ onChange?: ({ sorting, visibility, order, }: {
291
+ sorting: SortingState;
292
+ visibility: VisibilityState$1;
293
+ order: ColumnOrderState;
294
+ }) => void;
295
+ onPaginate?: (current: number) => void;
296
+ };
296
297
  declare const TableList: FC<TTableListProps$1<TData$1>>;
297
298
 
298
- declare const base$a: {
299
- container: string;
300
- head: {
301
- container: string;
302
- head: string;
303
- body: string;
304
- heading: string;
305
- paragraph: string;
306
- };
307
- body: {
308
- container: string;
309
- wrapper: string;
310
- content: string;
311
- styleWrapper: string;
312
- table: {
313
- container: string;
314
- head: {
315
- container: string;
316
- row: string;
317
- cell: string;
318
- checkbox: string;
319
- };
320
- body: {
321
- container: string;
322
- row: string;
323
- cell: string;
324
- checkbox: string;
325
- indicator: string;
326
- };
327
- };
328
- };
329
- sortIndicator: {
330
- container: string;
331
- isSorted: string;
332
- isNotSorted: string;
333
- icon: {
334
- container: string;
335
- };
336
- };
337
- controls: {
338
- container: string;
339
- content: string;
340
- head: string;
341
- body: string;
342
- dropdown: {
343
- container: string;
344
- input: string;
345
- label: string;
346
- actions: string;
347
- upIcon: string;
348
- downIcon: string;
349
- };
350
- };
351
- };
352
- type TTableListStyles = DeepPartial$1<typeof base$a>;
353
-
354
- type TData = any;
355
- type VisibilityState = {
356
- [key: string]: boolean;
357
- };
358
- type Params = {
359
- table: Table<any>;
360
- sorting: SortingState;
361
- columnVisibility: VisibilityState;
362
- columnOrder: ColumnOrderState;
363
- setSorting: Dispatch<SetStateAction<SortingState>>;
364
- setColumnVisibility: Dispatch<SetStateAction<VisibilityState>>;
365
- setColumnOrder: Dispatch<SetStateAction<ColumnOrderState>>;
366
- };
367
- type TTableListProps<TData> = {
368
- id: string;
369
- table: {
370
- columns: ColumnDef<TData>[];
371
- data: TData[];
372
- pages: {
373
- current: number;
374
- total: number;
375
- };
376
- options?: {
377
- defaultOrder?: string[];
378
- defaultVisibility?: string[];
379
- isStriped?: boolean;
380
- hasStickyHeader?: boolean;
381
- hasVerticalSeparators?: boolean;
382
- };
383
- };
384
- isLoading?: boolean;
385
- head?: (params: Params) => ReactNode;
386
- foot?: (params: Params) => ReactNode;
387
- onChange?: (params: Params) => void;
388
- };
299
+ declare const base$b: {
300
+ container: string;
301
+ head: {
302
+ container: string;
303
+ head: string;
304
+ body: string;
305
+ heading: string;
306
+ paragraph: string;
307
+ };
308
+ body: {
309
+ container: string;
310
+ wrapper: string;
311
+ content: string;
312
+ styleWrapper: string;
313
+ table: {
314
+ container: string;
315
+ head: {
316
+ container: string;
317
+ row: string;
318
+ cell: string;
319
+ checkbox: string;
320
+ };
321
+ body: {
322
+ container: string;
323
+ row: string;
324
+ cell: string;
325
+ checkbox: string;
326
+ indicator: string;
327
+ };
328
+ };
329
+ };
330
+ sortIndicator: {
331
+ container: string;
332
+ isSorted: string;
333
+ isNotSorted: string;
334
+ icon: {
335
+ container: string;
336
+ };
337
+ };
338
+ controls: {
339
+ container: string;
340
+ content: string;
341
+ head: string;
342
+ body: string;
343
+ dropdown: {
344
+ container: string;
345
+ input: string;
346
+ label: string;
347
+ actions: string;
348
+ upIcon: string;
349
+ downIcon: string;
350
+ };
351
+ };
352
+ };
353
+ type TTableListStyles$1 = DeepPartialType$1<typeof base$b>;
354
+
355
+ type TData = any;
356
+ type VisibilityState = {
357
+ [key: string]: boolean;
358
+ };
359
+ type Params = {
360
+ table: Table<any>;
361
+ sorting: SortingState;
362
+ columnVisibility: VisibilityState;
363
+ columnOrder: ColumnOrderState;
364
+ setSorting: Dispatch<SetStateAction<SortingState>>;
365
+ setColumnVisibility: Dispatch<SetStateAction<VisibilityState>>;
366
+ setColumnOrder: Dispatch<SetStateAction<ColumnOrderState>>;
367
+ };
368
+ type TTableListProps<TData> = {
369
+ id: string;
370
+ table: {
371
+ columns: ColumnDef<TData>[];
372
+ data: TData[];
373
+ pages: {
374
+ current: number;
375
+ total: number;
376
+ };
377
+ options?: {
378
+ defaultOrder?: string[];
379
+ defaultVisibility?: string[];
380
+ isStriped?: boolean;
381
+ hasStickyHeader?: boolean;
382
+ hasVerticalSeparators?: boolean;
383
+ };
384
+ };
385
+ isLoading?: boolean;
386
+ head?: (params: Params) => ReactNode;
387
+ foot?: (params: Params) => ReactNode;
388
+ onChange?: (params: Params) => void;
389
+ styles?: TTableListStyles;
390
+ };
389
391
  declare const TableList2: FC<TTableListProps<TData>>;
390
392
 
391
- declare const base$9: {
392
- container: string;
393
- list: string;
394
- separator: string;
395
- home: {
396
- container: string;
397
- content: string;
398
- link: string;
399
- icon: string;
400
- span: string;
401
- };
402
- page: {
403
- container: string;
404
- content: string;
405
- link: string;
406
- };
407
- };
408
- type TBreadcrumbsNavigationStyles = DeepPartial$1<typeof base$9>;
409
-
410
- type TProps$6 = {
411
- href: string;
412
- pages: {
413
- name: string;
414
- href: string;
415
- isCurrent: boolean;
416
- }[];
417
- type?: 'slashes' | 'chevrons' | 'panel' | 'bar';
418
- separator?: ReactNode;
419
- styles?: TBreadcrumbsNavigationStyles;
420
- };
393
+ declare const base$a: {
394
+ container: string;
395
+ head: string;
396
+ body: {
397
+ container: string;
398
+ wrapper: string;
399
+ content: string;
400
+ styleWrapper: string;
401
+ table: {
402
+ container: string;
403
+ head: {
404
+ container: string;
405
+ row: string;
406
+ cell: string;
407
+ checkbox: string;
408
+ };
409
+ body: {
410
+ container: string;
411
+ row: string;
412
+ cell: string;
413
+ checkbox: string;
414
+ indicator: string;
415
+ };
416
+ };
417
+ };
418
+ foot: string;
419
+ sortIndicator: {
420
+ container: string;
421
+ isSorted: string;
422
+ isNotSorted: string;
423
+ icon: {
424
+ container: string;
425
+ };
426
+ };
427
+ };
428
+ type TTableListStyles = DeepPartialType$1<typeof base$a>;
429
+
430
+ declare const base$9: {
431
+ container: string;
432
+ list: string;
433
+ separator: string;
434
+ home: {
435
+ container: string;
436
+ content: string;
437
+ link: string;
438
+ icon: string;
439
+ span: string;
440
+ };
441
+ page: {
442
+ container: string;
443
+ content: string;
444
+ link: string;
445
+ };
446
+ };
447
+ type TBreadcrumbsNavigationStyles = DeepPartialType$1<typeof base$9>;
448
+
449
+ type TProps$6 = {
450
+ href: string;
451
+ pages: {
452
+ name: string;
453
+ href: string;
454
+ isCurrent: boolean;
455
+ }[];
456
+ type?: 'slashes' | 'chevrons' | 'panel' | 'bar';
457
+ separator?: ReactNode;
458
+ styles?: TBreadcrumbsNavigationStyles;
459
+ };
421
460
  declare const BreadcrumbsNavigation: FC<TProps$6>;
422
461
 
423
- declare const base$8: {
424
- container: string;
425
- mobile: {
426
- container: string;
427
- button: string;
428
- };
429
- desktop: {
430
- container: string;
431
- leftButton: string;
432
- rightButton: string;
433
- navigation: string;
434
- };
435
- button: {
436
- default: string;
437
- active: string;
438
- disabled: string;
439
- };
440
- divider: string;
441
- label: string;
442
- icon: string;
443
- };
444
- type TPanelPaginationNavigationStyles = DeepPartial$1<typeof base$8>;
445
-
446
- type TProps$5 = {
447
- current?: number;
448
- min?: number;
449
- max: number;
450
- children: ({ min, max, current, }: {
451
- min: number;
452
- max: number;
453
- current: number;
454
- }) => ReactNode;
455
- styles?: TPanelPaginationNavigationStyles;
456
- onChange?: (current: number) => void;
457
- };
462
+ declare const base$8: {
463
+ container: string;
464
+ mobile: {
465
+ container: string;
466
+ button: string;
467
+ };
468
+ desktop: {
469
+ container: string;
470
+ leftButton: string;
471
+ rightButton: string;
472
+ navigation: string;
473
+ };
474
+ button: {
475
+ default: string;
476
+ active: string;
477
+ disabled: string;
478
+ };
479
+ divider: string;
480
+ label: string;
481
+ icon: string;
482
+ };
483
+ type TPanelPaginationNavigationStyles = DeepPartialType$1<typeof base$8>;
484
+
485
+ type TProps$5 = {
486
+ current?: number;
487
+ min?: number;
488
+ max: number;
489
+ children: ({ min, max, current, }: {
490
+ min: number;
491
+ max: number;
492
+ current: number;
493
+ }) => ReactNode;
494
+ styles?: TPanelPaginationNavigationStyles;
495
+ onChange?: (current: number) => void;
496
+ };
458
497
  declare const PanelPaginationNavigation: React.FC<TProps$5>;
459
498
 
460
- declare const base$7: {
461
- container: string;
462
- left: {
463
- container: string;
464
- button: string;
465
- icon: string;
466
- };
467
- center: {
468
- container: string;
469
- };
470
- right: {
471
- container: string;
472
- button: string;
473
- icon: string;
474
- };
475
- button: {
476
- default: string;
477
- active: string;
478
- disabled: string;
479
- };
480
- divider: string;
481
- };
482
- type TPagePaginationNavigationStyles = DeepPartial$1<typeof base$7>;
483
-
484
- type TProps$4 = {
485
- min?: number;
486
- max: number;
487
- styles?: TPagePaginationNavigationStyles;
488
- onChange?: (current: number) => void;
489
- };
499
+ declare const base$7: {
500
+ container: string;
501
+ left: {
502
+ container: string;
503
+ button: string;
504
+ icon: string;
505
+ };
506
+ center: {
507
+ container: string;
508
+ };
509
+ right: {
510
+ container: string;
511
+ button: string;
512
+ icon: string;
513
+ };
514
+ button: {
515
+ default: string;
516
+ active: string;
517
+ disabled: string;
518
+ };
519
+ divider: string;
520
+ };
521
+ type TPagePaginationNavigationStyles = DeepPartialType$1<typeof base$7>;
522
+
523
+ type TProps$4 = {
524
+ min?: number;
525
+ max: number;
526
+ styles?: TPagePaginationNavigationStyles;
527
+ onChange?: (current: number) => void;
528
+ };
490
529
  declare const PagePaginationNavigation: React.FC<TProps$4>;
491
530
 
492
- declare const base$6: {
493
- container: string;
494
- list: {
495
- container: string;
496
- head: string;
497
- body: string;
498
- label: string;
499
- select: string;
500
- navigation: string;
501
- };
502
- tab: {
503
- base: string;
504
- active: string;
505
- inactive: string;
506
- };
507
- };
508
- type TTabNavigationStyles = DeepPartial$1<typeof base$6>;
509
-
510
- type TContainerProps$1 = {
511
- children: ({ active, setActive, }: {
512
- active: string;
513
- setActive: any;
514
- }) => ReactNode | ReactNode[];
515
- styles?: Pick<TTabNavigationStyles, 'container'>;
516
- };
517
- type TListProps = {
518
- name: string;
519
- children: ReactNode | ReactNode[];
520
- active: string;
521
- setActive: any;
522
- styles?: Pick<TTabNavigationStyles, 'list'>;
523
- };
524
- type TNavigationItemProps$1 = {
525
- accessor: string;
526
- href?: string;
527
- type?: 'underline' | 'pills' | 'buttons';
528
- children: ReactNode;
529
- as?: ElementType;
530
- isCurrent?: boolean;
531
- isInitial?: boolean;
532
- onClick?: ((accessor: MouseEvent) => void) | any;
533
- styles?: Pick<TTabNavigationStyles, 'tab'>;
534
- isLoading?: boolean;
535
- };
536
- type TViewProps$1 = {
537
- children: ReactNode;
538
- };
539
- declare const TabNavigation: {
540
- Container: React.FC<TContainerProps$1>;
541
- List: React.FC<TListProps>;
542
- Item: React.FC<TNavigationItemProps$1>;
543
- View: React.FC<TViewProps$1>;
544
- };
545
-
546
- type ContainerStylesType = {
547
- container: string;
548
- };
549
- type NavigationStylesType = {
550
- list?: string;
551
- };
552
-
553
- type TContainerProps = {
554
- children: ({ active, setActive, }: {
555
- active: string;
556
- setActive: Dispatch<SetStateAction<string>>;
557
- }) => ReactNode | ReactNode[];
558
- styles?: ContainerStylesType;
559
- };
560
- type TNavigationProps = {
561
- children: ReactNode | ReactNode[];
562
- active: string;
563
- setActive: Dispatch<SetStateAction<string>>;
564
- styles?: NavigationStylesType;
565
- };
566
- type TNavigationItemProps = {
567
- accessor: string;
568
- href?: string;
569
- type?: string;
570
- children: ReactNode | ReactNode[];
571
- linkComponent?: ElementType;
572
- isCurrent?: boolean;
573
- isInitial?: boolean;
574
- onClick?: (accessor: MouseEvent) => void;
575
- };
576
- type TViewProps = {
577
- children: ReactNode;
578
- };
579
- declare const VerticalNavigation: {
580
- Container: React.FC<TContainerProps>;
581
- List: React.FC<TNavigationProps>;
582
- Item: React.FC<TNavigationItemProps>;
583
- View: React.FC<TViewProps>;
584
- };
585
-
586
- type TModalOverlayProps = {
587
- trigger?: ({ handleOpen, handleClose, }: {
588
- handleOpen: () => void;
589
- handleClose: () => void;
590
- }) => ReactNode;
591
- children: ({ handleOpen, handleClose, }: {
592
- handleOpen: () => void;
593
- handleClose: () => void;
594
- }) => ReactNode;
595
- size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
596
- styles?: TModalOverlayStyles;
597
- onOpen?: () => void;
598
- onClose?: () => void;
599
- };
531
+ declare const base$6: {
532
+ container: string;
533
+ list: {
534
+ container: string;
535
+ head: string;
536
+ body: string;
537
+ label: string;
538
+ select: string;
539
+ navigation: string;
540
+ };
541
+ tab: {
542
+ base: string;
543
+ active: string;
544
+ inactive: string;
545
+ };
546
+ };
547
+ type TTabNavigationStyles = DeepPartialType$1<typeof base$6>;
548
+
549
+ type TContainerProps$1 = {
550
+ children: ({ active, setActive, }: {
551
+ active: string;
552
+ setActive: any;
553
+ }) => ReactNode | ReactNode[];
554
+ styles?: Pick<TTabNavigationStyles, 'container'>;
555
+ };
556
+ type TListProps = {
557
+ name: string;
558
+ children: ReactNode | ReactNode[];
559
+ active: string;
560
+ setActive: any;
561
+ styles?: Pick<TTabNavigationStyles, 'list'>;
562
+ };
563
+ type TNavigationItemProps$1 = {
564
+ accessor: string;
565
+ href?: string;
566
+ type?: 'underline' | 'pills' | 'buttons';
567
+ children: ReactNode;
568
+ as?: ElementType;
569
+ isCurrent?: boolean;
570
+ isInitial?: boolean;
571
+ onClick?: ((accessor: MouseEvent) => void) | any;
572
+ styles?: Pick<TTabNavigationStyles, 'tab'>;
573
+ isLoading?: boolean;
574
+ };
575
+ type TViewProps$1 = {
576
+ children: ReactNode;
577
+ };
578
+ declare const TabNavigation: {
579
+ Container: React.FC<TContainerProps$1>;
580
+ List: React.FC<TListProps>;
581
+ Item: React.FC<TNavigationItemProps$1>;
582
+ View: React.FC<TViewProps$1>;
583
+ };
584
+
585
+ type ContainerStylesType = {
586
+ container: string;
587
+ };
588
+ type NavigationStylesType = {
589
+ list?: string;
590
+ };
591
+
592
+ type TContainerProps = {
593
+ children: ({ active, setActive, }: {
594
+ active: string;
595
+ setActive: Dispatch<SetStateAction<string>>;
596
+ }) => ReactNode | ReactNode[];
597
+ styles?: ContainerStylesType;
598
+ };
599
+ type TNavigationProps = {
600
+ children: ReactNode | ReactNode[];
601
+ active: string;
602
+ setActive: Dispatch<SetStateAction<string>>;
603
+ styles?: NavigationStylesType;
604
+ };
605
+ type TNavigationItemProps = {
606
+ accessor: string;
607
+ href?: string;
608
+ type?: string;
609
+ children: ReactNode | ReactNode[];
610
+ linkComponent?: ElementType;
611
+ isCurrent?: boolean;
612
+ isInitial?: boolean;
613
+ onClick?: (accessor: MouseEvent) => void;
614
+ };
615
+ type TViewProps = {
616
+ children: ReactNode;
617
+ };
618
+ declare const VerticalNavigation: {
619
+ Container: React.FC<TContainerProps>;
620
+ List: React.FC<TNavigationProps>;
621
+ Item: React.FC<TNavigationItemProps>;
622
+ View: React.FC<TViewProps>;
623
+ };
624
+
625
+ type TModalOverlayProps = {
626
+ trigger?: ({ handleOpen, handleClose, }: {
627
+ handleOpen: () => void;
628
+ handleClose: () => void;
629
+ }) => ReactNode;
630
+ children: ({ handleOpen, handleClose, }: {
631
+ handleOpen: () => void;
632
+ handleClose: () => void;
633
+ }) => ReactNode;
634
+ size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
635
+ styles?: TModalOverlayStyles;
636
+ onOpen?: () => void;
637
+ onClose?: () => void;
638
+ };
600
639
  declare const ModalOverlay: FC<TModalOverlayProps>;
601
640
 
602
- declare const base$5: {
603
- container: string;
604
- background: {
605
- container: string;
606
- transition: {
607
- enter: string;
608
- enterFrom: string;
609
- enterTo: string;
610
- leave: string;
611
- leaveFrom: string;
612
- leaveTo: string;
613
- };
614
- };
615
- layout: {
616
- container: string;
617
- content: string;
618
- };
619
- panel: {
620
- container: string;
621
- transition: {
622
- enter: string;
623
- enterFrom: string;
624
- enterTo: string;
625
- leave: string;
626
- leaveFrom: string;
627
- leaveTo: string;
628
- };
629
- };
630
- };
631
- type TModalOverlayStyles = DeepPartial$1<typeof base$5>;
632
-
633
- declare const base$4: {
634
- container: {
635
- outer: string;
636
- inner: string;
637
- };
638
- item: {
639
- container: string;
640
- layout: {
641
- container: string;
642
- content: string;
643
- inner: string;
644
- };
645
- panel: {
646
- container: string;
647
- transition: {
648
- enter: string;
649
- enterFrom: string;
650
- enterTo: string;
651
- leave: string;
652
- leaveFrom: string;
653
- leaveTo: string;
654
- };
655
- };
656
- };
657
- };
658
- type TNotificationOverlayStyles = DeepPartial$1<typeof base$4>;
659
-
660
- type DeepPartial<T> = {
661
- [P in keyof T]?: DeepPartial<T[P]>;
662
- };
663
-
664
- type TProps$3 = {
665
- trigger?: ({ onOpen, onClose, }: {
666
- onOpen: () => void;
667
- onClose: () => void;
668
- }) => ReactNode;
669
- children: ({ onOpen, onClose, }: {
670
- onOpen: () => void;
671
- onClose: () => void;
672
- }) => ReactNode;
673
- size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
674
- styles?: TNotificationOverlayStyles;
675
- };
676
- declare const NotificationOverlay: {
677
- Container: ({ children, styles: stylesOverrides, }: {
678
- children: ReactNode;
679
- styles?: DeepPartial<{
680
- container: {
681
- outer: string;
682
- inner: string;
683
- };
684
- item: {
685
- container: string;
686
- layout: {
687
- container: string;
688
- content: string;
689
- inner: string;
690
- };
691
- panel: {
692
- container: string;
693
- transition: {
694
- enter: string;
695
- enterFrom: string;
696
- enterTo: string;
697
- leave: string;
698
- leaveFrom: string;
699
- leaveTo: string;
700
- };
701
- };
702
- };
703
- }> | undefined;
704
- }) => JSX.Element;
705
- Item: React.FC<TProps$3>;
706
- };
707
-
708
- declare const base$3: {
709
- container: string;
710
- background: {
711
- container: string;
712
- transition: {
713
- enter: string;
714
- enterFrom: string;
715
- enterTo: string;
716
- leave: string;
717
- leaveFrom: string;
718
- leaveTo: string;
719
- };
720
- };
721
- layout: {
722
- container: string;
723
- content: string;
724
- inner: string;
725
- };
726
- panel: {
727
- container: string;
728
- transition: {
729
- enter: string;
730
- enterFrom: string;
731
- enterTo: string;
732
- leave: string;
733
- leaveFrom: string;
734
- leaveTo: string;
735
- };
736
- };
737
- };
738
- type TSlideOverOverlayStyles = DeepPartial$1<typeof base$3>;
739
-
740
- type TProps$2 = {
741
- trigger?: ({ onOpen, onClose, }: {
742
- onOpen: () => void;
743
- onClose: () => void;
744
- }) => ReactNode;
745
- children: ({ onOpen, onClose, }: {
746
- onOpen: () => void;
747
- onClose: () => void;
748
- }) => ReactNode;
749
- size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
750
- styles?: TSlideOverOverlayStyles;
751
- };
641
+ declare const base$5: {
642
+ container: string;
643
+ background: {
644
+ container: string;
645
+ transition: {
646
+ enter: string;
647
+ enterFrom: string;
648
+ enterTo: string;
649
+ leave: string;
650
+ leaveFrom: string;
651
+ leaveTo: string;
652
+ };
653
+ };
654
+ layout: {
655
+ container: string;
656
+ content: string;
657
+ };
658
+ panel: {
659
+ container: string;
660
+ transition: {
661
+ enter: string;
662
+ enterFrom: string;
663
+ enterTo: string;
664
+ leave: string;
665
+ leaveFrom: string;
666
+ leaveTo: string;
667
+ };
668
+ };
669
+ };
670
+ type TModalOverlayStyles = DeepPartialType$1<typeof base$5>;
671
+
672
+ declare const base$4: {
673
+ container: {
674
+ outer: string;
675
+ inner: string;
676
+ };
677
+ item: {
678
+ container: string;
679
+ layout: {
680
+ container: string;
681
+ content: string;
682
+ inner: string;
683
+ };
684
+ panel: {
685
+ container: string;
686
+ transition: {
687
+ enter: string;
688
+ enterFrom: string;
689
+ enterTo: string;
690
+ leave: string;
691
+ leaveFrom: string;
692
+ leaveTo: string;
693
+ };
694
+ };
695
+ };
696
+ };
697
+ type TNotificationOverlayStyles = DeepPartialType$1<typeof base$4>;
698
+
699
+ type DeepPartialType<T> = {
700
+ [P in keyof T]?: DeepPartialType<T[P]>;
701
+ };
702
+
703
+ type TProps$3 = {
704
+ trigger?: ({ onOpen, onClose, }: {
705
+ onOpen: () => void;
706
+ onClose: () => void;
707
+ }) => ReactNode;
708
+ children: ({ onOpen, onClose, }: {
709
+ onOpen: () => void;
710
+ onClose: () => void;
711
+ }) => ReactNode;
712
+ size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
713
+ styles?: TNotificationOverlayStyles;
714
+ };
715
+ declare const NotificationOverlay: {
716
+ Container: ({ children, styles: stylesOverrides, }: {
717
+ children: ReactNode;
718
+ styles?: DeepPartialType<{
719
+ container: {
720
+ outer: string;
721
+ inner: string;
722
+ };
723
+ item: {
724
+ container: string;
725
+ layout: {
726
+ container: string;
727
+ content: string;
728
+ inner: string;
729
+ };
730
+ panel: {
731
+ container: string;
732
+ transition: {
733
+ enter: string;
734
+ enterFrom: string;
735
+ enterTo: string;
736
+ leave: string;
737
+ leaveFrom: string;
738
+ leaveTo: string;
739
+ };
740
+ };
741
+ };
742
+ }> | undefined;
743
+ }) => react_jsx_runtime.JSX.Element;
744
+ Item: React.FC<TProps$3>;
745
+ };
746
+
747
+ declare const base$3: {
748
+ container: string;
749
+ background: {
750
+ container: string;
751
+ transition: {
752
+ enter: string;
753
+ enterFrom: string;
754
+ enterTo: string;
755
+ leave: string;
756
+ leaveFrom: string;
757
+ leaveTo: string;
758
+ };
759
+ };
760
+ layout: {
761
+ container: string;
762
+ content: string;
763
+ inner: string;
764
+ };
765
+ panel: {
766
+ container: string;
767
+ transition: {
768
+ enter: string;
769
+ enterFrom: string;
770
+ enterTo: string;
771
+ leave: string;
772
+ leaveFrom: string;
773
+ leaveTo: string;
774
+ };
775
+ };
776
+ };
777
+ type TSlideOverOverlayStyles = DeepPartialType$1<typeof base$3>;
778
+
779
+ type TProps$2 = {
780
+ trigger?: ({ handleOpen, handleClose, }: {
781
+ handleOpen: () => void;
782
+ handleClose: () => void;
783
+ }) => ReactNode;
784
+ children: ({ handleOpen, handleClose, }: {
785
+ handleOpen: () => void;
786
+ handleClose: () => void;
787
+ }) => ReactNode;
788
+ size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
789
+ styles?: TSlideOverOverlayStyles;
790
+ };
752
791
  declare const SlideOverOverlay: FC<TProps$2>;
753
792
 
754
- type TProps$1 = {
755
- table: Table<any>;
756
- setColumnOrder: Dispatch<SetStateAction<ColumnOrderState>>;
757
- trigger: ReactNode;
758
- };
793
+ type TProps$1 = {
794
+ table: Table<any>;
795
+ setColumnOrder: Dispatch<SetStateAction<ColumnOrderState>>;
796
+ trigger: ReactNode;
797
+ };
759
798
  declare const TableColumnOptionsCustom: FC<TProps$1>;
760
799
 
761
- type TProps = {
762
- table: Table<any>;
763
- fileName: string;
764
- children: ({ handleExport }: {
765
- handleExport: () => void;
766
- }) => ReactNode;
767
- };
800
+ type TProps = {
801
+ table: Table<any>;
802
+ fileName: string;
803
+ children: ({ handleExport }: {
804
+ handleExport: () => void;
805
+ }) => ReactNode;
806
+ };
768
807
  declare const TableExcelExportCustom: FC<TProps>;
769
808
 
770
- type TSelectMenuFormProps = {
771
- name: string;
772
- type?: 'normal' | 'inset' | 'overlapping' | 'pill' | 'floored';
773
- label?: string;
774
- description?: string;
775
- placeholder?: {
776
- select?: string;
777
- searchInput?: string;
778
- emptyState?: string;
779
- };
780
- options: {
781
- value: string;
782
- label: string;
783
- }[];
784
- required?: ({ isRequired }: {
785
- isRequired: boolean;
786
- }) => string | ReactNode;
787
- value: {
788
- label: string;
789
- value: string;
790
- disabled?: boolean;
791
- };
792
- error?: string | Option | Option[];
793
- isLoading?: boolean;
794
- isRequired?: boolean;
795
- isTouched?: boolean;
796
- isDisabled?: boolean;
797
- isClearable?: boolean;
798
- isSearchable?: boolean;
799
- isMultiple?: boolean;
800
- isDarkMode?: boolean;
801
- isSolo?: boolean;
802
- onChange?: (value: SelectValue) => void;
803
- onSearchInputChange?: ((e: ChangeEvent<HTMLInputElement>) => void) | undefined;
804
- onClear: (name: string) => void;
805
- onBlur?: any;
806
- styles?: TSelectMenuFormStyles;
807
- };
809
+ type TSelectMenuFormProps = {
810
+ name: string;
811
+ label?: string;
812
+ description?: string;
813
+ placeholder?: {
814
+ select?: string;
815
+ searchInput?: string;
816
+ emptyState?: string;
817
+ };
818
+ options: {
819
+ value: string;
820
+ label: string;
821
+ }[];
822
+ required?: ({ isRequired }: {
823
+ isRequired: boolean;
824
+ }) => string | ReactNode;
825
+ value: {
826
+ label: string;
827
+ value: string;
828
+ disabled?: boolean;
829
+ };
830
+ error?: string | Option | Option[];
831
+ isLoading?: boolean;
832
+ isRequired?: boolean;
833
+ isTouched?: boolean;
834
+ isDisabled?: boolean;
835
+ isClearable?: boolean;
836
+ isSearchable?: boolean;
837
+ isMultiple?: boolean;
838
+ isDarkMode?: boolean;
839
+ isSolo?: boolean;
840
+ onChange?: (value: SelectValue) => void;
841
+ onSearchInputChange?: ((e: ChangeEvent<HTMLInputElement>) => void) | undefined;
842
+ onClear: (name: string) => void;
843
+ onBlur?: any;
844
+ styles?: TSelectMenuFormStyles;
845
+ };
808
846
  declare const SelectMenuForm: FC<TSelectMenuFormProps>;
809
847
 
810
- declare const base$2: {
811
- container: string;
812
- head: string;
813
- body: string;
814
- foot: string;
815
- label: string;
816
- hint: string;
817
- leading: string;
818
- input: string;
819
- menuButton: string;
820
- menu: string;
821
- tagItem: string;
822
- tagItemText: string;
823
- tagItemIconContainer: string;
824
- tagItemIcon: string;
825
- list: string;
826
- listGroupLabel: string;
827
- listItem: string;
828
- listDisabledItem: string;
829
- searchContainer: string;
830
- searchBox: string;
831
- searchIcon: string;
832
- closeIcon: string;
833
- emptyState: string;
834
- trailing: string;
835
- description: string;
836
- error: string;
837
- };
838
- type TSelectMenuFormStyles = DeepPartial$1<typeof base$2>;
839
-
840
- type TDateMenuFormProps = {
841
- name: string;
842
- type?: 'normal' | 'inset' | 'overlapping' | 'pill' | 'floored';
843
- size?: 'compact' | 'expanded';
844
- label?: string;
845
- i18n?: string;
846
- description?: string;
847
- placeholder?: string;
848
- separator?: string;
849
- startFrom?: Date;
850
- displayFormat?: string;
851
- direction?: 'up' | 'down';
852
- minDate?: Date;
853
- maxDate?: Date;
854
- startWeekOn?: 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
855
- icon?: (isOpen: boolean) => ReactNode;
856
- required?: ({ isRequired }: {
857
- isRequired: boolean;
858
- }) => string | ReactNode;
859
- value: {
860
- label: string;
861
- value: string;
862
- disabled?: boolean;
863
- };
864
- error?: string;
865
- isRequired?: boolean;
866
- isTouched?: boolean;
867
- isDisabled?: boolean;
868
- isSolo?: boolean;
869
- isRanged?: boolean;
870
- onChange?: (value: {
871
- startDate: string;
872
- endDate: string;
873
- }) => void;
874
- onClear?: (name: string) => void;
875
- onBlur?: any;
876
- styles?: TDateMenuFormStyles;
877
- };
848
+ declare const base$2: {
849
+ container: string;
850
+ head: string;
851
+ body: string;
852
+ foot: string;
853
+ label: string;
854
+ hint: string;
855
+ leading: string;
856
+ input: string;
857
+ menuButton: string;
858
+ menu: string;
859
+ tagItem: string;
860
+ tagItemText: string;
861
+ tagItemIconContainer: string;
862
+ tagItemIcon: string;
863
+ list: string;
864
+ listGroupLabel: string;
865
+ listItem: string;
866
+ listDisabledItem: string;
867
+ searchContainer: string;
868
+ searchBox: string;
869
+ searchIcon: string;
870
+ closeIcon: string;
871
+ emptyState: string;
872
+ trailing: string;
873
+ description: string;
874
+ error: string;
875
+ };
876
+ type TSelectMenuFormStyles = DeepPartialType$1<typeof base$2>;
877
+
878
+ type TDateMenuFormProps = {
879
+ name: string;
880
+ type?: 'normal' | 'inset' | 'overlapping' | 'pill' | 'floored';
881
+ size?: 'compact' | 'expanded';
882
+ label?: string;
883
+ i18n?: string;
884
+ description?: string;
885
+ placeholder?: string;
886
+ separator?: string;
887
+ startFrom?: Date;
888
+ displayFormat?: string;
889
+ direction?: 'up' | 'down';
890
+ minDate?: Date;
891
+ maxDate?: Date;
892
+ startWeekOn?: 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
893
+ icon?: (isOpen: boolean) => ReactNode;
894
+ required?: ({ isRequired }: {
895
+ isRequired: boolean;
896
+ }) => string | ReactNode;
897
+ value: {
898
+ label: string;
899
+ value: string;
900
+ disabled?: boolean;
901
+ };
902
+ error?: string;
903
+ isRequired?: boolean;
904
+ isTouched?: boolean;
905
+ isDisabled?: boolean;
906
+ isSolo?: boolean;
907
+ isRanged?: boolean;
908
+ onChange?: (value: {
909
+ startDate: string;
910
+ endDate: string;
911
+ }) => void;
912
+ onClear?: (name: string) => void;
913
+ onBlur?: any;
914
+ styles?: TDateMenuFormStyles;
915
+ };
878
916
  declare const DateMenuForm: FC<TDateMenuFormProps>;
879
917
 
880
- declare const base$1: {
881
- container: string;
882
- head: string;
883
- body: string;
884
- foot: string;
885
- label: string;
886
- hint: string;
887
- leading: string;
888
- input: string;
889
- trailing: string;
890
- description: string;
891
- error: string;
892
- };
893
- type TDateMenuFormStyles = DeepPartial$1<typeof base$1>;
894
-
895
- type TCheckboxInputGroupFormProps = {
896
- name: string;
897
- form: FormikProps<FormikValues>;
898
- options: {
899
- title: string;
900
- description: string;
901
- value: string;
902
- }[];
903
- values: string[];
904
- isDisabled?: boolean;
905
- onChange?: (value: string) => void;
906
- styles?: TCheckboxInputGroupFormStyles;
907
- };
918
+ declare const base$1: {
919
+ container: string;
920
+ head: string;
921
+ body: string;
922
+ foot: string;
923
+ label: string;
924
+ hint: string;
925
+ leading: string;
926
+ input: string;
927
+ trailing: string;
928
+ description: string;
929
+ error: string;
930
+ };
931
+ type TDateMenuFormStyles = DeepPartialType$1<typeof base$1>;
932
+
933
+ type TCheckboxInputGroupFormProps = {
934
+ name: string;
935
+ form: FormikProps<FormikValues>;
936
+ options: {
937
+ title: string;
938
+ description?: string;
939
+ value: string;
940
+ }[];
941
+ values: string[];
942
+ isDisabled?: boolean;
943
+ onChange?: (value: string) => void;
944
+ styles?: TCheckboxInputGroupFormStyles;
945
+ };
908
946
  declare const CheckboxInputGroupForm: FC<TCheckboxInputGroupFormProps>;
909
947
 
910
- declare const base: {
911
- container: string;
912
- sr: string;
913
- list: string;
914
- item: {
915
- container: string;
916
- head: string;
917
- body: string;
918
- input: string;
919
- label: string;
920
- description: string;
921
- };
922
- };
923
- type TCheckboxInputGroupFormStyles = DeepPartial$1<typeof base>;
924
-
925
- export { AvatarElement, BadgeElement, BreadcrumbsNavigation, ButtonElement, ButtonGroupElement, CheckboxInputGroupForm as CheckboxInputFormGroup, ContainerLayout, DateMenuForm, DividerLayout, DropdownElement, IconElement, InputGroupForm, ListContainerLayout, MediaObjectLayout, ModalOverlay, NotificationOverlay, PagePaginationNavigation, LayoutPanel as PanelLayout, PanelPaginationNavigation, SelectMenuForm, SlideOverOverlay, TButtonElementProps, TCheckboxInputGroupFormProps, TCheckboxInputGroupFormStyles, TDateMenuFormProps, TDateMenuFormStyles, TInputGroupFormProps, TInputGroupStyles, TModalOverlayProps, TSelectMenuFormProps, TSelectMenuFormStyles, TTableListProps as TTableList2Props, TTableListProps$1 as TTableListProps, TTableListStyles, TabNavigation, TableColumnOptionsCustom, TableExcelExportCustom as TableExportCustom, TableList, TableList2, VerticalNavigation };
948
+ declare const base: {
949
+ container: string;
950
+ sr: string;
951
+ list: string;
952
+ item: {
953
+ container: string;
954
+ head: string;
955
+ body: string;
956
+ input: string;
957
+ label: string;
958
+ description: string;
959
+ };
960
+ };
961
+ type TCheckboxInputGroupFormStyles = DeepPartialType$1<typeof base>;
962
+
963
+ export { AvatarElement, BadgeElement, BreadcrumbsNavigation, ButtonElement, ButtonGroupElement, CheckboxInputGroupForm as CheckboxInputFormGroup, ContainerLayout, DateMenuForm, DividerLayout, DropdownElement, IconElement, InputGroupForm, ListContainerLayout, MediaObjectLayout, ModalOverlay, NotificationOverlay, PagePaginationNavigation, LayoutPanel as PanelLayout, PanelPaginationNavigation, SelectMenuForm, SlideOverOverlay, type TButtonElementProps, type TCheckboxInputGroupFormProps, type TCheckboxInputGroupFormStyles, type TDateMenuFormProps, type TDateMenuFormStyles, type TInputGroupFormProps, type TInputGroupStyles, type TModalOverlayProps, type TSelectMenuFormProps, type TSelectMenuFormStyles, type TTableListProps as TTableList2Props, type TTableListProps$1 as TTableListProps, type TTableListStyles$1 as TTableListStyles, TabNavigation, TableColumnOptionsCustom, TableExcelExportCustom as TableExportCustom, TableList, TableList2, VerticalNavigation };