@vuetify/nightly 3.6.0-alpha.2-dev.2024-04-29 → 3.6.0-alpha.2-dev.2024-04-30
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +4 -2
- package/dist/json/attributes.json +61 -9
- package/dist/json/importMap-labs.json +26 -22
- package/dist/json/importMap.json +128 -128
- package/dist/json/tags.json +19 -1
- package/dist/json/web-types.json +906 -494
- package/dist/vuetify-labs.css +2398 -2341
- package/dist/vuetify-labs.d.ts +438 -214
- package/dist/vuetify-labs.esm.js +220 -18
- package/dist/vuetify-labs.esm.js.map +1 -1
- package/dist/vuetify-labs.js +220 -18
- package/dist/vuetify-labs.min.css +2 -2
- package/dist/vuetify.css +829 -798
- package/dist/vuetify.d.ts +300 -257
- package/dist/vuetify.esm.js +111 -18
- package/dist/vuetify.esm.js.map +1 -1
- package/dist/vuetify.js +111 -18
- package/dist/vuetify.js.map +1 -1
- package/dist/vuetify.min.css +2 -2
- package/dist/vuetify.min.js +180 -175
- package/dist/vuetify.min.js.map +1 -1
- package/lib/components/VDataIterator/index.d.mts +2 -0
- package/lib/components/VDataTable/VDataTable.css +35 -0
- package/lib/components/VDataTable/VDataTable.sass +34 -1
- package/lib/components/VDataTable/VDataTableFooter.css +5 -9
- package/lib/components/VDataTable/VDataTableFooter.sass +21 -21
- package/lib/components/VDataTable/VDataTableHeaders.mjs +66 -7
- package/lib/components/VDataTable/VDataTableHeaders.mjs.map +1 -1
- package/lib/components/VDataTable/VDataTableRow.mjs +45 -10
- package/lib/components/VDataTable/VDataTableRow.mjs.map +1 -1
- package/lib/components/VDataTable/VDataTableRows.mjs +8 -2
- package/lib/components/VDataTable/VDataTableRows.mjs.map +1 -1
- package/lib/components/VDataTable/_variables.scss +9 -4
- package/lib/components/VDataTable/index.d.mts +263 -217
- package/lib/components/VDataTable/types.mjs.map +1 -1
- package/lib/components/VNavigationDrawer/VNavigationDrawer.css +1 -1
- package/lib/components/VNavigationDrawer/VNavigationDrawer.sass +1 -1
- package/lib/components/index.d.mts +255 -213
- package/lib/entry-bundler.mjs +1 -1
- package/lib/framework.mjs +1 -1
- package/lib/index.d.mts +45 -44
- package/lib/labs/VPullToRefresh/VPullToRefresh.css +27 -0
- package/lib/labs/VPullToRefresh/VPullToRefresh.mjs +117 -0
- package/lib/labs/VPullToRefresh/VPullToRefresh.mjs.map +1 -0
- package/lib/labs/VPullToRefresh/VPullToRefresh.sass +23 -0
- package/lib/labs/VPullToRefresh/index.d.mts +189 -0
- package/lib/labs/VPullToRefresh/index.mjs +2 -0
- package/lib/labs/VPullToRefresh/index.mjs.map +1 -0
- package/lib/labs/components.d.mts +182 -1
- package/lib/labs/components.mjs +1 -0
- package/lib/labs/components.mjs.map +1 -1
- package/package.json +1 -1
|
@@ -22669,6 +22669,7 @@ type DataTableHeader<T = Record<string, any>> = {
|
|
|
22669
22669
|
sort?: DataTableCompareFunction;
|
|
22670
22670
|
sortRaw?: DataTableCompareFunction;
|
|
22671
22671
|
filter?: FilterFunction;
|
|
22672
|
+
mobile?: boolean;
|
|
22672
22673
|
children?: DataTableHeader<T>[];
|
|
22673
22674
|
};
|
|
22674
22675
|
type InternalDataTableHeader = Omit<DataTableHeader, 'key' | 'value' | 'children'> & {
|
|
@@ -22677,6 +22678,7 @@ type InternalDataTableHeader = Omit<DataTableHeader, 'key' | 'value' | 'children
|
|
|
22677
22678
|
sortable: boolean;
|
|
22678
22679
|
fixedOffset?: number;
|
|
22679
22680
|
lastFixed?: boolean;
|
|
22681
|
+
nowrap?: boolean;
|
|
22680
22682
|
colspan?: number;
|
|
22681
22683
|
rowspan?: number;
|
|
22682
22684
|
children?: InternalDataTableHeader[];
|
|
@@ -23316,6 +23318,7 @@ type VDataTableHeadersSlots = {
|
|
|
23316
23318
|
};
|
|
23317
23319
|
declare const VDataTableHeaders: {
|
|
23318
23320
|
new (...args: any[]): vue.CreateComponentPublicInstance<{
|
|
23321
|
+
mobile: boolean;
|
|
23319
23322
|
sticky: boolean;
|
|
23320
23323
|
multiSort: boolean;
|
|
23321
23324
|
sortAscIcon: IconValue;
|
|
@@ -23323,6 +23326,7 @@ declare const VDataTableHeaders: {
|
|
|
23323
23326
|
} & {
|
|
23324
23327
|
color?: string | undefined;
|
|
23325
23328
|
loading?: string | boolean | undefined;
|
|
23329
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23326
23330
|
headerProps?: Record<string, any> | undefined;
|
|
23327
23331
|
} & {
|
|
23328
23332
|
$children?: {} | vue.VNodeChild | {
|
|
@@ -23346,6 +23350,7 @@ declare const VDataTableHeaders: {
|
|
|
23346
23350
|
"v-slot:header.data-table-select"?: false | ((arg: VDataTableHeaderCellColumnSlotProps) => vue.VNodeChild) | undefined;
|
|
23347
23351
|
"v-slot:header.data-table-expand"?: false | ((arg: VDataTableHeaderCellColumnSlotProps) => vue.VNodeChild) | undefined;
|
|
23348
23352
|
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
|
|
23353
|
+
mobile: boolean;
|
|
23349
23354
|
sticky: boolean;
|
|
23350
23355
|
multiSort: boolean;
|
|
23351
23356
|
sortAscIcon: IconValue;
|
|
@@ -23353,6 +23358,7 @@ declare const VDataTableHeaders: {
|
|
|
23353
23358
|
} & {
|
|
23354
23359
|
color?: string | undefined;
|
|
23355
23360
|
loading?: string | boolean | undefined;
|
|
23361
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23356
23362
|
headerProps?: Record<string, any> | undefined;
|
|
23357
23363
|
} & {
|
|
23358
23364
|
$children?: {} | vue.VNodeChild | {
|
|
@@ -23376,6 +23382,7 @@ declare const VDataTableHeaders: {
|
|
|
23376
23382
|
"v-slot:header.data-table-select"?: false | ((arg: VDataTableHeaderCellColumnSlotProps) => vue.VNodeChild) | undefined;
|
|
23377
23383
|
"v-slot:header.data-table-expand"?: false | ((arg: VDataTableHeaderCellColumnSlotProps) => vue.VNodeChild) | undefined;
|
|
23378
23384
|
}, {
|
|
23385
|
+
mobile: boolean;
|
|
23379
23386
|
sticky: boolean;
|
|
23380
23387
|
multiSort: boolean;
|
|
23381
23388
|
sortAscIcon: IconValue;
|
|
@@ -23404,6 +23411,7 @@ declare const VDataTableHeaders: {
|
|
|
23404
23411
|
M: {};
|
|
23405
23412
|
Defaults: {};
|
|
23406
23413
|
}, {
|
|
23414
|
+
mobile: boolean;
|
|
23407
23415
|
sticky: boolean;
|
|
23408
23416
|
multiSort: boolean;
|
|
23409
23417
|
sortAscIcon: IconValue;
|
|
@@ -23411,6 +23419,7 @@ declare const VDataTableHeaders: {
|
|
|
23411
23419
|
} & {
|
|
23412
23420
|
color?: string | undefined;
|
|
23413
23421
|
loading?: string | boolean | undefined;
|
|
23422
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23414
23423
|
headerProps?: Record<string, any> | undefined;
|
|
23415
23424
|
} & {
|
|
23416
23425
|
$children?: {} | vue.VNodeChild | {
|
|
@@ -23434,6 +23443,7 @@ declare const VDataTableHeaders: {
|
|
|
23434
23443
|
"v-slot:header.data-table-select"?: false | ((arg: VDataTableHeaderCellColumnSlotProps) => vue.VNodeChild) | undefined;
|
|
23435
23444
|
"v-slot:header.data-table-expand"?: false | ((arg: VDataTableHeaderCellColumnSlotProps) => vue.VNodeChild) | undefined;
|
|
23436
23445
|
}, {}, {}, {}, {}, {
|
|
23446
|
+
mobile: boolean;
|
|
23437
23447
|
sticky: boolean;
|
|
23438
23448
|
multiSort: boolean;
|
|
23439
23449
|
sortAscIcon: IconValue;
|
|
@@ -23443,6 +23453,7 @@ declare const VDataTableHeaders: {
|
|
|
23443
23453
|
__isTeleport?: undefined;
|
|
23444
23454
|
__isSuspense?: undefined;
|
|
23445
23455
|
} & vue.ComponentOptionsBase<{
|
|
23456
|
+
mobile: boolean;
|
|
23446
23457
|
sticky: boolean;
|
|
23447
23458
|
multiSort: boolean;
|
|
23448
23459
|
sortAscIcon: IconValue;
|
|
@@ -23450,6 +23461,7 @@ declare const VDataTableHeaders: {
|
|
|
23450
23461
|
} & {
|
|
23451
23462
|
color?: string | undefined;
|
|
23452
23463
|
loading?: string | boolean | undefined;
|
|
23464
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23453
23465
|
headerProps?: Record<string, any> | undefined;
|
|
23454
23466
|
} & {
|
|
23455
23467
|
$children?: {} | vue.VNodeChild | {
|
|
@@ -23473,6 +23485,7 @@ declare const VDataTableHeaders: {
|
|
|
23473
23485
|
"v-slot:header.data-table-select"?: false | ((arg: VDataTableHeaderCellColumnSlotProps) => vue.VNodeChild) | undefined;
|
|
23474
23486
|
"v-slot:header.data-table-expand"?: false | ((arg: VDataTableHeaderCellColumnSlotProps) => vue.VNodeChild) | undefined;
|
|
23475
23487
|
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
|
|
23488
|
+
mobile: boolean;
|
|
23476
23489
|
sticky: boolean;
|
|
23477
23490
|
multiSort: boolean;
|
|
23478
23491
|
sortAscIcon: IconValue;
|
|
@@ -23495,6 +23508,11 @@ declare const VDataTableHeaders: {
|
|
|
23495
23508
|
}>[];
|
|
23496
23509
|
}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
|
|
23497
23510
|
loading: (StringConstructor | BooleanConstructor)[];
|
|
23511
|
+
mobile: {
|
|
23512
|
+
type: BooleanConstructor;
|
|
23513
|
+
default: null;
|
|
23514
|
+
};
|
|
23515
|
+
mobileBreakpoint: PropType<number | DisplayBreakpoint>;
|
|
23498
23516
|
color: StringConstructor;
|
|
23499
23517
|
sticky: BooleanConstructor;
|
|
23500
23518
|
multiSort: BooleanConstructor;
|
|
@@ -23511,6 +23529,11 @@ declare const VDataTableHeaders: {
|
|
|
23511
23529
|
};
|
|
23512
23530
|
}, vue.ExtractPropTypes<{
|
|
23513
23531
|
loading: (StringConstructor | BooleanConstructor)[];
|
|
23532
|
+
mobile: {
|
|
23533
|
+
type: BooleanConstructor;
|
|
23534
|
+
default: null;
|
|
23535
|
+
};
|
|
23536
|
+
mobileBreakpoint: PropType<number | DisplayBreakpoint>;
|
|
23514
23537
|
color: StringConstructor;
|
|
23515
23538
|
sticky: BooleanConstructor;
|
|
23516
23539
|
multiSort: BooleanConstructor;
|
|
@@ -23542,30 +23565,50 @@ type VDataTableGroupHeaderRowSlots = {
|
|
|
23542
23565
|
type VDataTableRowSlots<T> = {
|
|
23543
23566
|
'item.data-table-select': Omit<ItemKeySlot<T>, 'value'>;
|
|
23544
23567
|
'item.data-table-expand': Omit<ItemKeySlot<T>, 'value'>;
|
|
23568
|
+
'header.data-table-select': VDataTableHeaderCellColumnSlotProps;
|
|
23569
|
+
'header.data-table-expand': VDataTableHeaderCellColumnSlotProps;
|
|
23545
23570
|
} & {
|
|
23546
23571
|
[key: `item.${string}`]: ItemKeySlot<T>;
|
|
23572
|
+
[key: `header.${string}`]: VDataTableHeaderCellColumnSlotProps;
|
|
23547
23573
|
};
|
|
23548
23574
|
declare const VDataTableRow: {
|
|
23549
|
-
new (...args: any[]): vue.CreateComponentPublicInstance<{
|
|
23575
|
+
new (...args: any[]): vue.CreateComponentPublicInstance<{
|
|
23576
|
+
mobile: boolean;
|
|
23577
|
+
} & {
|
|
23550
23578
|
onClick?: ((args_0: MouseEvent) => void) | undefined;
|
|
23551
23579
|
onContextmenu?: ((args_0: MouseEvent) => void) | undefined;
|
|
23552
23580
|
onDblclick?: ((args_0: MouseEvent) => void) | undefined;
|
|
23581
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23553
23582
|
index?: number | undefined;
|
|
23554
|
-
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slots" | "item" | "cellProps" | `v-slot:item.${string}`>, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
|
|
23583
|
+
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slots" | "item" | "cellProps" | `v-slot:header.${string}` | `v-slot:item.${string}`>, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
|
|
23584
|
+
mobile: boolean;
|
|
23585
|
+
} & {
|
|
23555
23586
|
onClick?: ((args_0: MouseEvent) => void) | undefined;
|
|
23556
23587
|
onContextmenu?: ((args_0: MouseEvent) => void) | undefined;
|
|
23557
23588
|
onDblclick?: ((args_0: MouseEvent) => void) | undefined;
|
|
23589
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23558
23590
|
index?: number | undefined;
|
|
23559
|
-
}, {
|
|
23591
|
+
}, {
|
|
23592
|
+
mobile: boolean;
|
|
23593
|
+
}, true, {}, vue.SlotsType<Partial<{
|
|
23560
23594
|
[x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23561
23595
|
[key: string]: any;
|
|
23562
23596
|
}>[];
|
|
23597
|
+
[x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23598
|
+
[key: string]: any;
|
|
23599
|
+
}>[];
|
|
23563
23600
|
'item.data-table-select': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23564
23601
|
[key: string]: any;
|
|
23565
23602
|
}>[];
|
|
23566
23603
|
'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23567
23604
|
[key: string]: any;
|
|
23568
23605
|
}>[];
|
|
23606
|
+
'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23607
|
+
[key: string]: any;
|
|
23608
|
+
}>[];
|
|
23609
|
+
'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23610
|
+
[key: string]: any;
|
|
23611
|
+
}>[];
|
|
23569
23612
|
}>>, {
|
|
23570
23613
|
P: {};
|
|
23571
23614
|
B: {};
|
|
@@ -23573,30 +23616,49 @@ declare const VDataTableRow: {
|
|
|
23573
23616
|
C: {};
|
|
23574
23617
|
M: {};
|
|
23575
23618
|
Defaults: {};
|
|
23576
|
-
}, {
|
|
23619
|
+
}, {
|
|
23620
|
+
mobile: boolean;
|
|
23621
|
+
} & {
|
|
23577
23622
|
onClick?: ((args_0: MouseEvent) => void) | undefined;
|
|
23578
23623
|
onContextmenu?: ((args_0: MouseEvent) => void) | undefined;
|
|
23579
23624
|
onDblclick?: ((args_0: MouseEvent) => void) | undefined;
|
|
23625
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23580
23626
|
index?: number | undefined;
|
|
23581
|
-
}, {}, {}, {}, {}, {
|
|
23627
|
+
}, {}, {}, {}, {}, {
|
|
23628
|
+
mobile: boolean;
|
|
23629
|
+
}>;
|
|
23582
23630
|
__isFragment?: undefined;
|
|
23583
23631
|
__isTeleport?: undefined;
|
|
23584
23632
|
__isSuspense?: undefined;
|
|
23585
|
-
} & vue.ComponentOptionsBase<{
|
|
23633
|
+
} & vue.ComponentOptionsBase<{
|
|
23634
|
+
mobile: boolean;
|
|
23635
|
+
} & {
|
|
23586
23636
|
onClick?: ((args_0: MouseEvent) => void) | undefined;
|
|
23587
23637
|
onContextmenu?: ((args_0: MouseEvent) => void) | undefined;
|
|
23588
23638
|
onDblclick?: ((args_0: MouseEvent) => void) | undefined;
|
|
23639
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23589
23640
|
index?: number | undefined;
|
|
23590
|
-
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slots" | "item" | "cellProps" | `v-slot:
|
|
23641
|
+
}, void, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slots" | "item" | "cellProps" | `v-slot:header.${string}` | `v-slot:item.${string}`>, string, {
|
|
23642
|
+
mobile: boolean;
|
|
23643
|
+
}, {}, string, vue.SlotsType<Partial<{
|
|
23591
23644
|
[x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23592
23645
|
[key: string]: any;
|
|
23593
23646
|
}>[];
|
|
23647
|
+
[x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23648
|
+
[key: string]: any;
|
|
23649
|
+
}>[];
|
|
23594
23650
|
'item.data-table-select': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23595
23651
|
[key: string]: any;
|
|
23596
23652
|
}>[];
|
|
23597
23653
|
'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23598
23654
|
[key: string]: any;
|
|
23599
23655
|
}>[];
|
|
23656
|
+
'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23657
|
+
[key: string]: any;
|
|
23658
|
+
}>[];
|
|
23659
|
+
'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23660
|
+
[key: string]: any;
|
|
23661
|
+
}>[];
|
|
23600
23662
|
}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T>(props: {
|
|
23601
23663
|
item?: DataTableItem<T> | undefined;
|
|
23602
23664
|
cellProps?: CellProps<T> | undefined;
|
|
@@ -23604,6 +23666,11 @@ declare const VDataTableRow: {
|
|
|
23604
23666
|
item?: DataTableItem<T> | undefined;
|
|
23605
23667
|
cellProps?: CellProps<T> | undefined;
|
|
23606
23668
|
}, VDataTableRowSlots<T>>) & FilterPropsOptions<{
|
|
23669
|
+
mobile: {
|
|
23670
|
+
type: BooleanConstructor;
|
|
23671
|
+
default: null;
|
|
23672
|
+
};
|
|
23673
|
+
mobileBreakpoint: PropType<number | DisplayBreakpoint>;
|
|
23607
23674
|
index: NumberConstructor;
|
|
23608
23675
|
item: PropType<DataTableItem<any>>;
|
|
23609
23676
|
cellProps: PropType<CellProps<any>>;
|
|
@@ -23611,6 +23678,11 @@ declare const VDataTableRow: {
|
|
|
23611
23678
|
onContextmenu: PropType<(args_0: MouseEvent) => void>;
|
|
23612
23679
|
onDblclick: PropType<(args_0: MouseEvent) => void>;
|
|
23613
23680
|
}, vue.ExtractPropTypes<{
|
|
23681
|
+
mobile: {
|
|
23682
|
+
type: BooleanConstructor;
|
|
23683
|
+
default: null;
|
|
23684
|
+
};
|
|
23685
|
+
mobileBreakpoint: PropType<number | DisplayBreakpoint>;
|
|
23614
23686
|
index: NumberConstructor;
|
|
23615
23687
|
item: PropType<DataTableItem<any>>;
|
|
23616
23688
|
cellProps: PropType<CellProps<any>>;
|
|
@@ -23633,27 +23705,35 @@ declare const VDataTableRows: {
|
|
|
23633
23705
|
new (...args: any[]): vue.CreateComponentPublicInstance<{
|
|
23634
23706
|
noDataText: string;
|
|
23635
23707
|
loadingText: string;
|
|
23708
|
+
mobile: boolean;
|
|
23636
23709
|
hideNoData: boolean;
|
|
23637
23710
|
} & {
|
|
23638
23711
|
loading?: string | boolean | undefined;
|
|
23712
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23639
23713
|
cellProps?: CellProps<any> | undefined;
|
|
23640
23714
|
rowProps?: RowProps<any> | undefined;
|
|
23641
|
-
}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slots" | "items" | "v-slot:item" | "v-slot:no-data" | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
|
|
23715
|
+
}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slots" | "items" | "v-slot:item" | "v-slot:no-data" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
|
|
23642
23716
|
noDataText: string;
|
|
23643
23717
|
loadingText: string;
|
|
23718
|
+
mobile: boolean;
|
|
23644
23719
|
hideNoData: boolean;
|
|
23645
23720
|
} & {
|
|
23646
23721
|
loading?: string | boolean | undefined;
|
|
23722
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23647
23723
|
cellProps?: CellProps<any> | undefined;
|
|
23648
23724
|
rowProps?: RowProps<any> | undefined;
|
|
23649
23725
|
}, {
|
|
23650
23726
|
noDataText: string;
|
|
23651
23727
|
loadingText: string;
|
|
23728
|
+
mobile: boolean;
|
|
23652
23729
|
hideNoData: boolean;
|
|
23653
23730
|
}, true, {}, vue.SlotsType<Partial<{
|
|
23654
23731
|
[x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23655
23732
|
[key: string]: any;
|
|
23656
23733
|
}>[];
|
|
23734
|
+
[x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23735
|
+
[key: string]: any;
|
|
23736
|
+
}>[];
|
|
23657
23737
|
'data-table-group': (arg: {
|
|
23658
23738
|
item: Group<any>;
|
|
23659
23739
|
count: number;
|
|
@@ -23672,6 +23752,12 @@ declare const VDataTableRows: {
|
|
|
23672
23752
|
'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23673
23753
|
[key: string]: any;
|
|
23674
23754
|
}>[];
|
|
23755
|
+
'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23756
|
+
[key: string]: any;
|
|
23757
|
+
}>[];
|
|
23758
|
+
'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23759
|
+
[key: string]: any;
|
|
23760
|
+
}>[];
|
|
23675
23761
|
item: (arg: {
|
|
23676
23762
|
index: number;
|
|
23677
23763
|
item: unknown;
|
|
@@ -23709,14 +23795,17 @@ declare const VDataTableRows: {
|
|
|
23709
23795
|
}, {
|
|
23710
23796
|
noDataText: string;
|
|
23711
23797
|
loadingText: string;
|
|
23798
|
+
mobile: boolean;
|
|
23712
23799
|
hideNoData: boolean;
|
|
23713
23800
|
} & {
|
|
23714
23801
|
loading?: string | boolean | undefined;
|
|
23802
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23715
23803
|
cellProps?: CellProps<any> | undefined;
|
|
23716
23804
|
rowProps?: RowProps<any> | undefined;
|
|
23717
23805
|
}, {}, {}, {}, {}, {
|
|
23718
23806
|
noDataText: string;
|
|
23719
23807
|
loadingText: string;
|
|
23808
|
+
mobile: boolean;
|
|
23720
23809
|
hideNoData: boolean;
|
|
23721
23810
|
}>;
|
|
23722
23811
|
__isFragment?: undefined;
|
|
@@ -23725,19 +23814,25 @@ declare const VDataTableRows: {
|
|
|
23725
23814
|
} & vue.ComponentOptionsBase<{
|
|
23726
23815
|
noDataText: string;
|
|
23727
23816
|
loadingText: string;
|
|
23817
|
+
mobile: boolean;
|
|
23728
23818
|
hideNoData: boolean;
|
|
23729
23819
|
} & {
|
|
23730
23820
|
loading?: string | boolean | undefined;
|
|
23821
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23731
23822
|
cellProps?: CellProps<any> | undefined;
|
|
23732
23823
|
rowProps?: RowProps<any> | undefined;
|
|
23733
|
-
}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slots" | "items" | "v-slot:item" | "v-slot:no-data" | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row">, string, {
|
|
23824
|
+
}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<Record<string, any>, "$children" | "v-slots" | "items" | "v-slot:item" | "v-slot:no-data" | `v-slot:header.${string}` | "v-slot:data-table-group" | "v-slot:data-table-select" | `v-slot:item.${string}` | "v-slot:loading" | "v-slot:group-header" | "v-slot:expanded-row">, string, {
|
|
23734
23825
|
noDataText: string;
|
|
23735
23826
|
loadingText: string;
|
|
23827
|
+
mobile: boolean;
|
|
23736
23828
|
hideNoData: boolean;
|
|
23737
23829
|
}, {}, string, vue.SlotsType<Partial<{
|
|
23738
23830
|
[x: `item.${string}`]: (arg: ItemKeySlot<unknown>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23739
23831
|
[key: string]: any;
|
|
23740
23832
|
}>[];
|
|
23833
|
+
[x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23834
|
+
[key: string]: any;
|
|
23835
|
+
}>[];
|
|
23741
23836
|
'data-table-group': (arg: {
|
|
23742
23837
|
item: Group<any>;
|
|
23743
23838
|
count: number;
|
|
@@ -23756,6 +23851,12 @@ declare const VDataTableRows: {
|
|
|
23756
23851
|
'item.data-table-expand': (arg: Omit<ItemKeySlot<unknown>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23757
23852
|
[key: string]: any;
|
|
23758
23853
|
}>[];
|
|
23854
|
+
'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23855
|
+
[key: string]: any;
|
|
23856
|
+
}>[];
|
|
23857
|
+
'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
23858
|
+
[key: string]: any;
|
|
23859
|
+
}>[];
|
|
23759
23860
|
item: (arg: {
|
|
23760
23861
|
index: number;
|
|
23761
23862
|
item: unknown;
|
|
@@ -23788,6 +23889,11 @@ declare const VDataTableRows: {
|
|
|
23788
23889
|
}, slots: VDataTableRowsSlots<T>) => GenericProps<{
|
|
23789
23890
|
items?: readonly (DataTableItem<T> | Group<T>)[] | undefined;
|
|
23790
23891
|
}, VDataTableRowsSlots<T>>) & FilterPropsOptions<{
|
|
23892
|
+
mobile: {
|
|
23893
|
+
type: BooleanConstructor;
|
|
23894
|
+
default: null;
|
|
23895
|
+
};
|
|
23896
|
+
mobileBreakpoint: PropType<number | DisplayBreakpoint>;
|
|
23791
23897
|
loading: (StringConstructor | BooleanConstructor)[];
|
|
23792
23898
|
loadingText: {
|
|
23793
23899
|
type: StringConstructor;
|
|
@@ -23805,6 +23911,11 @@ declare const VDataTableRows: {
|
|
|
23805
23911
|
rowProps: PropType<RowProps<any>>;
|
|
23806
23912
|
cellProps: PropType<CellProps<any>>;
|
|
23807
23913
|
}, vue.ExtractPropTypes<{
|
|
23914
|
+
mobile: {
|
|
23915
|
+
type: BooleanConstructor;
|
|
23916
|
+
default: null;
|
|
23917
|
+
};
|
|
23918
|
+
mobileBreakpoint: PropType<number | DisplayBreakpoint>;
|
|
23808
23919
|
loading: (StringConstructor | BooleanConstructor)[];
|
|
23809
23920
|
loadingText: {
|
|
23810
23921
|
type: StringConstructor;
|
|
@@ -23871,6 +23982,7 @@ declare const VDataTable: {
|
|
|
23871
23982
|
sortBy: readonly SortItem[];
|
|
23872
23983
|
pageText: string;
|
|
23873
23984
|
page: string | number;
|
|
23985
|
+
mobile: boolean;
|
|
23874
23986
|
sticky: boolean;
|
|
23875
23987
|
expanded: readonly string[];
|
|
23876
23988
|
density: Density;
|
|
@@ -23913,6 +24025,7 @@ declare const VDataTable: {
|
|
|
23913
24025
|
theme?: string | undefined;
|
|
23914
24026
|
color?: string | undefined;
|
|
23915
24027
|
loading?: string | boolean | undefined;
|
|
24028
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23916
24029
|
customFilter?: FilterFunction | undefined;
|
|
23917
24030
|
customKeyFilter?: FilterKeyFunctions | undefined;
|
|
23918
24031
|
filterKeys?: FilterKeys | undefined;
|
|
@@ -23944,6 +24057,7 @@ declare const VDataTable: {
|
|
|
23944
24057
|
sortBy: readonly SortItem[];
|
|
23945
24058
|
pageText: string;
|
|
23946
24059
|
page: string | number;
|
|
24060
|
+
mobile: boolean;
|
|
23947
24061
|
sticky: boolean;
|
|
23948
24062
|
expanded: readonly string[];
|
|
23949
24063
|
density: Density;
|
|
@@ -23986,6 +24100,7 @@ declare const VDataTable: {
|
|
|
23986
24100
|
theme?: string | undefined;
|
|
23987
24101
|
color?: string | undefined;
|
|
23988
24102
|
loading?: string | boolean | undefined;
|
|
24103
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
23989
24104
|
customFilter?: FilterFunction | undefined;
|
|
23990
24105
|
customKeyFilter?: FilterKeyFunctions | undefined;
|
|
23991
24106
|
filterKeys?: FilterKeys | undefined;
|
|
@@ -24008,6 +24123,7 @@ declare const VDataTable: {
|
|
|
24008
24123
|
sortBy: readonly SortItem[];
|
|
24009
24124
|
pageText: string;
|
|
24010
24125
|
page: string | number;
|
|
24126
|
+
mobile: boolean;
|
|
24011
24127
|
sticky: boolean;
|
|
24012
24128
|
expanded: readonly string[];
|
|
24013
24129
|
density: Density;
|
|
@@ -24046,16 +24162,7 @@ declare const VDataTable: {
|
|
|
24046
24162
|
[x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24047
24163
|
[key: string]: any;
|
|
24048
24164
|
}>[];
|
|
24049
|
-
[x: `header.${string}`]: (arg: {
|
|
24050
|
-
column: InternalDataTableHeader;
|
|
24051
|
-
selectAll: (value: boolean) => void;
|
|
24052
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
24053
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
24054
|
-
sortBy: readonly SortItem[];
|
|
24055
|
-
someSelected: boolean;
|
|
24056
|
-
allSelected: boolean;
|
|
24057
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
24058
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24165
|
+
[x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24059
24166
|
[key: string]: any;
|
|
24060
24167
|
}>[];
|
|
24061
24168
|
'data-table-group': (arg: {
|
|
@@ -24076,6 +24183,12 @@ declare const VDataTable: {
|
|
|
24076
24183
|
'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24077
24184
|
[key: string]: any;
|
|
24078
24185
|
}>[];
|
|
24186
|
+
'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24187
|
+
[key: string]: any;
|
|
24188
|
+
}>[];
|
|
24189
|
+
'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24190
|
+
[key: string]: any;
|
|
24191
|
+
}>[];
|
|
24079
24192
|
item: (arg: {
|
|
24080
24193
|
index: number;
|
|
24081
24194
|
item: any;
|
|
@@ -24109,30 +24222,6 @@ declare const VDataTable: {
|
|
|
24109
24222
|
loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24110
24223
|
[key: string]: any;
|
|
24111
24224
|
}>[];
|
|
24112
|
-
'header.data-table-select': (arg: {
|
|
24113
|
-
column: InternalDataTableHeader;
|
|
24114
|
-
selectAll: (value: boolean) => void;
|
|
24115
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
24116
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
24117
|
-
sortBy: readonly SortItem[];
|
|
24118
|
-
someSelected: boolean;
|
|
24119
|
-
allSelected: boolean;
|
|
24120
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
24121
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24122
|
-
[key: string]: any;
|
|
24123
|
-
}>[];
|
|
24124
|
-
'header.data-table-expand': (arg: {
|
|
24125
|
-
column: InternalDataTableHeader;
|
|
24126
|
-
selectAll: (value: boolean) => void;
|
|
24127
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
24128
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
24129
|
-
sortBy: readonly SortItem[];
|
|
24130
|
-
someSelected: boolean;
|
|
24131
|
-
allSelected: boolean;
|
|
24132
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
24133
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24134
|
-
[key: string]: any;
|
|
24135
|
-
}>[];
|
|
24136
24225
|
default: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24137
24226
|
[key: string]: any;
|
|
24138
24227
|
}>[];
|
|
@@ -24182,6 +24271,7 @@ declare const VDataTable: {
|
|
|
24182
24271
|
sortBy: readonly SortItem[];
|
|
24183
24272
|
pageText: string;
|
|
24184
24273
|
page: string | number;
|
|
24274
|
+
mobile: boolean;
|
|
24185
24275
|
sticky: boolean;
|
|
24186
24276
|
expanded: readonly string[];
|
|
24187
24277
|
density: Density;
|
|
@@ -24224,6 +24314,7 @@ declare const VDataTable: {
|
|
|
24224
24314
|
theme?: string | undefined;
|
|
24225
24315
|
color?: string | undefined;
|
|
24226
24316
|
loading?: string | boolean | undefined;
|
|
24317
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
24227
24318
|
customFilter?: FilterFunction | undefined;
|
|
24228
24319
|
customKeyFilter?: FilterKeyFunctions | undefined;
|
|
24229
24320
|
filterKeys?: FilterKeys | undefined;
|
|
@@ -24246,6 +24337,7 @@ declare const VDataTable: {
|
|
|
24246
24337
|
sortBy: readonly SortItem[];
|
|
24247
24338
|
pageText: string;
|
|
24248
24339
|
page: string | number;
|
|
24340
|
+
mobile: boolean;
|
|
24249
24341
|
sticky: boolean;
|
|
24250
24342
|
expanded: readonly string[];
|
|
24251
24343
|
density: Density;
|
|
@@ -24293,6 +24385,7 @@ declare const VDataTable: {
|
|
|
24293
24385
|
sortBy: readonly SortItem[];
|
|
24294
24386
|
pageText: string;
|
|
24295
24387
|
page: string | number;
|
|
24388
|
+
mobile: boolean;
|
|
24296
24389
|
sticky: boolean;
|
|
24297
24390
|
expanded: readonly string[];
|
|
24298
24391
|
density: Density;
|
|
@@ -24335,6 +24428,7 @@ declare const VDataTable: {
|
|
|
24335
24428
|
theme?: string | undefined;
|
|
24336
24429
|
color?: string | undefined;
|
|
24337
24430
|
loading?: string | boolean | undefined;
|
|
24431
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
24338
24432
|
customFilter?: FilterFunction | undefined;
|
|
24339
24433
|
customKeyFilter?: FilterKeyFunctions | undefined;
|
|
24340
24434
|
filterKeys?: FilterKeys | undefined;
|
|
@@ -24366,6 +24460,7 @@ declare const VDataTable: {
|
|
|
24366
24460
|
sortBy: readonly SortItem[];
|
|
24367
24461
|
pageText: string;
|
|
24368
24462
|
page: string | number;
|
|
24463
|
+
mobile: boolean;
|
|
24369
24464
|
sticky: boolean;
|
|
24370
24465
|
expanded: readonly string[];
|
|
24371
24466
|
density: Density;
|
|
@@ -24404,16 +24499,7 @@ declare const VDataTable: {
|
|
|
24404
24499
|
[x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24405
24500
|
[key: string]: any;
|
|
24406
24501
|
}>[];
|
|
24407
|
-
[x: `header.${string}`]: (arg: {
|
|
24408
|
-
column: InternalDataTableHeader;
|
|
24409
|
-
selectAll: (value: boolean) => void;
|
|
24410
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
24411
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
24412
|
-
sortBy: readonly SortItem[];
|
|
24413
|
-
someSelected: boolean;
|
|
24414
|
-
allSelected: boolean;
|
|
24415
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
24416
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24502
|
+
[x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24417
24503
|
[key: string]: any;
|
|
24418
24504
|
}>[];
|
|
24419
24505
|
'data-table-group': (arg: {
|
|
@@ -24434,6 +24520,12 @@ declare const VDataTable: {
|
|
|
24434
24520
|
'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24435
24521
|
[key: string]: any;
|
|
24436
24522
|
}>[];
|
|
24523
|
+
'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24524
|
+
[key: string]: any;
|
|
24525
|
+
}>[];
|
|
24526
|
+
'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24527
|
+
[key: string]: any;
|
|
24528
|
+
}>[];
|
|
24437
24529
|
item: (arg: {
|
|
24438
24530
|
index: number;
|
|
24439
24531
|
item: any;
|
|
@@ -24467,30 +24559,6 @@ declare const VDataTable: {
|
|
|
24467
24559
|
loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24468
24560
|
[key: string]: any;
|
|
24469
24561
|
}>[];
|
|
24470
|
-
'header.data-table-select': (arg: {
|
|
24471
|
-
column: InternalDataTableHeader;
|
|
24472
|
-
selectAll: (value: boolean) => void;
|
|
24473
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
24474
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
24475
|
-
sortBy: readonly SortItem[];
|
|
24476
|
-
someSelected: boolean;
|
|
24477
|
-
allSelected: boolean;
|
|
24478
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
24479
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24480
|
-
[key: string]: any;
|
|
24481
|
-
}>[];
|
|
24482
|
-
'header.data-table-expand': (arg: {
|
|
24483
|
-
column: InternalDataTableHeader;
|
|
24484
|
-
selectAll: (value: boolean) => void;
|
|
24485
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
24486
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
24487
|
-
sortBy: readonly SortItem[];
|
|
24488
|
-
someSelected: boolean;
|
|
24489
|
-
allSelected: boolean;
|
|
24490
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
24491
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24492
|
-
[key: string]: any;
|
|
24493
|
-
}>[];
|
|
24494
24562
|
default: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
24495
24563
|
[key: string]: any;
|
|
24496
24564
|
}>[];
|
|
@@ -24550,6 +24618,7 @@ declare const VDataTable: {
|
|
|
24550
24618
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
24551
24619
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
24552
24620
|
readonly filter?: FilterFunction | undefined;
|
|
24621
|
+
readonly mobile?: boolean | undefined;
|
|
24553
24622
|
readonly children?: readonly any[] | undefined;
|
|
24554
24623
|
}[] | undefined;
|
|
24555
24624
|
modelValue?: V | undefined;
|
|
@@ -24580,6 +24649,7 @@ declare const VDataTable: {
|
|
|
24580
24649
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
24581
24650
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
24582
24651
|
readonly filter?: FilterFunction | undefined;
|
|
24652
|
+
readonly mobile?: boolean | undefined;
|
|
24583
24653
|
readonly children?: readonly any[] | undefined;
|
|
24584
24654
|
}[] | undefined;
|
|
24585
24655
|
modelValue?: V | undefined;
|
|
@@ -24664,6 +24734,11 @@ declare const VDataTable: {
|
|
|
24664
24734
|
height: (StringConstructor | NumberConstructor)[];
|
|
24665
24735
|
hover: BooleanConstructor;
|
|
24666
24736
|
loading: (StringConstructor | BooleanConstructor)[];
|
|
24737
|
+
mobile: {
|
|
24738
|
+
type: BooleanConstructor;
|
|
24739
|
+
default: null;
|
|
24740
|
+
};
|
|
24741
|
+
mobileBreakpoint: vue.PropType<number | DisplayBreakpoint>;
|
|
24667
24742
|
color: StringConstructor;
|
|
24668
24743
|
sticky: BooleanConstructor;
|
|
24669
24744
|
multiSort: BooleanConstructor;
|
|
@@ -24732,6 +24807,7 @@ declare const VDataTable: {
|
|
|
24732
24807
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
24733
24808
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
24734
24809
|
readonly filter?: FilterFunction | undefined;
|
|
24810
|
+
readonly mobile?: boolean | undefined;
|
|
24735
24811
|
readonly children?: readonly {
|
|
24736
24812
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
24737
24813
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -24752,6 +24828,7 @@ declare const VDataTable: {
|
|
|
24752
24828
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
24753
24829
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
24754
24830
|
readonly filter?: FilterFunction | undefined;
|
|
24831
|
+
readonly mobile?: boolean | undefined;
|
|
24755
24832
|
readonly children?: readonly any[] | undefined;
|
|
24756
24833
|
}[] | undefined;
|
|
24757
24834
|
}[]>;
|
|
@@ -24864,6 +24941,11 @@ declare const VDataTable: {
|
|
|
24864
24941
|
height: (StringConstructor | NumberConstructor)[];
|
|
24865
24942
|
hover: BooleanConstructor;
|
|
24866
24943
|
loading: (StringConstructor | BooleanConstructor)[];
|
|
24944
|
+
mobile: {
|
|
24945
|
+
type: BooleanConstructor;
|
|
24946
|
+
default: null;
|
|
24947
|
+
};
|
|
24948
|
+
mobileBreakpoint: vue.PropType<number | DisplayBreakpoint>;
|
|
24867
24949
|
color: StringConstructor;
|
|
24868
24950
|
sticky: BooleanConstructor;
|
|
24869
24951
|
multiSort: BooleanConstructor;
|
|
@@ -24932,6 +25014,7 @@ declare const VDataTable: {
|
|
|
24932
25014
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
24933
25015
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
24934
25016
|
readonly filter?: FilterFunction | undefined;
|
|
25017
|
+
readonly mobile?: boolean | undefined;
|
|
24935
25018
|
readonly children?: readonly {
|
|
24936
25019
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
24937
25020
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -24952,6 +25035,7 @@ declare const VDataTable: {
|
|
|
24952
25035
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
24953
25036
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
24954
25037
|
readonly filter?: FilterFunction | undefined;
|
|
25038
|
+
readonly mobile?: boolean | undefined;
|
|
24955
25039
|
readonly children?: readonly any[] | undefined;
|
|
24956
25040
|
}[] | undefined;
|
|
24957
25041
|
}[]>;
|
|
@@ -25281,6 +25365,7 @@ declare const VDataTableVirtual: {
|
|
|
25281
25365
|
noDataText: string;
|
|
25282
25366
|
loadingText: string;
|
|
25283
25367
|
sortBy: readonly SortItem[];
|
|
25368
|
+
mobile: boolean;
|
|
25284
25369
|
sticky: boolean;
|
|
25285
25370
|
expanded: readonly string[];
|
|
25286
25371
|
density: Density;
|
|
@@ -25310,6 +25395,7 @@ declare const VDataTableVirtual: {
|
|
|
25310
25395
|
theme?: string | undefined;
|
|
25311
25396
|
color?: string | undefined;
|
|
25312
25397
|
loading?: string | boolean | undefined;
|
|
25398
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
25313
25399
|
customFilter?: FilterFunction | undefined;
|
|
25314
25400
|
customKeyFilter?: FilterKeyFunctions | undefined;
|
|
25315
25401
|
filterKeys?: FilterKeys | undefined;
|
|
@@ -25335,6 +25421,7 @@ declare const VDataTableVirtual: {
|
|
|
25335
25421
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
25336
25422
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
25337
25423
|
readonly filter?: FilterFunction | undefined;
|
|
25424
|
+
readonly mobile?: boolean | undefined;
|
|
25338
25425
|
readonly children?: readonly {
|
|
25339
25426
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
25340
25427
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -25355,6 +25442,7 @@ declare const VDataTableVirtual: {
|
|
|
25355
25442
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
25356
25443
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
25357
25444
|
readonly filter?: FilterFunction | undefined;
|
|
25445
|
+
readonly mobile?: boolean | undefined;
|
|
25358
25446
|
readonly children?: readonly any[] | undefined;
|
|
25359
25447
|
}[] | undefined;
|
|
25360
25448
|
}[] | undefined;
|
|
@@ -25375,6 +25463,7 @@ declare const VDataTableVirtual: {
|
|
|
25375
25463
|
noDataText: string;
|
|
25376
25464
|
loadingText: string;
|
|
25377
25465
|
sortBy: readonly SortItem[];
|
|
25466
|
+
mobile: boolean;
|
|
25378
25467
|
sticky: boolean;
|
|
25379
25468
|
expanded: readonly string[];
|
|
25380
25469
|
density: Density;
|
|
@@ -25404,6 +25493,7 @@ declare const VDataTableVirtual: {
|
|
|
25404
25493
|
theme?: string | undefined;
|
|
25405
25494
|
color?: string | undefined;
|
|
25406
25495
|
loading?: string | boolean | undefined;
|
|
25496
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
25407
25497
|
customFilter?: FilterFunction | undefined;
|
|
25408
25498
|
customKeyFilter?: FilterKeyFunctions | undefined;
|
|
25409
25499
|
filterKeys?: FilterKeys | undefined;
|
|
@@ -25429,6 +25519,7 @@ declare const VDataTableVirtual: {
|
|
|
25429
25519
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
25430
25520
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
25431
25521
|
readonly filter?: FilterFunction | undefined;
|
|
25522
|
+
readonly mobile?: boolean | undefined;
|
|
25432
25523
|
readonly children?: readonly {
|
|
25433
25524
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
25434
25525
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -25449,6 +25540,7 @@ declare const VDataTableVirtual: {
|
|
|
25449
25540
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
25450
25541
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
25451
25542
|
readonly filter?: FilterFunction | undefined;
|
|
25543
|
+
readonly mobile?: boolean | undefined;
|
|
25452
25544
|
readonly children?: readonly any[] | undefined;
|
|
25453
25545
|
}[] | undefined;
|
|
25454
25546
|
}[] | undefined;
|
|
@@ -25463,6 +25555,7 @@ declare const VDataTableVirtual: {
|
|
|
25463
25555
|
noDataText: string;
|
|
25464
25556
|
loadingText: string;
|
|
25465
25557
|
sortBy: readonly SortItem[];
|
|
25558
|
+
mobile: boolean;
|
|
25466
25559
|
sticky: boolean;
|
|
25467
25560
|
expanded: readonly string[];
|
|
25468
25561
|
density: Density;
|
|
@@ -25488,16 +25581,7 @@ declare const VDataTableVirtual: {
|
|
|
25488
25581
|
[x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25489
25582
|
[key: string]: any;
|
|
25490
25583
|
}>[];
|
|
25491
|
-
[x: `header.${string}`]: (arg: {
|
|
25492
|
-
column: InternalDataTableHeader;
|
|
25493
|
-
selectAll: (value: boolean) => void;
|
|
25494
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
25495
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
25496
|
-
sortBy: readonly SortItem[];
|
|
25497
|
-
someSelected: boolean;
|
|
25498
|
-
allSelected: boolean;
|
|
25499
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
25500
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25584
|
+
[x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25501
25585
|
[key: string]: any;
|
|
25502
25586
|
}>[];
|
|
25503
25587
|
'data-table-group': (arg: {
|
|
@@ -25518,6 +25602,12 @@ declare const VDataTableVirtual: {
|
|
|
25518
25602
|
'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25519
25603
|
[key: string]: any;
|
|
25520
25604
|
}>[];
|
|
25605
|
+
'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25606
|
+
[key: string]: any;
|
|
25607
|
+
}>[];
|
|
25608
|
+
'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25609
|
+
[key: string]: any;
|
|
25610
|
+
}>[];
|
|
25521
25611
|
item: (arg: {
|
|
25522
25612
|
index: number;
|
|
25523
25613
|
item: any;
|
|
@@ -25553,30 +25643,6 @@ declare const VDataTableVirtual: {
|
|
|
25553
25643
|
loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25554
25644
|
[key: string]: any;
|
|
25555
25645
|
}>[];
|
|
25556
|
-
'header.data-table-select': (arg: {
|
|
25557
|
-
column: InternalDataTableHeader;
|
|
25558
|
-
selectAll: (value: boolean) => void;
|
|
25559
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
25560
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
25561
|
-
sortBy: readonly SortItem[];
|
|
25562
|
-
someSelected: boolean;
|
|
25563
|
-
allSelected: boolean;
|
|
25564
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
25565
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25566
|
-
[key: string]: any;
|
|
25567
|
-
}>[];
|
|
25568
|
-
'header.data-table-expand': (arg: {
|
|
25569
|
-
column: InternalDataTableHeader;
|
|
25570
|
-
selectAll: (value: boolean) => void;
|
|
25571
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
25572
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
25573
|
-
sortBy: readonly SortItem[];
|
|
25574
|
-
someSelected: boolean;
|
|
25575
|
-
allSelected: boolean;
|
|
25576
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
25577
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25578
|
-
[key: string]: any;
|
|
25579
|
-
}>[];
|
|
25580
25646
|
colgroup: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25581
25647
|
[key: string]: any;
|
|
25582
25648
|
}>[];
|
|
@@ -25605,6 +25671,7 @@ declare const VDataTableVirtual: {
|
|
|
25605
25671
|
noDataText: string;
|
|
25606
25672
|
loadingText: string;
|
|
25607
25673
|
sortBy: readonly SortItem[];
|
|
25674
|
+
mobile: boolean;
|
|
25608
25675
|
sticky: boolean;
|
|
25609
25676
|
expanded: readonly string[];
|
|
25610
25677
|
density: Density;
|
|
@@ -25634,6 +25701,7 @@ declare const VDataTableVirtual: {
|
|
|
25634
25701
|
theme?: string | undefined;
|
|
25635
25702
|
color?: string | undefined;
|
|
25636
25703
|
loading?: string | boolean | undefined;
|
|
25704
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
25637
25705
|
customFilter?: FilterFunction | undefined;
|
|
25638
25706
|
customKeyFilter?: FilterKeyFunctions | undefined;
|
|
25639
25707
|
filterKeys?: FilterKeys | undefined;
|
|
@@ -25659,6 +25727,7 @@ declare const VDataTableVirtual: {
|
|
|
25659
25727
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
25660
25728
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
25661
25729
|
readonly filter?: FilterFunction | undefined;
|
|
25730
|
+
readonly mobile?: boolean | undefined;
|
|
25662
25731
|
readonly children?: readonly {
|
|
25663
25732
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
25664
25733
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -25679,6 +25748,7 @@ declare const VDataTableVirtual: {
|
|
|
25679
25748
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
25680
25749
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
25681
25750
|
readonly filter?: FilterFunction | undefined;
|
|
25751
|
+
readonly mobile?: boolean | undefined;
|
|
25682
25752
|
readonly children?: readonly any[] | undefined;
|
|
25683
25753
|
}[] | undefined;
|
|
25684
25754
|
}[] | undefined;
|
|
@@ -25693,6 +25763,7 @@ declare const VDataTableVirtual: {
|
|
|
25693
25763
|
noDataText: string;
|
|
25694
25764
|
loadingText: string;
|
|
25695
25765
|
sortBy: readonly SortItem[];
|
|
25766
|
+
mobile: boolean;
|
|
25696
25767
|
sticky: boolean;
|
|
25697
25768
|
expanded: readonly string[];
|
|
25698
25769
|
density: Density;
|
|
@@ -25724,6 +25795,7 @@ declare const VDataTableVirtual: {
|
|
|
25724
25795
|
noDataText: string;
|
|
25725
25796
|
loadingText: string;
|
|
25726
25797
|
sortBy: readonly SortItem[];
|
|
25798
|
+
mobile: boolean;
|
|
25727
25799
|
sticky: boolean;
|
|
25728
25800
|
expanded: readonly string[];
|
|
25729
25801
|
density: Density;
|
|
@@ -25753,6 +25825,7 @@ declare const VDataTableVirtual: {
|
|
|
25753
25825
|
theme?: string | undefined;
|
|
25754
25826
|
color?: string | undefined;
|
|
25755
25827
|
loading?: string | boolean | undefined;
|
|
25828
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
25756
25829
|
customFilter?: FilterFunction | undefined;
|
|
25757
25830
|
customKeyFilter?: FilterKeyFunctions | undefined;
|
|
25758
25831
|
filterKeys?: FilterKeys | undefined;
|
|
@@ -25778,6 +25851,7 @@ declare const VDataTableVirtual: {
|
|
|
25778
25851
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
25779
25852
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
25780
25853
|
readonly filter?: FilterFunction | undefined;
|
|
25854
|
+
readonly mobile?: boolean | undefined;
|
|
25781
25855
|
readonly children?: readonly {
|
|
25782
25856
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
25783
25857
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -25798,6 +25872,7 @@ declare const VDataTableVirtual: {
|
|
|
25798
25872
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
25799
25873
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
25800
25874
|
readonly filter?: FilterFunction | undefined;
|
|
25875
|
+
readonly mobile?: boolean | undefined;
|
|
25801
25876
|
readonly children?: readonly any[] | undefined;
|
|
25802
25877
|
}[] | undefined;
|
|
25803
25878
|
}[] | undefined;
|
|
@@ -25818,6 +25893,7 @@ declare const VDataTableVirtual: {
|
|
|
25818
25893
|
noDataText: string;
|
|
25819
25894
|
loadingText: string;
|
|
25820
25895
|
sortBy: readonly SortItem[];
|
|
25896
|
+
mobile: boolean;
|
|
25821
25897
|
sticky: boolean;
|
|
25822
25898
|
expanded: readonly string[];
|
|
25823
25899
|
density: Density;
|
|
@@ -25843,16 +25919,7 @@ declare const VDataTableVirtual: {
|
|
|
25843
25919
|
[x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25844
25920
|
[key: string]: any;
|
|
25845
25921
|
}>[];
|
|
25846
|
-
[x: `header.${string}`]: (arg: {
|
|
25847
|
-
column: InternalDataTableHeader;
|
|
25848
|
-
selectAll: (value: boolean) => void;
|
|
25849
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
25850
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
25851
|
-
sortBy: readonly SortItem[];
|
|
25852
|
-
someSelected: boolean;
|
|
25853
|
-
allSelected: boolean;
|
|
25854
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
25855
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25922
|
+
[x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25856
25923
|
[key: string]: any;
|
|
25857
25924
|
}>[];
|
|
25858
25925
|
'data-table-group': (arg: {
|
|
@@ -25873,6 +25940,12 @@ declare const VDataTableVirtual: {
|
|
|
25873
25940
|
'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25874
25941
|
[key: string]: any;
|
|
25875
25942
|
}>[];
|
|
25943
|
+
'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25944
|
+
[key: string]: any;
|
|
25945
|
+
}>[];
|
|
25946
|
+
'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25947
|
+
[key: string]: any;
|
|
25948
|
+
}>[];
|
|
25876
25949
|
item: (arg: {
|
|
25877
25950
|
index: number;
|
|
25878
25951
|
item: any;
|
|
@@ -25908,30 +25981,6 @@ declare const VDataTableVirtual: {
|
|
|
25908
25981
|
loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25909
25982
|
[key: string]: any;
|
|
25910
25983
|
}>[];
|
|
25911
|
-
'header.data-table-select': (arg: {
|
|
25912
|
-
column: InternalDataTableHeader;
|
|
25913
|
-
selectAll: (value: boolean) => void;
|
|
25914
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
25915
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
25916
|
-
sortBy: readonly SortItem[];
|
|
25917
|
-
someSelected: boolean;
|
|
25918
|
-
allSelected: boolean;
|
|
25919
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
25920
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25921
|
-
[key: string]: any;
|
|
25922
|
-
}>[];
|
|
25923
|
-
'header.data-table-expand': (arg: {
|
|
25924
|
-
column: InternalDataTableHeader;
|
|
25925
|
-
selectAll: (value: boolean) => void;
|
|
25926
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
25927
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
25928
|
-
sortBy: readonly SortItem[];
|
|
25929
|
-
someSelected: boolean;
|
|
25930
|
-
allSelected: boolean;
|
|
25931
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
25932
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25933
|
-
[key: string]: any;
|
|
25934
|
-
}>[];
|
|
25935
25984
|
colgroup: (arg: VDataTableVirtualSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
25936
25985
|
[key: string]: any;
|
|
25937
25986
|
}>[];
|
|
@@ -26000,6 +26049,11 @@ declare const VDataTableVirtual: {
|
|
|
26000
26049
|
fixedFooter: BooleanConstructor;
|
|
26001
26050
|
hover: BooleanConstructor;
|
|
26002
26051
|
loading: (StringConstructor | BooleanConstructor)[];
|
|
26052
|
+
mobile: {
|
|
26053
|
+
type: BooleanConstructor;
|
|
26054
|
+
default: null;
|
|
26055
|
+
};
|
|
26056
|
+
mobileBreakpoint: vue.PropType<number | DisplayBreakpoint>;
|
|
26003
26057
|
color: StringConstructor;
|
|
26004
26058
|
sticky: BooleanConstructor;
|
|
26005
26059
|
multiSort: BooleanConstructor;
|
|
@@ -26068,6 +26122,7 @@ declare const VDataTableVirtual: {
|
|
|
26068
26122
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26069
26123
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26070
26124
|
readonly filter?: FilterFunction | undefined;
|
|
26125
|
+
readonly mobile?: boolean | undefined;
|
|
26071
26126
|
readonly children?: readonly {
|
|
26072
26127
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
26073
26128
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -26088,6 +26143,7 @@ declare const VDataTableVirtual: {
|
|
|
26088
26143
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26089
26144
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26090
26145
|
readonly filter?: FilterFunction | undefined;
|
|
26146
|
+
readonly mobile?: boolean | undefined;
|
|
26091
26147
|
readonly children?: readonly any[] | undefined;
|
|
26092
26148
|
}[] | undefined;
|
|
26093
26149
|
}[]>;
|
|
@@ -26145,6 +26201,11 @@ declare const VDataTableVirtual: {
|
|
|
26145
26201
|
fixedFooter: BooleanConstructor;
|
|
26146
26202
|
hover: BooleanConstructor;
|
|
26147
26203
|
loading: (StringConstructor | BooleanConstructor)[];
|
|
26204
|
+
mobile: {
|
|
26205
|
+
type: BooleanConstructor;
|
|
26206
|
+
default: null;
|
|
26207
|
+
};
|
|
26208
|
+
mobileBreakpoint: vue.PropType<number | DisplayBreakpoint>;
|
|
26148
26209
|
color: StringConstructor;
|
|
26149
26210
|
sticky: BooleanConstructor;
|
|
26150
26211
|
multiSort: BooleanConstructor;
|
|
@@ -26213,6 +26274,7 @@ declare const VDataTableVirtual: {
|
|
|
26213
26274
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26214
26275
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26215
26276
|
readonly filter?: FilterFunction | undefined;
|
|
26277
|
+
readonly mobile?: boolean | undefined;
|
|
26216
26278
|
readonly children?: readonly {
|
|
26217
26279
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
26218
26280
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -26233,6 +26295,7 @@ declare const VDataTableVirtual: {
|
|
|
26233
26295
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26234
26296
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26235
26297
|
readonly filter?: FilterFunction | undefined;
|
|
26298
|
+
readonly mobile?: boolean | undefined;
|
|
26236
26299
|
readonly children?: readonly any[] | undefined;
|
|
26237
26300
|
}[] | undefined;
|
|
26238
26301
|
}[]>;
|
|
@@ -26267,6 +26330,7 @@ declare const VDataTableServer: {
|
|
|
26267
26330
|
sortBy: readonly SortItem[];
|
|
26268
26331
|
pageText: string;
|
|
26269
26332
|
page: string | number;
|
|
26333
|
+
mobile: boolean;
|
|
26270
26334
|
sticky: boolean;
|
|
26271
26335
|
expanded: readonly string[];
|
|
26272
26336
|
density: Density;
|
|
@@ -26308,6 +26372,7 @@ declare const VDataTableServer: {
|
|
|
26308
26372
|
theme?: string | undefined;
|
|
26309
26373
|
color?: string | undefined;
|
|
26310
26374
|
loading?: string | boolean | undefined;
|
|
26375
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
26311
26376
|
customKeySort?: Record<string, DataTableCompareFunction> | undefined;
|
|
26312
26377
|
headerProps?: Record<string, any> | undefined;
|
|
26313
26378
|
headers?: readonly {
|
|
@@ -26330,6 +26395,7 @@ declare const VDataTableServer: {
|
|
|
26330
26395
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26331
26396
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26332
26397
|
readonly filter?: FilterFunction | undefined;
|
|
26398
|
+
readonly mobile?: boolean | undefined;
|
|
26333
26399
|
readonly children?: readonly {
|
|
26334
26400
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
26335
26401
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -26350,6 +26416,7 @@ declare const VDataTableServer: {
|
|
|
26350
26416
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26351
26417
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26352
26418
|
readonly filter?: FilterFunction | undefined;
|
|
26419
|
+
readonly mobile?: boolean | undefined;
|
|
26353
26420
|
readonly children?: readonly any[] | undefined;
|
|
26354
26421
|
}[] | undefined;
|
|
26355
26422
|
}[] | undefined;
|
|
@@ -26377,6 +26444,7 @@ declare const VDataTableServer: {
|
|
|
26377
26444
|
sortBy: readonly SortItem[];
|
|
26378
26445
|
pageText: string;
|
|
26379
26446
|
page: string | number;
|
|
26447
|
+
mobile: boolean;
|
|
26380
26448
|
sticky: boolean;
|
|
26381
26449
|
expanded: readonly string[];
|
|
26382
26450
|
density: Density;
|
|
@@ -26418,6 +26486,7 @@ declare const VDataTableServer: {
|
|
|
26418
26486
|
theme?: string | undefined;
|
|
26419
26487
|
color?: string | undefined;
|
|
26420
26488
|
loading?: string | boolean | undefined;
|
|
26489
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
26421
26490
|
customKeySort?: Record<string, DataTableCompareFunction> | undefined;
|
|
26422
26491
|
headerProps?: Record<string, any> | undefined;
|
|
26423
26492
|
headers?: readonly {
|
|
@@ -26440,6 +26509,7 @@ declare const VDataTableServer: {
|
|
|
26440
26509
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26441
26510
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26442
26511
|
readonly filter?: FilterFunction | undefined;
|
|
26512
|
+
readonly mobile?: boolean | undefined;
|
|
26443
26513
|
readonly children?: readonly {
|
|
26444
26514
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
26445
26515
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -26460,6 +26530,7 @@ declare const VDataTableServer: {
|
|
|
26460
26530
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26461
26531
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26462
26532
|
readonly filter?: FilterFunction | undefined;
|
|
26533
|
+
readonly mobile?: boolean | undefined;
|
|
26463
26534
|
readonly children?: readonly any[] | undefined;
|
|
26464
26535
|
}[] | undefined;
|
|
26465
26536
|
}[] | undefined;
|
|
@@ -26479,6 +26550,7 @@ declare const VDataTableServer: {
|
|
|
26479
26550
|
sortBy: readonly SortItem[];
|
|
26480
26551
|
pageText: string;
|
|
26481
26552
|
page: string | number;
|
|
26553
|
+
mobile: boolean;
|
|
26482
26554
|
sticky: boolean;
|
|
26483
26555
|
expanded: readonly string[];
|
|
26484
26556
|
density: Density;
|
|
@@ -26515,16 +26587,7 @@ declare const VDataTableServer: {
|
|
|
26515
26587
|
[x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26516
26588
|
[key: string]: any;
|
|
26517
26589
|
}>[];
|
|
26518
|
-
[x: `header.${string}`]: (arg: {
|
|
26519
|
-
column: InternalDataTableHeader;
|
|
26520
|
-
selectAll: (value: boolean) => void;
|
|
26521
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
26522
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
26523
|
-
sortBy: readonly SortItem[];
|
|
26524
|
-
someSelected: boolean;
|
|
26525
|
-
allSelected: boolean;
|
|
26526
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
26527
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26590
|
+
[x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26528
26591
|
[key: string]: any;
|
|
26529
26592
|
}>[];
|
|
26530
26593
|
'data-table-group': (arg: {
|
|
@@ -26545,6 +26608,12 @@ declare const VDataTableServer: {
|
|
|
26545
26608
|
'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26546
26609
|
[key: string]: any;
|
|
26547
26610
|
}>[];
|
|
26611
|
+
'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26612
|
+
[key: string]: any;
|
|
26613
|
+
}>[];
|
|
26614
|
+
'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26615
|
+
[key: string]: any;
|
|
26616
|
+
}>[];
|
|
26548
26617
|
item: (arg: {
|
|
26549
26618
|
index: number;
|
|
26550
26619
|
item: any;
|
|
@@ -26578,30 +26647,6 @@ declare const VDataTableServer: {
|
|
|
26578
26647
|
loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26579
26648
|
[key: string]: any;
|
|
26580
26649
|
}>[];
|
|
26581
|
-
'header.data-table-select': (arg: {
|
|
26582
|
-
column: InternalDataTableHeader;
|
|
26583
|
-
selectAll: (value: boolean) => void;
|
|
26584
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
26585
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
26586
|
-
sortBy: readonly SortItem[];
|
|
26587
|
-
someSelected: boolean;
|
|
26588
|
-
allSelected: boolean;
|
|
26589
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
26590
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26591
|
-
[key: string]: any;
|
|
26592
|
-
}>[];
|
|
26593
|
-
'header.data-table-expand': (arg: {
|
|
26594
|
-
column: InternalDataTableHeader;
|
|
26595
|
-
selectAll: (value: boolean) => void;
|
|
26596
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
26597
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
26598
|
-
sortBy: readonly SortItem[];
|
|
26599
|
-
someSelected: boolean;
|
|
26600
|
-
allSelected: boolean;
|
|
26601
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
26602
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26603
|
-
[key: string]: any;
|
|
26604
|
-
}>[];
|
|
26605
26650
|
default: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26606
26651
|
[key: string]: any;
|
|
26607
26652
|
}>[];
|
|
@@ -26651,6 +26696,7 @@ declare const VDataTableServer: {
|
|
|
26651
26696
|
sortBy: readonly SortItem[];
|
|
26652
26697
|
pageText: string;
|
|
26653
26698
|
page: string | number;
|
|
26699
|
+
mobile: boolean;
|
|
26654
26700
|
sticky: boolean;
|
|
26655
26701
|
expanded: readonly string[];
|
|
26656
26702
|
density: Density;
|
|
@@ -26692,6 +26738,7 @@ declare const VDataTableServer: {
|
|
|
26692
26738
|
theme?: string | undefined;
|
|
26693
26739
|
color?: string | undefined;
|
|
26694
26740
|
loading?: string | boolean | undefined;
|
|
26741
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
26695
26742
|
customKeySort?: Record<string, DataTableCompareFunction> | undefined;
|
|
26696
26743
|
headerProps?: Record<string, any> | undefined;
|
|
26697
26744
|
headers?: readonly {
|
|
@@ -26714,6 +26761,7 @@ declare const VDataTableServer: {
|
|
|
26714
26761
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26715
26762
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26716
26763
|
readonly filter?: FilterFunction | undefined;
|
|
26764
|
+
readonly mobile?: boolean | undefined;
|
|
26717
26765
|
readonly children?: readonly {
|
|
26718
26766
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
26719
26767
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -26734,6 +26782,7 @@ declare const VDataTableServer: {
|
|
|
26734
26782
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26735
26783
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26736
26784
|
readonly filter?: FilterFunction | undefined;
|
|
26785
|
+
readonly mobile?: boolean | undefined;
|
|
26737
26786
|
readonly children?: readonly any[] | undefined;
|
|
26738
26787
|
}[] | undefined;
|
|
26739
26788
|
}[] | undefined;
|
|
@@ -26753,6 +26802,7 @@ declare const VDataTableServer: {
|
|
|
26753
26802
|
sortBy: readonly SortItem[];
|
|
26754
26803
|
pageText: string;
|
|
26755
26804
|
page: string | number;
|
|
26805
|
+
mobile: boolean;
|
|
26756
26806
|
sticky: boolean;
|
|
26757
26807
|
expanded: readonly string[];
|
|
26758
26808
|
density: Density;
|
|
@@ -26798,6 +26848,7 @@ declare const VDataTableServer: {
|
|
|
26798
26848
|
sortBy: readonly SortItem[];
|
|
26799
26849
|
pageText: string;
|
|
26800
26850
|
page: string | number;
|
|
26851
|
+
mobile: boolean;
|
|
26801
26852
|
sticky: boolean;
|
|
26802
26853
|
expanded: readonly string[];
|
|
26803
26854
|
density: Density;
|
|
@@ -26839,6 +26890,7 @@ declare const VDataTableServer: {
|
|
|
26839
26890
|
theme?: string | undefined;
|
|
26840
26891
|
color?: string | undefined;
|
|
26841
26892
|
loading?: string | boolean | undefined;
|
|
26893
|
+
mobileBreakpoint?: number | DisplayBreakpoint | undefined;
|
|
26842
26894
|
customKeySort?: Record<string, DataTableCompareFunction> | undefined;
|
|
26843
26895
|
headerProps?: Record<string, any> | undefined;
|
|
26844
26896
|
headers?: readonly {
|
|
@@ -26861,6 +26913,7 @@ declare const VDataTableServer: {
|
|
|
26861
26913
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26862
26914
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26863
26915
|
readonly filter?: FilterFunction | undefined;
|
|
26916
|
+
readonly mobile?: boolean | undefined;
|
|
26864
26917
|
readonly children?: readonly {
|
|
26865
26918
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
26866
26919
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -26881,6 +26934,7 @@ declare const VDataTableServer: {
|
|
|
26881
26934
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
26882
26935
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
26883
26936
|
readonly filter?: FilterFunction | undefined;
|
|
26937
|
+
readonly mobile?: boolean | undefined;
|
|
26884
26938
|
readonly children?: readonly any[] | undefined;
|
|
26885
26939
|
}[] | undefined;
|
|
26886
26940
|
}[] | undefined;
|
|
@@ -26908,6 +26962,7 @@ declare const VDataTableServer: {
|
|
|
26908
26962
|
sortBy: readonly SortItem[];
|
|
26909
26963
|
pageText: string;
|
|
26910
26964
|
page: string | number;
|
|
26965
|
+
mobile: boolean;
|
|
26911
26966
|
sticky: boolean;
|
|
26912
26967
|
expanded: readonly string[];
|
|
26913
26968
|
density: Density;
|
|
@@ -26944,16 +26999,7 @@ declare const VDataTableServer: {
|
|
|
26944
26999
|
[x: `item.${string}`]: (arg: ItemKeySlot<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26945
27000
|
[key: string]: any;
|
|
26946
27001
|
}>[];
|
|
26947
|
-
[x: `header.${string}`]: (arg: {
|
|
26948
|
-
column: InternalDataTableHeader;
|
|
26949
|
-
selectAll: (value: boolean) => void;
|
|
26950
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
26951
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
26952
|
-
sortBy: readonly SortItem[];
|
|
26953
|
-
someSelected: boolean;
|
|
26954
|
-
allSelected: boolean;
|
|
26955
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
26956
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
27002
|
+
[x: `header.${string}`]: (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26957
27003
|
[key: string]: any;
|
|
26958
27004
|
}>[];
|
|
26959
27005
|
'data-table-group': (arg: {
|
|
@@ -26974,6 +27020,12 @@ declare const VDataTableServer: {
|
|
|
26974
27020
|
'item.data-table-expand': (arg: Omit<ItemKeySlot<any>, "value">) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
26975
27021
|
[key: string]: any;
|
|
26976
27022
|
}>[];
|
|
27023
|
+
'header.data-table-select': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
27024
|
+
[key: string]: any;
|
|
27025
|
+
}>[];
|
|
27026
|
+
'header.data-table-expand': (arg: VDataTableHeaderCellColumnSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
27027
|
+
[key: string]: any;
|
|
27028
|
+
}>[];
|
|
26977
27029
|
item: (arg: {
|
|
26978
27030
|
index: number;
|
|
26979
27031
|
item: any;
|
|
@@ -27007,30 +27059,6 @@ declare const VDataTableServer: {
|
|
|
27007
27059
|
loader: (arg: LoaderSlotProps) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
27008
27060
|
[key: string]: any;
|
|
27009
27061
|
}>[];
|
|
27010
|
-
'header.data-table-select': (arg: {
|
|
27011
|
-
column: InternalDataTableHeader;
|
|
27012
|
-
selectAll: (value: boolean) => void;
|
|
27013
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
27014
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
27015
|
-
sortBy: readonly SortItem[];
|
|
27016
|
-
someSelected: boolean;
|
|
27017
|
-
allSelected: boolean;
|
|
27018
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
27019
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
27020
|
-
[key: string]: any;
|
|
27021
|
-
}>[];
|
|
27022
|
-
'header.data-table-expand': (arg: {
|
|
27023
|
-
column: InternalDataTableHeader;
|
|
27024
|
-
selectAll: (value: boolean) => void;
|
|
27025
|
-
isSorted: (column: InternalDataTableHeader) => boolean;
|
|
27026
|
-
toggleSort: (column: InternalDataTableHeader) => void;
|
|
27027
|
-
sortBy: readonly SortItem[];
|
|
27028
|
-
someSelected: boolean;
|
|
27029
|
-
allSelected: boolean;
|
|
27030
|
-
getSortIcon: (column: InternalDataTableHeader) => IconValue;
|
|
27031
|
-
}) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
27032
|
-
[key: string]: any;
|
|
27033
|
-
}>[];
|
|
27034
27062
|
default: (arg: VDataTableSlotProps<any>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
|
|
27035
27063
|
[key: string]: any;
|
|
27036
27064
|
}>[];
|
|
@@ -27152,6 +27180,11 @@ declare const VDataTableServer: {
|
|
|
27152
27180
|
height: (StringConstructor | NumberConstructor)[];
|
|
27153
27181
|
hover: BooleanConstructor;
|
|
27154
27182
|
loading: (StringConstructor | BooleanConstructor)[];
|
|
27183
|
+
mobile: {
|
|
27184
|
+
type: BooleanConstructor;
|
|
27185
|
+
default: null;
|
|
27186
|
+
};
|
|
27187
|
+
mobileBreakpoint: vue.PropType<number | DisplayBreakpoint>;
|
|
27155
27188
|
color: StringConstructor;
|
|
27156
27189
|
sticky: BooleanConstructor;
|
|
27157
27190
|
multiSort: BooleanConstructor;
|
|
@@ -27220,6 +27253,7 @@ declare const VDataTableServer: {
|
|
|
27220
27253
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
27221
27254
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
27222
27255
|
readonly filter?: FilterFunction | undefined;
|
|
27256
|
+
readonly mobile?: boolean | undefined;
|
|
27223
27257
|
readonly children?: readonly {
|
|
27224
27258
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
27225
27259
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -27240,6 +27274,7 @@ declare const VDataTableServer: {
|
|
|
27240
27274
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
27241
27275
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
27242
27276
|
readonly filter?: FilterFunction | undefined;
|
|
27277
|
+
readonly mobile?: boolean | undefined;
|
|
27243
27278
|
readonly children?: readonly any[] | undefined;
|
|
27244
27279
|
}[] | undefined;
|
|
27245
27280
|
}[]>;
|
|
@@ -27348,6 +27383,11 @@ declare const VDataTableServer: {
|
|
|
27348
27383
|
height: (StringConstructor | NumberConstructor)[];
|
|
27349
27384
|
hover: BooleanConstructor;
|
|
27350
27385
|
loading: (StringConstructor | BooleanConstructor)[];
|
|
27386
|
+
mobile: {
|
|
27387
|
+
type: BooleanConstructor;
|
|
27388
|
+
default: null;
|
|
27389
|
+
};
|
|
27390
|
+
mobileBreakpoint: vue.PropType<number | DisplayBreakpoint>;
|
|
27351
27391
|
color: StringConstructor;
|
|
27352
27392
|
sticky: BooleanConstructor;
|
|
27353
27393
|
multiSort: BooleanConstructor;
|
|
@@ -27416,6 +27456,7 @@ declare const VDataTableServer: {
|
|
|
27416
27456
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
27417
27457
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
27418
27458
|
readonly filter?: FilterFunction | undefined;
|
|
27459
|
+
readonly mobile?: boolean | undefined;
|
|
27419
27460
|
readonly children?: readonly {
|
|
27420
27461
|
readonly key?: (string & {}) | "data-table-group" | "data-table-select" | "data-table-expand" | undefined;
|
|
27421
27462
|
readonly value?: SelectItemKey<Record<string, any>>;
|
|
@@ -27436,6 +27477,7 @@ declare const VDataTableServer: {
|
|
|
27436
27477
|
readonly sort?: DataTableCompareFunction<any> | undefined;
|
|
27437
27478
|
readonly sortRaw?: DataTableCompareFunction<any> | undefined;
|
|
27438
27479
|
readonly filter?: FilterFunction | undefined;
|
|
27480
|
+
readonly mobile?: boolean | undefined;
|
|
27439
27481
|
readonly children?: readonly any[] | undefined;
|
|
27440
27482
|
}[] | undefined;
|
|
27441
27483
|
}[]>;
|