pro-design-vue 0.0.1-beta.1

package/es/components/table/src/components/Body/Body.vue.d.ts

@@ -0,0 +1,2201 @@
+import type { PropType, CSSProperties } from 'vue';
+import type { SummaryFixed } from '../interface';
+import type { CustomSlotsType } from '../../utils/type';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    prefixCls: PropType<string>;
+    wrapText: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    bodyScrollWidth: {
+        type: PropType<number>;
+    };
+    bodyWidth: {
+        type: PropType<number>;
+    };
+    bodyHeight: {
+        type: PropType<number>;
+    };
+    height: {
+        type: PropType<number | string>;
+    };
+    scrollX: PropType<number | string>;
+    summaryFixed: PropType<boolean | SummaryFixed>;
+    emptyText: FunctionConstructor;
+    summary: FunctionConstructor;
+}>, {
+    bodyContainerStyle: import("vue").ComputedRef<CSSProperties>;
+    measureDomStyle: import("vue").ComputedRef<any>;
+    isEmpty: import("vue").ComputedRef<boolean>;
+    emptyStyle: import("vue").ComputedRef<CSSProperties>;
+    handleEmptyHeight: (e: CustomEvent) => void;
+    bodyClass: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    fixLeftClass: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    fixRightClass: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    centerClass: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    containerClass: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    summaryViewportClass: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    summaryClass: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    rightStyle: import("vue").ComputedRef<CSSProperties>;
+    centerStyle: import("vue").ComputedRef<CSSProperties>;
+    leftStyle: import("vue").ComputedRef<CSSProperties>;
+    summaryViewportStyle: import("vue").ComputedRef<CSSProperties>;
+    containerStyle: import("vue").ComputedRef<CSSProperties>;
+    summaryStyle: import("vue").ComputedRef<CSSProperties>;
+    viewportHeight: import("vue").ComputedRef<number>;
+    leftColumns: import("vue").ComputedRef<import("../interface").FinallyColumnType<import("../interface").DefaultRecordType>[]>;
+    centerColumns: import("vue").ComputedRef<import("../interface").FinallyColumnType<import("../interface").DefaultRecordType>[]>;
+    rightColumns: import("vue").ComputedRef<import("../interface").FinallyColumnType<import("../interface").DefaultRecordType>[]>;
+    bodyInnerWidth: import("vue").Ref<number, number>;
+    handleBodyInnerResize: (e: CustomEvent) => void;
+    handleBodyScrollResize: (e: CustomEvent) => void;
+    bodyRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    bodyInnerRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    viewportRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    summaryViewportRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    handleResize: (e: CustomEvent) => void;
+    bodyStyle: import("vue").ComputedRef<CSSProperties>;
+    handleBodyResize: (e: CustomEvent) => void;
+    emptyImage: any;
+    scrollLayerStyle: import("vue").ComputedRef<CSSProperties>;
+    getRowClassName: (record: any, index: number) => string;
+    showWatermark: import("vue").ComputedRef<boolean>;
+    leftPopupContainer: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    centerPopupContainer: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    rightPopupContainer: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    dragRowPlaceholderRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    leftShadowStyle: import("vue").ComputedRef<CSSProperties>;
+    rightShadowStyle: import("vue").ComputedRef<CSSProperties>;
+    fixedSummaryClass: import("vue").ComputedRef<(string | {
+        [x: string]: boolean;
+    })[]>;
+    scrollLayerRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    scrollbarStyle: import("vue").ComputedRef<CSSProperties>;
+    topSummaryStyle: import("vue").ComputedRef<CSSProperties>;
+    leftTarget: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    centerTarget: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    rightTarget: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    popupContent: import("vue").ShallowRef<any, any>;
+    popupContentPos: import("vue").Ref<string | null | undefined, string | null | undefined>;
+    handleContextmenuPopupResize: () => void;
+    handleDragStart: (e: MouseEvent) => false | undefined;
+    handleKeydown: (e: KeyboardEvent) => void;
+    bodyViewportStyle: import("vue").ComputedRef<CSSProperties>;
+    bodyViewportRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    bodyContainerRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    rowsHeightStyle: import("vue").ComputedRef<CSSProperties>;
+    showYScrollbar: import("vue").ComputedRef<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("keydown" | "scroll" | "scrollLeft" | "scrollTop" | "update:bodyWidth" | "update:bodyHeight" | "update:bodyScrollWidth")[], "keydown" | "scroll" | "scrollLeft" | "scrollTop" | "update:bodyWidth" | "update:bodyHeight" | "update:bodyScrollWidth", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    prefixCls: PropType<string>;
+    wrapText: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    bodyScrollWidth: {
+        type: PropType<number>;
+    };
+    bodyWidth: {
+        type: PropType<number>;
+    };
+    bodyHeight: {
+        type: PropType<number>;
+    };
+    height: {
+        type: PropType<number | string>;
+    };
+    scrollX: PropType<number | string>;
+    summaryFixed: PropType<boolean | SummaryFixed>;
+    emptyText: FunctionConstructor;
+    summary: FunctionConstructor;
+}>> & Readonly<{
+    onKeydown?: ((...args: any[]) => any) | undefined;
+    onScroll?: ((...args: any[]) => any) | undefined;
+    onScrollLeft?: ((...args: any[]) => any) | undefined;
+    onScrollTop?: ((...args: any[]) => any) | undefined;
+    "onUpdate:bodyWidth"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:bodyHeight"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:bodyScrollWidth"?: ((...args: any[]) => any) | undefined;
+}>, {
+    wrapText: boolean;
+}, CustomSlotsType<{
+    emptyText: any;
+    default: any;
+}>, {
+    BodyRows: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        prefixCls: PropType<string>;
+        type: {
+            type: PropType<import("../interface").RowType>;
+        };
+        wrapText: {
+            type: PropType<boolean>;
+            default: boolean;
+        };
+        getRowClassName: {
+            type: PropType<import("../interface").RowClassName<any>>;
+        };
+    }>, {
+        data: import("vue").ComputedRef<any[]>;
+        columns: import("vue").ShallowRef<import("../interface").FinallyColumnType<import("../interface").DefaultRecordType>[], import("../interface").FinallyColumnType<import("../interface").DefaultRecordType>[]>;
+        rowPosition: import("vue").ComputedRef<number[]>;
+        transitionName: import("vue").ComputedRef<string>;
+        virtual: import("vue").ComputedRef<boolean>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        prefixCls: PropType<string>;
+        type: {
+            type: PropType<import("../interface").RowType>;
+        };
+        wrapText: {
+            type: PropType<boolean>;
+            default: boolean;
+        };
+        getRowClassName: {
+            type: PropType<import("../interface").RowClassName<any>>;
+        };
+    }>> & Readonly<{}>, {
+        wrapText: boolean;
+    }, {}, {
+        Row: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            prefixCls: PropType<string>;
+            isExpandRow: PropType<boolean>;
+            record: {
+                type: ObjectConstructor;
+            };
+            type: {
+                type: PropType<import("../interface").RowType>;
+            };
+            rowKey: {
+                type: PropType<import("pro-design-vue").ProTableKey>;
+                required: true;
+            };
+            supportExpand: BooleanConstructor;
+            pos: PropType<number>;
+            rowIndex: PropType<number>;
+            flattenRowIndex: NumberConstructor;
+            indent: PropType<number>;
+            wrapText: {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+            getRowClassName: {
+                type: PropType<import("../interface").RowClassName<any>>;
+            };
+        }>, {
+            rowClass: import("vue").ComputedRef<string>;
+            rowStyle: import("vue").ComputedRef<CSSProperties>;
+            cellClass: import("vue").ComputedRef<{
+                [x: string]: boolean;
+            }>;
+            tableContext: import("../context/TableContext").TableContextProps;
+            mergedRowHeights: import("vue").ComputedRef<Record<import("pro-design-vue").ProTableKey, number>>;
+            handleCellBlur: () => void;
+            handleCellHover: (rowKey: import("pro-design-vue").ProTableKey, columnKey: import("pro-design-vue").ProTableKey, draggingRowKey: import("pro-design-vue").ProTableKey) => void;
+            handleClick: (event: any) => void;
+            rowSelectionType: import("vue").ComputedRef<import("../interface").RowSelectionType | undefined>;
+            nestExpandable: import("vue").ComputedRef<boolean>;
+            hasNestChildren: import("vue").ComputedRef<boolean>;
+            mergedExpandable: import("vue").ComputedRef<boolean>;
+            expandIconColumnIndex: import("vue").ComputedRef<number>;
+            indentSize: import("vue").ComputedRef<number>;
+            expanded: import("vue").ComputedRef<boolean>;
+            onInternalTriggerExpand: (record: any, event: any) => void;
+            customRowProps: import("vue").ComputedRef<(Omit<import("vue").HTMLAttributes, "style"> & {
+                style?: CSSProperties;
+            }) | undefined>;
+            expandColumnKey: string;
+            expandRowClass: import("vue").ComputedRef<string>;
+            mergedColumns: import("vue").ComputedRef<import("../interface").FinallyColumnType<import("../interface").DefaultRecordType>[]>;
+            height: import("vue").ComputedRef<number | undefined>;
+            cellHeight: import("vue").ComputedRef<number | undefined>;
+            columnStartIndex: import("vue").Ref<number, number>;
+            resizeObserver: import("resize-observer-polyfill").default;
+            calMaxHeight: () => void;
+            bodyRow: import("vue").Ref<any, any>;
+            hoverRowKey: import("vue").Ref<import("pro-design-vue").ProTableKey, import("pro-design-vue").ProTableKey>;
+            hoverColumnKey: import("vue").Ref<import("pro-design-vue").ProTableKey, import("pro-design-vue").ProTableKey>;
+            xVirtual: import("vue").ComputedRef<boolean>;
+            getPopupContainer: () => HTMLDivElement;
+            editCellKeys: import("vue").Ref<string[], string[]>;
+            closeEditor: (key?: string | string[]) => void;
+            openEditor: (key: string | string[], values?: Record<string, any>) => void;
+            mergedTooltipOpen: import("vue").ComputedRef<boolean>;
+            onCellMousedown: (mouseEvent: import("../../hooks/RangeInterface.ts").CustomMouseEvent, cellPosition: import("../../hooks/RangeInterface.ts").RangeCell) => void;
+            onCellKeydown: (event: KeyboardEvent, payload: import("../../hooks/RangeInterface.ts").InnerKeydownPayload) => void;
+            onCellMousemove: (mouseEvent: import("../../hooks/RangeInterface.ts").CustomMouseEvent, cellPosition: import("../../hooks/RangeInterface.ts").RangeCell) => void;
+            onCellClick: (mouseEvent: MouseEvent, cellPosition: import("../../hooks/RangeInterface.ts").RangeCell) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            prefixCls: PropType<string>;
+            isExpandRow: PropType<boolean>;
+            record: {
+                type: ObjectConstructor;
+            };
+            type: {
+                type: PropType<import("../interface").RowType>;
+            };
+            rowKey: {
+                type: PropType<import("pro-design-vue").ProTableKey>;
+                required: true;
+            };
+            supportExpand: BooleanConstructor;
+            pos: PropType<number>;
+            rowIndex: PropType<number>;
+            flattenRowIndex: NumberConstructor;
+            indent: PropType<number>;
+            wrapText: {
+                type: PropType<boolean>;
+                default: boolean;
+            };
+            getRowClassName: {
+                type: PropType<import("../interface").RowClassName<any>>;
+            };
+        }>> & Readonly<{}>, {
+            wrapText: boolean;
+            supportExpand: boolean;
+        }, {}, {
+            ExpandIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                prefixCls: StringConstructor;
+                record: ObjectConstructor;
+                expanded: BooleanConstructor;
+                expandable: BooleanConstructor;
+                disabled: BooleanConstructor;
+                onExpand: FunctionConstructor;
+            }>, {
+                handleClick: () => void;
+                className: import("vue").ComputedRef<{
+                    [x: string]: boolean;
+                }>;
+                label: import("vue").ComputedRef<string | undefined>;
+                expandIcon: import("vue").ComputedRef<import("../interface").RenderExpandIcon<import("../interface").DefaultRecordType> | undefined>;
+                props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                    prefixCls: StringConstructor;
+                    record: ObjectConstructor;
+                    expanded: BooleanConstructor;
+                    expandable: BooleanConstructor;
+                    disabled: BooleanConstructor;
+                    onExpand: FunctionConstructor;
+                }>> & Readonly<{
+                    onExpand?: ((...args: any[]) => any) | undefined;
+                }> & {}>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "expand"[], "expand", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                prefixCls: StringConstructor;
+                record: ObjectConstructor;
+                expanded: BooleanConstructor;
+                expandable: BooleanConstructor;
+                disabled: BooleanConstructor;
+                onExpand: FunctionConstructor;
+            }>> & Readonly<{
+                onExpand?: ((...args: any[]) => any) | undefined;
+            }>, {
+                disabled: boolean;
+                expanded: boolean;
+                expandable: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            BodyCell: import("vue").FunctionalComponent<Partial<import("vue").ExtractPropTypes<{
+                prefixCls: PropType<string>;
+                rowIndex: {
+                    type: PropType<number>;
+                    required: boolean;
+                };
+                flattenRowIndex: {
+                    type: NumberConstructor;
+                    required: boolean;
+                };
+                rowKey: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                column: {
+                    type: PropType<import("../interface").FinallyColumnType>;
+                    default: () => {};
+                };
+                item: {
+                    type: PropType<any>;
+                    default: () => {};
+                };
+                wrapText: {
+                    type: PropType<boolean>;
+                    default: boolean;
+                };
+                type: {
+                    type: PropType<import("../interface").RowType>;
+                };
+                height: PropType<number>;
+                hasAppendNode: PropType<boolean>;
+                resizeObserver: {
+                    type: PropType<ResizeObserver>;
+                };
+                calMaxHeight: FunctionConstructor;
+                tooltipOpen: PropType<boolean>;
+                getPopupContainer: PropType<() => HTMLElement>;
+                onCellLeave: FunctionConstructor;
+                editCellKeys: PropType<string[]>;
+                onOpenEditor: FunctionConstructor;
+                onCloseEditor: FunctionConstructor;
+                onMousedown: PropType<(e: any, cellPosition: import("../../hooks/RangeInterface.ts").RangeCell) => void>;
+                onMousemove: PropType<(e: any, cellPosition: import("../../hooks/RangeInterface.ts").RangeCell) => void>;
+                onKeydown: PropType<(e: KeyboardEvent, payload: import("../../hooks/RangeInterface.ts").InnerKeydownPayload) => void>;
+                onClick: PropType<(e: MouseEvent, cellPosition: import("../../hooks/RangeInterface.ts").RangeCell) => void>;
+            }>>, {}, any, {}>;
+            ExpandedRow: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                prefixCls: StringConstructor;
+                rowKey: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                item: {
+                    type: ObjectConstructor;
+                    default: () => {};
+                };
+                rowIndex: NumberConstructor;
+                resizeObserver: {
+                    type: PropType<ResizeObserver>;
+                };
+                calMaxHeight: FunctionConstructor;
+            }>, {
+                cellClass: import("vue").ComputedRef<{
+                    [x: string]: boolean;
+                }>;
+                tableSlotsContext: import("../context/TableSlotsContext").ContextSlots;
+                mergedCellProps: import("vue").ComputedRef<{
+                    style: {
+                        minWidth: string;
+                        accentColor?: import("csstype").AccentColorProperty;
+                        alignContent?: import("csstype").AlignContentProperty;
+                        alignItems?: import("csstype").AlignItemsProperty;
+                        alignSelf?: import("csstype").AlignSelfProperty;
+                        alignTracks?: import("csstype").AlignTracksProperty;
+                        animationComposition?: import("csstype").GlobalsString;
+                        animationDelay?: import("csstype").GlobalsString;
+                        animationDirection?: import("csstype").AnimationDirectionProperty;
+                        animationDuration?: import("csstype").GlobalsString;
+                        animationFillMode?: import("csstype").AnimationFillModeProperty;
+                        animationIterationCount?: import("csstype").AnimationIterationCountProperty;
+                        animationName?: import("csstype").AnimationNameProperty;
+                        animationPlayState?: import("csstype").AnimationPlayStateProperty;
+                        animationTimeline?: import("csstype").AnimationTimelineProperty;
+                        animationTimingFunction?: import("csstype").AnimationTimingFunctionProperty;
+                        appearance?: import("csstype").AppearanceProperty;
+                        aspectRatio?: import("csstype").AspectRatioProperty;
+                        backdropFilter?: import("csstype").BackdropFilterProperty;
+                        backfaceVisibility?: import("csstype").BackfaceVisibilityProperty;
+                        backgroundAttachment?: import("csstype").BackgroundAttachmentProperty;
+                        backgroundBlendMode?: import("csstype").BackgroundBlendModeProperty;
+                        backgroundClip?: import("csstype").BackgroundClipProperty;
+                        backgroundColor?: import("csstype").BackgroundColorProperty;
+                        backgroundImage?: import("csstype").BackgroundImageProperty;
+                        backgroundOrigin?: import("csstype").BackgroundOriginProperty;
+                        backgroundPositionX?: import("csstype").BackgroundPositionXProperty<string | number> | undefined;
+                        backgroundPositionY?: import("csstype").BackgroundPositionYProperty<string | number> | undefined;
+                        backgroundRepeat?: import("csstype").BackgroundRepeatProperty;
+                        backgroundSize?: import("csstype").BackgroundSizeProperty<string | number> | undefined;
+                        blockOverflow?: import("csstype").BlockOverflowProperty;
+                        blockSize?: import("csstype").BlockSizeProperty<string | number> | undefined;
+                        borderBlockColor?: import("csstype").BorderBlockColorProperty;
+                        borderBlockEndColor?: import("csstype").BorderBlockEndColorProperty;
+                        borderBlockEndStyle?: import("csstype").BorderBlockEndStyleProperty;
+                        borderBlockEndWidth?: import("csstype").BorderBlockEndWidthProperty<string | number> | undefined;
+                        borderBlockStartColor?: import("csstype").BorderBlockStartColorProperty;
+                        borderBlockStartStyle?: import("csstype").BorderBlockStartStyleProperty;
+                        borderBlockStartWidth?: import("csstype").BorderBlockStartWidthProperty<string | number> | undefined;
+                        borderBlockStyle?: import("csstype").BorderBlockStyleProperty;
+                        borderBlockWidth?: import("csstype").BorderBlockWidthProperty<string | number> | undefined;
+                        borderBottomColor?: import("csstype").BorderBottomColorProperty;
+                        borderBottomLeftRadius?: import("csstype").BorderBottomLeftRadiusProperty<string | number> | undefined;
+                        borderBottomRightRadius?: import("csstype").BorderBottomRightRadiusProperty<string | number> | undefined;
+                        borderBottomStyle?: import("csstype").BorderBottomStyleProperty;
+                        borderBottomWidth?: import("csstype").BorderBottomWidthProperty<string | number> | undefined;
+                        borderCollapse?: import("csstype").BorderCollapseProperty;
+                        borderEndEndRadius?: import("csstype").BorderEndEndRadiusProperty<string | number> | undefined;
+                        borderEndStartRadius?: import("csstype").BorderEndStartRadiusProperty<string | number> | undefined;
+                        borderImageOutset?: import("csstype").BorderImageOutsetProperty<string | number> | undefined;
+                        borderImageRepeat?: import("csstype").BorderImageRepeatProperty;
+                        borderImageSlice?: import("csstype").BorderImageSliceProperty;
+                        borderImageSource?: import("csstype").BorderImageSourceProperty;
+                        borderImageWidth?: import("csstype").BorderImageWidthProperty<string | number> | undefined;
+                        borderInlineColor?: import("csstype").BorderInlineColorProperty;
+                        borderInlineEndColor?: import("csstype").BorderInlineEndColorProperty;
+                        borderInlineEndStyle?: import("csstype").BorderInlineEndStyleProperty;
+                        borderInlineEndWidth?: import("csstype").BorderInlineEndWidthProperty<string | number> | undefined;
+                        borderInlineStartColor?: import("csstype").BorderInlineStartColorProperty;
+                        borderInlineStartStyle?: import("csstype").BorderInlineStartStyleProperty;
+                        borderInlineStartWidth?: import("csstype").BorderInlineStartWidthProperty<string | number> | undefined;
+                        borderInlineStyle?: import("csstype").BorderInlineStyleProperty;
+                        borderInlineWidth?: import("csstype").BorderInlineWidthProperty<string | number> | undefined;
+                        borderLeftColor?: import("csstype").BorderLeftColorProperty;
+                        borderLeftStyle?: import("csstype").BorderLeftStyleProperty;
+                        borderLeftWidth?: import("csstype").BorderLeftWidthProperty<string | number> | undefined;
+                        borderRightColor?: import("csstype").BorderRightColorProperty;
+                        borderRightStyle?: import("csstype").BorderRightStyleProperty;
+                        borderRightWidth?: import("csstype").BorderRightWidthProperty<string | number> | undefined;
+                        borderSpacing?: import("csstype").BorderSpacingProperty<string | number> | undefined;
+                        borderStartEndRadius?: import("csstype").BorderStartEndRadiusProperty<string | number> | undefined;
+                        borderStartStartRadius?: import("csstype").BorderStartStartRadiusProperty<string | number> | undefined;
+                        borderTopColor?: import("csstype").BorderTopColorProperty;
+                        borderTopLeftRadius?: import("csstype").BorderTopLeftRadiusProperty<string | number> | undefined;
+                        borderTopRightRadius?: import("csstype").BorderTopRightRadiusProperty<string | number> | undefined;
+                        borderTopStyle?: import("csstype").BorderTopStyleProperty;
+                        borderTopWidth?: import("csstype").BorderTopWidthProperty<string | number> | undefined;
+                        bottom?: import("csstype").BottomProperty<string | number> | undefined;
+                        boxDecorationBreak?: import("csstype").BoxDecorationBreakProperty;
+                        boxShadow?: import("csstype").BoxShadowProperty;
+                        boxSizing?: import("csstype").BoxSizingProperty;
+                        breakAfter?: import("csstype").BreakAfterProperty;
+                        breakBefore?: import("csstype").BreakBeforeProperty;
+                        breakInside?: import("csstype").BreakInsideProperty;
+                        captionSide?: import("csstype").CaptionSideProperty;
+                        caretColor?: import("csstype").CaretColorProperty;
+                        clear?: import("csstype").ClearProperty;
+                        clipPath?: import("csstype").ClipPathProperty;
+                        color?: import("csstype").ColorProperty;
+                        colorAdjust?: import("csstype").PrintColorAdjustProperty;
+                        colorScheme?: import("csstype").ColorSchemeProperty;
+                        columnCount?: import("csstype").ColumnCountProperty;
+                        columnFill?: import("csstype").ColumnFillProperty;
+                        columnGap?: import("csstype").ColumnGapProperty<string | number> | undefined;
+                        columnRuleColor?: import("csstype").ColumnRuleColorProperty;
+                        columnRuleStyle?: import("csstype").ColumnRuleStyleProperty;
+                        columnRuleWidth?: import("csstype").ColumnRuleWidthProperty<string | number> | undefined;
+                        columnSpan?: import("csstype").ColumnSpanProperty;
+                        columnWidth?: import("csstype").ColumnWidthProperty<string | number> | undefined;
+                        contain?: import("csstype").ContainProperty;
+                        content?: import("csstype").ContentProperty;
+                        contentVisibility?: import("csstype").ContentVisibilityProperty;
+                        counterIncrement?: import("csstype").CounterIncrementProperty;
+                        counterReset?: import("csstype").CounterResetProperty;
+                        counterSet?: import("csstype").CounterSetProperty;
+                        cursor?: import("csstype").CursorProperty;
+                        direction?: import("csstype").DirectionProperty;
+                        display?: import("csstype").DisplayProperty;
+                        emptyCells?: import("csstype").EmptyCellsProperty;
+                        filter?: import("csstype").FilterProperty;
+                        flexBasis?: import("csstype").FlexBasisProperty<string | number> | undefined;
+                        flexDirection?: import("csstype").FlexDirectionProperty;
+                        flexGrow?: import("csstype").GlobalsNumber;
+                        flexShrink?: import("csstype").GlobalsNumber;
+                        flexWrap?: import("csstype").FlexWrapProperty;
+                        float?: import("csstype").FloatProperty;
+                        fontFamily?: import("csstype").FontFamilyProperty;
+                        fontFeatureSettings?: import("csstype").FontFeatureSettingsProperty;
+                        fontKerning?: import("csstype").FontKerningProperty;
+                        fontLanguageOverride?: import("csstype").FontLanguageOverrideProperty;
+                        fontOpticalSizing?: import("csstype").FontOpticalSizingProperty;
+                        fontSize?: import("csstype").FontSizeProperty<string | number> | undefined;
+                        fontSizeAdjust?: import("csstype").FontSizeAdjustProperty;
+                        fontSmooth?: import("csstype").FontSmoothProperty<string | number> | undefined;
+                        fontStretch?: import("csstype").FontStretchProperty;
+                        fontStyle?: import("csstype").FontStyleProperty;
+                        fontSynthesis?: import("csstype").FontSynthesisProperty;
+                        fontVariant?: import("csstype").FontVariantProperty;
+                        fontVariantAlternates?: import("csstype").FontVariantAlternatesProperty;
+                        fontVariantCaps?: import("csstype").FontVariantCapsProperty;
+                        fontVariantEastAsian?: import("csstype").FontVariantEastAsianProperty;
+                        fontVariantLigatures?: import("csstype").FontVariantLigaturesProperty;
+                        fontVariantNumeric?: import("csstype").FontVariantNumericProperty;
+                        fontVariantPosition?: import("csstype").FontVariantPositionProperty;
+                        fontVariationSettings?: import("csstype").FontVariationSettingsProperty;
+                        fontWeight?: import("csstype").FontWeightProperty;
+                        forcedColorAdjust?: import("csstype").ForcedColorAdjustProperty;
+                        gridAutoColumns?: import("csstype").GridAutoColumnsProperty<string | number> | undefined;
+                        gridAutoFlow?: import("csstype").GridAutoFlowProperty;
+                        gridAutoRows?: import("csstype").GridAutoRowsProperty<string | number> | undefined;
+                        gridColumnEnd?: import("csstype").GridColumnEndProperty;
+                        gridColumnStart?: import("csstype").GridColumnStartProperty;
+                        gridRowEnd?: import("csstype").GridRowEndProperty;
+                        gridRowStart?: import("csstype").GridRowStartProperty;
+                        gridTemplateAreas?: import("csstype").GridTemplateAreasProperty;
+                        gridTemplateColumns?: import("csstype").GridTemplateColumnsProperty<string | number> | undefined;
+                        gridTemplateRows?: import("csstype").GridTemplateRowsProperty<string | number> | undefined;
+                        hangingPunctuation?: import("csstype").HangingPunctuationProperty;
+                        height?: import("csstype").HeightProperty<string | number> | undefined;
+                        hyphenateCharacter?: import("csstype").HyphenateCharacterProperty;
+                        hyphens?: import("csstype").HyphensProperty;
+                        imageOrientation?: import("csstype").ImageOrientationProperty;
+                        imageRendering?: import("csstype").ImageRenderingProperty;
+                        imageResolution?: import("csstype").ImageResolutionProperty;
+                        initialLetter?: import("csstype").InitialLetterProperty;
+                        inlineSize?: import("csstype").InlineSizeProperty<string | number> | undefined;
+                        inputSecurity?: import("csstype").InputSecurityProperty;
+                        inset?: import("csstype").InsetProperty<string | number> | undefined;
+                        insetBlock?: import("csstype").InsetBlockProperty<string | number> | undefined;
+                        insetBlockEnd?: import("csstype").InsetBlockEndProperty<string | number> | undefined;
+                        insetBlockStart?: import("csstype").InsetBlockStartProperty<string | number> | undefined;
+                        insetInline?: import("csstype").InsetInlineProperty<string | number> | undefined;
+                        insetInlineEnd?: import("csstype").InsetInlineEndProperty<string | number> | undefined;
+                        insetInlineStart?: import("csstype").InsetInlineStartProperty<string | number> | undefined;
+                        isolation?: import("csstype").IsolationProperty;
+                        justifyContent?: import("csstype").JustifyContentProperty;
+                        justifyItems?: import("csstype").JustifyItemsProperty;
+                        justifySelf?: import("csstype").JustifySelfProperty;
+                        justifyTracks?: import("csstype").JustifyTracksProperty;
+                        left?: import("csstype").LeftProperty<string | number> | undefined;
+                        letterSpacing?: import("csstype").LetterSpacingProperty<string | number> | undefined;
+                        lineBreak?: import("csstype").LineBreakProperty;
+                        lineHeight?: import("csstype").LineHeightProperty<string | number> | undefined;
+                        lineHeightStep?: import("csstype").LineHeightStepProperty<string | number> | undefined;
+                        listStyleImage?: import("csstype").ListStyleImageProperty;
+                        listStylePosition?: import("csstype").ListStylePositionProperty;
+                        listStyleType?: import("csstype").ListStyleTypeProperty;
+                        marginBlock?: import("csstype").MarginBlockProperty<string | number> | undefined;
+                        marginBlockEnd?: import("csstype").MarginBlockEndProperty<string | number> | undefined;
+                        marginBlockStart?: import("csstype").MarginBlockStartProperty<string | number> | undefined;
+                        marginBottom?: import("csstype").MarginBottomProperty<string | number> | undefined;
+                        marginInline?: import("csstype").MarginInlineProperty<string | number> | undefined;
+                        marginInlineEnd?: import("csstype").MarginInlineEndProperty<string | number> | undefined;
+                        marginInlineStart?: import("csstype").MarginInlineStartProperty<string | number> | undefined;
+                        marginLeft?: import("csstype").MarginLeftProperty<string | number> | undefined;
+                        marginRight?: import("csstype").MarginRightProperty<string | number> | undefined;
+                        marginTop?: import("csstype").MarginTopProperty<string | number> | undefined;
+                        maskBorderMode?: import("csstype").MaskBorderModeProperty;
+                        maskBorderOutset?: import("csstype").MaskBorderOutsetProperty<string | number> | undefined;
+                        maskBorderRepeat?: import("csstype").MaskBorderRepeatProperty;
+                        maskBorderSlice?: import("csstype").MaskBorderSliceProperty;
+                        maskBorderSource?: import("csstype").MaskBorderSourceProperty;
+                        maskBorderWidth?: import("csstype").MaskBorderWidthProperty<string | number> | undefined;
+                        maskClip?: import("csstype").MaskClipProperty;
+                        maskComposite?: import("csstype").MaskCompositeProperty;
+                        maskImage?: import("csstype").MaskImageProperty;
+                        maskMode?: import("csstype").MaskModeProperty;
+                        maskOrigin?: import("csstype").MaskOriginProperty;
+                        maskPosition?: import("csstype").MaskPositionProperty<string | number> | undefined;
+                        maskRepeat?: import("csstype").MaskRepeatProperty;
+                        maskSize?: import("csstype").MaskSizeProperty<string | number> | undefined;
+                        maskType?: import("csstype").MaskTypeProperty;
+                        mathDepth?: import("csstype").MathDepthProperty;
+                        mathShift?: import("csstype").MathShiftProperty;
+                        mathStyle?: import("csstype").MathStyleProperty;
+                        maxBlockSize?: import("csstype").MaxBlockSizeProperty<string | number> | undefined;
+                        maxHeight?: import("csstype").MaxHeightProperty<string | number> | undefined;
+                        maxInlineSize?: import("csstype").MaxInlineSizeProperty<string | number> | undefined;
+                        maxLines?: import("csstype").MaxLinesProperty;
+                        maxWidth?: import("csstype").MaxWidthProperty<string | number> | undefined;
+                        minBlockSize?: import("csstype").MinBlockSizeProperty<string | number> | undefined;
+                        minHeight?: import("csstype").MinHeightProperty<string | number> | undefined;
+                        minInlineSize?: import("csstype").MinInlineSizeProperty<string | number> | undefined;
+                        mixBlendMode?: import("csstype").MixBlendModeProperty;
+                        motionDistance?: import("csstype").OffsetDistanceProperty<string | number> | undefined;
+                        motionPath?: import("csstype").OffsetPathProperty;
+                        motionRotation?: import("csstype").OffsetRotateProperty;
+                        objectFit?: import("csstype").ObjectFitProperty;
+                        objectPosition?: import("csstype").ObjectPositionProperty<string | number> | undefined;
+                        offsetAnchor?: import("csstype").OffsetAnchorProperty<string | number> | undefined;
+                        offsetDistance?: import("csstype").OffsetDistanceProperty<string | number> | undefined;
+                        offsetPath?: import("csstype").OffsetPathProperty;
+                        offsetRotate?: import("csstype").OffsetRotateProperty;
+                        offsetRotation?: import("csstype").OffsetRotateProperty;
+                        opacity?: import("csstype").OpacityProperty;
+                        order?: import("csstype").GlobalsNumber;
+                        orphans?: import("csstype").GlobalsNumber;
+                        outlineColor?: import("csstype").OutlineColorProperty;
+                        outlineOffset?: import("csstype").OutlineOffsetProperty<string | number> | undefined;
+                        outlineStyle?: import("csstype").OutlineStyleProperty;
+                        outlineWidth?: import("csstype").OutlineWidthProperty<string | number> | undefined;
+                        overflowAnchor?: import("csstype").OverflowAnchorProperty;
+                        overflowBlock?: import("csstype").OverflowBlockProperty;
+                        overflowClipBox?: import("csstype").OverflowClipBoxProperty;
+                        overflowClipMargin?: import("csstype").OverflowClipMarginProperty<string | number> | undefined;
+                        overflowInline?: import("csstype").OverflowInlineProperty;
+                        overflowWrap?: import("csstype").OverflowWrapProperty;
+                        overflowX?: import("csstype").OverflowXProperty;
+                        overflowY?: import("csstype").OverflowYProperty;
+                        overscrollBehaviorBlock?: import("csstype").OverscrollBehaviorBlockProperty;
+                        overscrollBehaviorInline?: import("csstype").OverscrollBehaviorInlineProperty;
+                        overscrollBehaviorX?: import("csstype").OverscrollBehaviorXProperty;
+                        overscrollBehaviorY?: import("csstype").OverscrollBehaviorYProperty;
+                        paddingBlock?: import("csstype").PaddingBlockProperty<string | number> | undefined;
+                        paddingBlockEnd?: import("csstype").PaddingBlockEndProperty<string | number> | undefined;
+                        paddingBlockStart?: import("csstype").PaddingBlockStartProperty<string | number> | undefined;
+                        paddingBottom?: import("csstype").PaddingBottomProperty<string | number> | undefined;
+                        paddingInline?: import("csstype").PaddingInlineProperty<string | number> | undefined;
+                        paddingInlineEnd?: import("csstype").PaddingInlineEndProperty<string | number> | undefined;
+                        paddingInlineStart?: import("csstype").PaddingInlineStartProperty<string | number> | undefined;
+                        paddingLeft?: import("csstype").PaddingLeftProperty<string | number> | undefined;
+                        paddingRight?: import("csstype").PaddingRightProperty<string | number> | undefined;
+                        paddingTop?: import("csstype").PaddingTopProperty<string | number> | undefined;
+                        pageBreakAfter?: import("csstype").PageBreakAfterProperty;
+                        pageBreakBefore?: import("csstype").PageBreakBeforeProperty;
+                        pageBreakInside?: import("csstype").PageBreakInsideProperty;
+                        paintOrder?: import("csstype").PaintOrderProperty;
+                        perspective?: import("csstype").PerspectiveProperty<string | number> | undefined;
+                        perspectiveOrigin?: import("csstype").PerspectiveOriginProperty<string | number> | undefined;
+                        placeContent?: import("csstype").PlaceContentProperty;
+                        pointerEvents?: import("csstype").PointerEventsProperty;
+                        position?: import("csstype").PositionProperty;
+                        printColorAdjust?: import("csstype").PrintColorAdjustProperty;
+                        quotes?: import("csstype").QuotesProperty;
+                        resize?: import("csstype").ResizeProperty;
+                        right?: import("csstype").RightProperty<string | number> | undefined;
+                        rotate?: import("csstype").RotateProperty;
+                        rowGap?: import("csstype").RowGapProperty<string | number> | undefined;
+                        rubyAlign?: import("csstype").RubyAlignProperty;
+                        rubyMerge?: import("csstype").RubyMergeProperty;
+                        rubyPosition?: import("csstype").RubyPositionProperty;
+                        scale?: import("csstype").ScaleProperty;
+                        scrollBehavior?: import("csstype").ScrollBehaviorProperty;
+                        scrollMargin?: import("csstype").ScrollMarginProperty<string | number> | undefined;
+                        scrollMarginBlock?: import("csstype").ScrollMarginBlockProperty<string | number> | undefined;
+                        scrollMarginBlockEnd?: import("csstype").ScrollMarginBlockEndProperty<string | number> | undefined;
+                        scrollMarginBlockStart?: import("csstype").ScrollMarginBlockStartProperty<string | number> | undefined;
+                        scrollMarginBottom?: import("csstype").ScrollMarginBottomProperty<string | number> | undefined;
+                        scrollMarginInline?: import("csstype").ScrollMarginInlineProperty<string | number> | undefined;
+                        scrollMarginInlineEnd?: import("csstype").ScrollMarginInlineEndProperty<string | number> | undefined;
+                        scrollMarginInlineStart?: import("csstype").ScrollMarginInlineStartProperty<string | number> | undefined;
+                        scrollMarginLeft?: import("csstype").ScrollMarginLeftProperty<string | number> | undefined;
+                        scrollMarginRight?: import("csstype").ScrollMarginRightProperty<string | number> | undefined;
+                        scrollMarginTop?: import("csstype").ScrollMarginTopProperty<string | number> | undefined;
+                        scrollPadding?: import("csstype").ScrollPaddingProperty<string | number> | undefined;
+                        scrollPaddingBlock?: import("csstype").ScrollPaddingBlockProperty<string | number> | undefined;
+                        scrollPaddingBlockEnd?: import("csstype").ScrollPaddingBlockEndProperty<string | number> | undefined;
+                        scrollPaddingBlockStart?: import("csstype").ScrollPaddingBlockStartProperty<string | number> | undefined;
+                        scrollPaddingBottom?: import("csstype").ScrollPaddingBottomProperty<string | number> | undefined;
+                        scrollPaddingInline?: import("csstype").ScrollPaddingInlineProperty<string | number> | undefined;
+                        scrollPaddingInlineEnd?: import("csstype").ScrollPaddingInlineEndProperty<string | number> | undefined;
+                        scrollPaddingInlineStart?: import("csstype").ScrollPaddingInlineStartProperty<string | number> | undefined;
+                        scrollPaddingLeft?: import("csstype").ScrollPaddingLeftProperty<string | number> | undefined;
+                        scrollPaddingRight?: import("csstype").ScrollPaddingRightProperty<string | number> | undefined;
+                        scrollPaddingTop?: import("csstype").ScrollPaddingTopProperty<string | number> | undefined;
+                        scrollSnapAlign?: import("csstype").ScrollSnapAlignProperty;
+                        scrollSnapMargin?: import("csstype").ScrollMarginProperty<string | number> | undefined;
+                        scrollSnapMarginBottom?: import("csstype").ScrollMarginBottomProperty<string | number> | undefined;
+                        scrollSnapMarginLeft?: import("csstype").ScrollMarginLeftProperty<string | number> | undefined;
+                        scrollSnapMarginRight?: import("csstype").ScrollMarginRightProperty<string | number> | undefined;
+                        scrollSnapMarginTop?: import("csstype").ScrollMarginTopProperty<string | number> | undefined;
+                        scrollSnapStop?: import("csstype").ScrollSnapStopProperty;
+                        scrollSnapType?: import("csstype").ScrollSnapTypeProperty;
+                        scrollbarColor?: import("csstype").ScrollbarColorProperty;
+                        scrollbarGutter?: import("csstype").ScrollbarGutterProperty;
+                        scrollbarWidth?: import("csstype").ScrollbarWidthProperty;
+                        shapeImageThreshold?: import("csstype").ShapeImageThresholdProperty;
+                        shapeMargin?: import("csstype").ShapeMarginProperty<string | number> | undefined;
+                        shapeOutside?: import("csstype").ShapeOutsideProperty;
+                        tabSize?: import("csstype").TabSizeProperty<string | number> | undefined;
+                        tableLayout?: import("csstype").TableLayoutProperty;
+                        textAlign?: import("csstype").TextAlignProperty;
+                        textAlignLast?: import("csstype").TextAlignLastProperty;
+                        textCombineUpright?: import("csstype").TextCombineUprightProperty;
+                        textDecorationColor?: import("csstype").TextDecorationColorProperty;
+                        textDecorationLine?: import("csstype").TextDecorationLineProperty;
+                        textDecorationSkip?: import("csstype").TextDecorationSkipProperty;
+                        textDecorationSkipInk?: import("csstype").TextDecorationSkipInkProperty;
+                        textDecorationStyle?: import("csstype").TextDecorationStyleProperty;
+                        textDecorationThickness?: import("csstype").TextDecorationThicknessProperty<string | number> | undefined;
+                        textEmphasisColor?: import("csstype").TextEmphasisColorProperty;
+                        textEmphasisPosition?: import("csstype").GlobalsString;
+                        textEmphasisStyle?: import("csstype").TextEmphasisStyleProperty;
+                        textIndent?: import("csstype").TextIndentProperty<string | number> | undefined;
+                        textJustify?: import("csstype").TextJustifyProperty;
+                        textOrientation?: import("csstype").TextOrientationProperty;
+                        textOverflow?: import("csstype").TextOverflowProperty;
+                        textRendering?: import("csstype").TextRenderingProperty;
+                        textShadow?: import("csstype").TextShadowProperty;
+                        textSizeAdjust?: import("csstype").TextSizeAdjustProperty;
+                        textTransform?: import("csstype").TextTransformProperty;
+                        textUnderlineOffset?: import("csstype").TextUnderlineOffsetProperty<string | number> | undefined;
+                        textUnderlinePosition?: import("csstype").TextUnderlinePositionProperty;
+                        top?: import("csstype").TopProperty<string | number> | undefined;
+                        touchAction?: import("csstype").TouchActionProperty;
+                        transform?: import("csstype").TransformProperty;
+                        transformBox?: import("csstype").TransformBoxProperty;
+                        transformOrigin?: import("csstype").TransformOriginProperty<string | number> | undefined;
+                        transformStyle?: import("csstype").TransformStyleProperty;
+                        transitionDelay?: import("csstype").GlobalsString;
+                        transitionDuration?: import("csstype").GlobalsString;
+                        transitionProperty?: import("csstype").TransitionPropertyProperty;
+                        transitionTimingFunction?: import("csstype").TransitionTimingFunctionProperty;
+                        translate?: import("csstype").TranslateProperty<string | number> | undefined;
+                        unicodeBidi?: import("csstype").UnicodeBidiProperty;
+                        userSelect?: import("csstype").UserSelectProperty;
+                        verticalAlign?: import("csstype").VerticalAlignProperty<string | number> | undefined;
+                        visibility?: import("csstype").VisibilityProperty;
+                        whiteSpace?: import("csstype").WhiteSpaceProperty;
+                        widows?: import("csstype").GlobalsNumber;
+                        width?: import("csstype").WidthProperty<string | number> | undefined;
+                        willChange?: import("csstype").WillChangeProperty;
+                        wordBreak?: import("csstype").WordBreakProperty;
+                        wordSpacing?: import("csstype").WordSpacingProperty<string | number> | undefined;
+                        wordWrap?: import("csstype").WordWrapProperty;
+                        writingMode?: import("csstype").WritingModeProperty;
+                        zIndex?: import("csstype").ZIndexProperty;
+                        zoom?: import("csstype").ZoomProperty;
+                        all?: import("csstype").Globals;
+                        animation?: import("csstype").AnimationProperty;
+                        background?: import("csstype").BackgroundProperty<string | number> | undefined;
+                        backgroundPosition?: import("csstype").BackgroundPositionProperty<string | number> | undefined;
+                        border?: import("csstype").BorderProperty<string | number> | undefined;
+                        borderBlock?: import("csstype").BorderBlockProperty<string | number> | undefined;
+                        borderBlockEnd?: import("csstype").BorderBlockEndProperty<string | number> | undefined;
+                        borderBlockStart?: import("csstype").BorderBlockStartProperty<string | number> | undefined;
+                        borderBottom?: import("csstype").BorderBottomProperty<string | number> | undefined;
+                        borderColor?: import("csstype").BorderColorProperty;
+                        borderImage?: import("csstype").BorderImageProperty;
+                        borderInline?: import("csstype").BorderInlineProperty<string | number> | undefined;
+                        borderInlineEnd?: import("csstype").BorderInlineEndProperty<string | number> | undefined;
+                        borderInlineStart?: import("csstype").BorderInlineStartProperty<string | number> | undefined;
+                        borderLeft?: import("csstype").BorderLeftProperty<string | number> | undefined;
+                        borderRadius?: import("csstype").BorderRadiusProperty<string | number> | undefined;
+                        borderRight?: import("csstype").BorderRightProperty<string | number> | undefined;
+                        borderStyle?: import("csstype").BorderStyleProperty;
+                        borderTop?: import("csstype").BorderTopProperty<string | number> | undefined;
+                        borderWidth?: import("csstype").BorderWidthProperty<string | number> | undefined;
+                        columnRule?: import("csstype").ColumnRuleProperty<string | number> | undefined;
+                        columns?: import("csstype").ColumnsProperty<string | number> | undefined;
+                        flex?: import("csstype").FlexProperty<string | number> | undefined;
+                        flexFlow?: import("csstype").FlexFlowProperty;
+                        font?: import("csstype").FontProperty;
+                        gap?: import("csstype").GapProperty<string | number> | undefined;
+                        grid?: import("csstype").GridProperty;
+                        gridArea?: import("csstype").GridAreaProperty;
+                        gridColumn?: import("csstype").GridColumnProperty;
+                        gridRow?: import("csstype").GridRowProperty;
+                        gridTemplate?: import("csstype").GridTemplateProperty;
+                        lineClamp?: import("csstype").LineClampProperty;
+                        listStyle?: import("csstype").ListStyleProperty;
+                        margin?: import("csstype").MarginProperty<string | number> | undefined;
+                        mask?: import("csstype").MaskProperty<string | number> | undefined;
+                        maskBorder?: import("csstype").MaskBorderProperty;
+                        motion?: import("csstype").OffsetProperty<string | number> | undefined;
+                        offset?: import("csstype").OffsetProperty<string | number> | undefined;
+                        outline?: import("csstype").OutlineProperty<string | number> | undefined;
+                        overflow?: import("csstype").OverflowProperty;
+                        overscrollBehavior?: import("csstype").OverscrollBehaviorProperty;
+                        padding?: import("csstype").PaddingProperty<string | number> | undefined;
+                        placeItems?: import("csstype").PlaceItemsProperty;
+                        placeSelf?: import("csstype").PlaceSelfProperty;
+                        textDecoration?: import("csstype").TextDecorationProperty<string | number> | undefined;
+                        textEmphasis?: import("csstype").TextEmphasisProperty;
+                        transition?: import("csstype").TransitionProperty;
+                        MozAnimationDelay?: import("csstype").GlobalsString;
+                        MozAnimationDirection?: import("csstype").AnimationDirectionProperty;
+                        MozAnimationDuration?: import("csstype").GlobalsString;
+                        MozAnimationFillMode?: import("csstype").AnimationFillModeProperty;
+                        MozAnimationIterationCount?: import("csstype").AnimationIterationCountProperty;
+                        MozAnimationName?: import("csstype").AnimationNameProperty;
+                        MozAnimationPlayState?: import("csstype").AnimationPlayStateProperty;
+                        MozAnimationTimingFunction?: import("csstype").AnimationTimingFunctionProperty;
+                        MozAppearance?: import("csstype").MozAppearanceProperty;
+                        MozBackfaceVisibility?: import("csstype").BackfaceVisibilityProperty;
+                        MozBorderBottomColors?: import("csstype").MozBorderBottomColorsProperty;
+                        MozBorderEndColor?: import("csstype").BorderInlineEndColorProperty;
+                        MozBorderEndStyle?: import("csstype").BorderInlineEndStyleProperty;
+                        MozBorderEndWidth?: import("csstype").BorderInlineEndWidthProperty<string | number> | undefined;
+                        MozBorderLeftColors?: import("csstype").MozBorderLeftColorsProperty;
+                        MozBorderRightColors?: import("csstype").MozBorderRightColorsProperty;
+                        MozBorderStartColor?: import("csstype").BorderInlineStartColorProperty;
+                        MozBorderStartStyle?: import("csstype").BorderInlineStartStyleProperty;
+                        MozBorderTopColors?: import("csstype").MozBorderTopColorsProperty;
+                        MozBoxSizing?: import("csstype").BoxSizingProperty;
+                        MozColumnCount?: import("csstype").ColumnCountProperty;
+                        MozColumnFill?: import("csstype").ColumnFillProperty;
+                        MozColumnRuleColor?: import("csstype").ColumnRuleColorProperty;
+                        MozColumnRuleStyle?: import("csstype").ColumnRuleStyleProperty;
+                        MozColumnRuleWidth?: import("csstype").ColumnRuleWidthProperty<string | number> | undefined;
+                        MozColumnWidth?: import("csstype").ColumnWidthProperty<string | number> | undefined;
+                        MozContextProperties?: import("csstype").MozContextPropertiesProperty;
+                        MozFontFeatureSettings?: import("csstype").FontFeatureSettingsProperty;
+                        MozFontLanguageOverride?: import("csstype").FontLanguageOverrideProperty;
+                        MozHyphens?: import("csstype").HyphensProperty;
+                        MozImageRegion?: import("csstype").MozImageRegionProperty;
+                        MozMarginEnd?: import("csstype").MarginInlineEndProperty<string | number> | undefined;
+                        MozMarginStart?: import("csstype").MarginInlineStartProperty<string | number> | undefined;
+                        MozOrient?: import("csstype").MozOrientProperty;
+                        MozOsxFontSmoothing?: import("csstype").FontSmoothProperty<string | number> | undefined;
+                        MozPaddingEnd?: import("csstype").PaddingInlineEndProperty<string | number> | undefined;
+                        MozPaddingStart?: import("csstype").PaddingInlineStartProperty<string | number> | undefined;
+                        MozPerspective?: import("csstype").PerspectiveProperty<string | number> | undefined;
+                        MozPerspectiveOrigin?: import("csstype").PerspectiveOriginProperty<string | number> | undefined;
+                        MozStackSizing?: import("csstype").MozStackSizingProperty;
+                        MozTabSize?: import("csstype").TabSizeProperty<string | number> | undefined;
+                        MozTextBlink?: import("csstype").MozTextBlinkProperty;
+                        MozTextSizeAdjust?: import("csstype").TextSizeAdjustProperty;
+                        MozTransformOrigin?: import("csstype").TransformOriginProperty<string | number> | undefined;
+                        MozTransformStyle?: import("csstype").TransformStyleProperty;
+                        MozTransitionDelay?: import("csstype").GlobalsString;
+                        MozTransitionDuration?: import("csstype").GlobalsString;
+                        MozTransitionProperty?: import("csstype").TransitionPropertyProperty;
+                        MozTransitionTimingFunction?: import("csstype").TransitionTimingFunctionProperty;
+                        MozUserFocus?: import("csstype").MozUserFocusProperty;
+                        MozUserModify?: import("csstype").MozUserModifyProperty;
+                        MozUserSelect?: import("csstype").UserSelectProperty;
+                        MozWindowDragging?: import("csstype").MozWindowDraggingProperty;
+                        MozWindowShadow?: import("csstype").MozWindowShadowProperty;
+                        msAccelerator?: import("csstype").MsAcceleratorProperty;
+                        msBlockProgression?: import("csstype").MsBlockProgressionProperty;
+                        msContentZoomChaining?: import("csstype").MsContentZoomChainingProperty;
+                        msContentZoomLimitMax?: import("csstype").GlobalsString;
+                        msContentZoomLimitMin?: import("csstype").GlobalsString;
+                        msContentZoomSnapPoints?: import("csstype").GlobalsString;
+                        msContentZoomSnapType?: import("csstype").MsContentZoomSnapTypeProperty;
+                        msContentZooming?: import("csstype").MsContentZoomingProperty;
+                        msFilter?: import("csstype").GlobalsString;
+                        msFlexDirection?: import("csstype").FlexDirectionProperty;
+                        msFlexPositive?: import("csstype").GlobalsNumber;
+                        msFlowFrom?: import("csstype").MsFlowFromProperty;
+                        msFlowInto?: import("csstype").MsFlowIntoProperty;
+                        msGridColumns?: import("csstype").MsGridColumnsProperty<string | number> | undefined;
+                        msGridRows?: import("csstype").MsGridRowsProperty<string | number> | undefined;
+                        msHighContrastAdjust?: import("csstype").MsHighContrastAdjustProperty;
+                        msHyphenateLimitChars?: import("csstype").MsHyphenateLimitCharsProperty;
+                        msHyphenateLimitLines?: import("csstype").MsHyphenateLimitLinesProperty;
+                        msHyphenateLimitZone?: import("csstype").MsHyphenateLimitZoneProperty<string | number> | undefined;
+                        msHyphens?: import("csstype").HyphensProperty;
+                        msImeAlign?: import("csstype").MsImeAlignProperty;
+                        msLineBreak?: import("csstype").LineBreakProperty;
+                        msOrder?: import("csstype").GlobalsNumber;
+                        msOverflowStyle?: import("csstype").MsOverflowStyleProperty;
+                        msOverflowX?: import("csstype").OverflowXProperty;
+                        msOverflowY?: import("csstype").OverflowYProperty;
+                        msScrollChaining?: import("csstype").MsScrollChainingProperty;
+                        msScrollLimitXMax?: import("csstype").MsScrollLimitXMaxProperty<string | number> | undefined;
+                        msScrollLimitXMin?: import("csstype").MsScrollLimitXMinProperty<string | number> | undefined;
+                        msScrollLimitYMax?: import("csstype").MsScrollLimitYMaxProperty<string | number> | undefined;
+                        msScrollLimitYMin?: import("csstype").MsScrollLimitYMinProperty<string | number> | undefined;
+                        msScrollRails?: import("csstype").MsScrollRailsProperty;
+                        msScrollSnapPointsX?: import("csstype").GlobalsString;
+                        msScrollSnapPointsY?: import("csstype").GlobalsString;
+                        msScrollSnapType?: import("csstype").MsScrollSnapTypeProperty;
+                        msScrollTranslation?: import("csstype").MsScrollTranslationProperty;
+                        msScrollbar3dlightColor?: import("csstype").MsScrollbar3dlightColorProperty;
+                        msScrollbarArrowColor?: import("csstype").MsScrollbarArrowColorProperty;
+                        msScrollbarBaseColor?: import("csstype").MsScrollbarBaseColorProperty;
+                        msScrollbarDarkshadowColor?: import("csstype").MsScrollbarDarkshadowColorProperty;
+                        msScrollbarFaceColor?: import("csstype").MsScrollbarFaceColorProperty;
+                        msScrollbarHighlightColor?: import("csstype").MsScrollbarHighlightColorProperty;
+                        msScrollbarShadowColor?: import("csstype").MsScrollbarShadowColorProperty;
+                        msScrollbarTrackColor?: import("csstype").MsScrollbarTrackColorProperty;
+                        msTextAutospace?: import("csstype").MsTextAutospaceProperty;
+                        msTextCombineHorizontal?: import("csstype").TextCombineUprightProperty;
+                        msTextOverflow?: import("csstype").TextOverflowProperty;
+                        msTouchAction?: import("csstype").TouchActionProperty;
+                        msTouchSelect?: import("csstype").MsTouchSelectProperty;
+                        msTransform?: import("csstype").TransformProperty;
+                        msTransformOrigin?: import("csstype").TransformOriginProperty<string | number> | undefined;
+                        msTransitionDelay?: import("csstype").GlobalsString;
+                        msTransitionDuration?: import("csstype").GlobalsString;
+                        msTransitionProperty?: import("csstype").TransitionPropertyProperty;
+                        msTransitionTimingFunction?: import("csstype").TransitionTimingFunctionProperty;
+                        msUserSelect?: import("csstype").MsUserSelectProperty;
+                        msWordBreak?: import("csstype").WordBreakProperty;
+                        msWrapFlow?: import("csstype").MsWrapFlowProperty;
+                        msWrapMargin?: import("csstype").MsWrapMarginProperty<string | number> | undefined;
+                        msWrapThrough?: import("csstype").MsWrapThroughProperty;
+                        msWritingMode?: import("csstype").WritingModeProperty;
+                        WebkitAlignContent?: import("csstype").AlignContentProperty;
+                        WebkitAlignItems?: import("csstype").AlignItemsProperty;
+                        WebkitAlignSelf?: import("csstype").AlignSelfProperty;
+                        WebkitAnimationDelay?: import("csstype").GlobalsString;
+                        WebkitAnimationDirection?: import("csstype").AnimationDirectionProperty;
+                        WebkitAnimationDuration?: import("csstype").GlobalsString;
+                        WebkitAnimationFillMode?: import("csstype").AnimationFillModeProperty;
+                        WebkitAnimationIterationCount?: import("csstype").AnimationIterationCountProperty;
+                        WebkitAnimationName?: import("csstype").AnimationNameProperty;
+                        WebkitAnimationPlayState?: import("csstype").AnimationPlayStateProperty;
+                        WebkitAnimationTimingFunction?: import("csstype").AnimationTimingFunctionProperty;
+                        WebkitAppearance?: import("csstype").WebkitAppearanceProperty;
+                        WebkitBackdropFilter?: import("csstype").BackdropFilterProperty;
+                        WebkitBackfaceVisibility?: import("csstype").BackfaceVisibilityProperty;
+                        WebkitBackgroundClip?: import("csstype").BackgroundClipProperty;
+                        WebkitBackgroundOrigin?: import("csstype").BackgroundOriginProperty;
+                        WebkitBackgroundSize?: import("csstype").BackgroundSizeProperty<string | number> | undefined;
+                        WebkitBorderBeforeColor?: import("csstype").WebkitBorderBeforeColorProperty;
+                        WebkitBorderBeforeStyle?: import("csstype").WebkitBorderBeforeStyleProperty;
+                        WebkitBorderBeforeWidth?: import("csstype").WebkitBorderBeforeWidthProperty<string | number> | undefined;
+                        WebkitBorderBottomLeftRadius?: import("csstype").BorderBottomLeftRadiusProperty<string | number> | undefined;
+                        WebkitBorderBottomRightRadius?: import("csstype").BorderBottomRightRadiusProperty<string | number> | undefined;
+                        WebkitBorderImageSlice?: import("csstype").BorderImageSliceProperty;
+                        WebkitBorderTopLeftRadius?: import("csstype").BorderTopLeftRadiusProperty<string | number> | undefined;
+                        WebkitBorderTopRightRadius?: import("csstype").BorderTopRightRadiusProperty<string | number> | undefined;
+                        WebkitBoxDecorationBreak?: import("csstype").BoxDecorationBreakProperty;
+                        WebkitBoxReflect?: import("csstype").WebkitBoxReflectProperty<string | number> | undefined;
+                        WebkitBoxShadow?: import("csstype").BoxShadowProperty;
+                        WebkitBoxSizing?: import("csstype").BoxSizingProperty;
+                        WebkitClipPath?: import("csstype").ClipPathProperty;
+                        WebkitColumnCount?: import("csstype").ColumnCountProperty;
+                        WebkitColumnFill?: import("csstype").ColumnFillProperty;
+                        WebkitColumnRuleColor?: import("csstype").ColumnRuleColorProperty;
+                        WebkitColumnRuleStyle?: import("csstype").ColumnRuleStyleProperty;
+                        WebkitColumnRuleWidth?: import("csstype").ColumnRuleWidthProperty<string | number> | undefined;
+                        WebkitColumnSpan?: import("csstype").ColumnSpanProperty;
+                        WebkitColumnWidth?: import("csstype").ColumnWidthProperty<string | number> | undefined;
+                        WebkitFilter?: import("csstype").FilterProperty;
+                        WebkitFlexBasis?: import("csstype").FlexBasisProperty<string | number> | undefined;
+                        WebkitFlexDirection?: import("csstype").FlexDirectionProperty;
+                        WebkitFlexGrow?: import("csstype").GlobalsNumber;
+                        WebkitFlexShrink?: import("csstype").GlobalsNumber;
+                        WebkitFlexWrap?: import("csstype").FlexWrapProperty;
+                        WebkitFontFeatureSettings?: import("csstype").FontFeatureSettingsProperty;
+                        WebkitFontKerning?: import("csstype").FontKerningProperty;
+                        WebkitFontSmoothing?: import("csstype").FontSmoothProperty<string | number> | undefined;
+                        WebkitFontVariantLigatures?: import("csstype").FontVariantLigaturesProperty;
+                        WebkitHyphenateCharacter?: import("csstype").HyphenateCharacterProperty;
+                        WebkitHyphens?: import("csstype").HyphensProperty;
+                        WebkitInitialLetter?: import("csstype").InitialLetterProperty;
+                        WebkitJustifyContent?: import("csstype").JustifyContentProperty;
+                        WebkitLineBreak?: import("csstype").LineBreakProperty;
+                        WebkitLineClamp?: import("csstype").WebkitLineClampProperty;
+                        WebkitMarginEnd?: import("csstype").MarginInlineEndProperty<string | number> | undefined;
+                        WebkitMarginStart?: import("csstype").MarginInlineStartProperty<string | number> | undefined;
+                        WebkitMaskAttachment?: import("csstype").WebkitMaskAttachmentProperty;
+                        WebkitMaskBoxImageOutset?: import("csstype").MaskBorderOutsetProperty<string | number> | undefined;
+                        WebkitMaskBoxImageRepeat?: import("csstype").MaskBorderRepeatProperty;
+                        WebkitMaskBoxImageSlice?: import("csstype").MaskBorderSliceProperty;
+                        WebkitMaskBoxImageSource?: import("csstype").MaskBorderSourceProperty;
+                        WebkitMaskBoxImageWidth?: import("csstype").MaskBorderWidthProperty<string | number> | undefined;
+                        WebkitMaskClip?: import("csstype").WebkitMaskClipProperty;
+                        WebkitMaskComposite?: import("csstype").WebkitMaskCompositeProperty;
+                        WebkitMaskImage?: import("csstype").WebkitMaskImageProperty;
+                        WebkitMaskOrigin?: import("csstype").WebkitMaskOriginProperty;
+                        WebkitMaskPosition?: import("csstype").WebkitMaskPositionProperty<string | number> | undefined;
+                        WebkitMaskPositionX?: import("csstype").WebkitMaskPositionXProperty<string | number> | undefined;
+                        WebkitMaskPositionY?: import("csstype").WebkitMaskPositionYProperty<string | number> | undefined;
+                        WebkitMaskRepeat?: import("csstype").WebkitMaskRepeatProperty;
+                        WebkitMaskRepeatX?: import("csstype").WebkitMaskRepeatXProperty;
+                        WebkitMaskRepeatY?: import("csstype").WebkitMaskRepeatYProperty;
+                        WebkitMaskSize?: import("csstype").WebkitMaskSizeProperty<string | number> | undefined;
+                        WebkitMaxInlineSize?: import("csstype").MaxInlineSizeProperty<string | number> | undefined;
+                        WebkitOrder?: import("csstype").GlobalsNumber;
+                        WebkitOverflowScrolling?: import("csstype").WebkitOverflowScrollingProperty;
+                        WebkitPaddingEnd?: import("csstype").PaddingInlineEndProperty<string | number> | undefined;
+                        WebkitPaddingStart?: import("csstype").PaddingInlineStartProperty<string | number> | undefined;
+                        WebkitPerspective?: import("csstype").PerspectiveProperty<string | number> | undefined;
+                        WebkitPerspectiveOrigin?: import("csstype").PerspectiveOriginProperty<string | number> | undefined;
+                        WebkitPrintColorAdjust?: import("csstype").PrintColorAdjustProperty;
+                        WebkitRubyPosition?: import("csstype").RubyPositionProperty;
+                        WebkitScrollSnapType?: import("csstype").ScrollSnapTypeProperty;
+                        WebkitShapeMargin?: import("csstype").ShapeMarginProperty<string | number> | undefined;
+                        WebkitTapHighlightColor?: import("csstype").WebkitTapHighlightColorProperty;
+                        WebkitTextCombine?: import("csstype").TextCombineUprightProperty;
+                        WebkitTextDecorationColor?: import("csstype").TextDecorationColorProperty;
+                        WebkitTextDecorationLine?: import("csstype").TextDecorationLineProperty;
+                        WebkitTextDecorationSkip?: import("csstype").TextDecorationSkipProperty;
+                        WebkitTextDecorationStyle?: import("csstype").TextDecorationStyleProperty;
+                        WebkitTextEmphasisColor?: import("csstype").TextEmphasisColorProperty;
+                        WebkitTextEmphasisPosition?: import("csstype").GlobalsString;
+                        WebkitTextEmphasisStyle?: import("csstype").TextEmphasisStyleProperty;
+                        WebkitTextFillColor?: import("csstype").WebkitTextFillColorProperty;
+                        WebkitTextOrientation?: import("csstype").TextOrientationProperty;
+                        WebkitTextSizeAdjust?: import("csstype").TextSizeAdjustProperty;
+                        WebkitTextStrokeColor?: import("csstype").WebkitTextStrokeColorProperty;
+                        WebkitTextStrokeWidth?: import("csstype").WebkitTextStrokeWidthProperty<string | number> | undefined;
+                        WebkitTextUnderlinePosition?: import("csstype").TextUnderlinePositionProperty;
+                        WebkitTouchCallout?: import("csstype").WebkitTouchCalloutProperty;
+                        WebkitTransform?: import("csstype").TransformProperty;
+                        WebkitTransformOrigin?: import("csstype").TransformOriginProperty<string | number> | undefined;
+                        WebkitTransformStyle?: import("csstype").TransformStyleProperty;
+                        WebkitTransitionDelay?: import("csstype").GlobalsString;
+                        WebkitTransitionDuration?: import("csstype").GlobalsString;
+                        WebkitTransitionProperty?: import("csstype").TransitionPropertyProperty;
+                        WebkitTransitionTimingFunction?: import("csstype").TransitionTimingFunctionProperty;
+                        WebkitUserModify?: import("csstype").WebkitUserModifyProperty;
+                        WebkitUserSelect?: import("csstype").UserSelectProperty;
+                        WebkitWritingMode?: import("csstype").WritingModeProperty;
+                        MozAnimation?: import("csstype").AnimationProperty;
+                        MozBorderImage?: import("csstype").BorderImageProperty;
+                        MozColumnRule?: import("csstype").ColumnRuleProperty<string | number> | undefined;
+                        MozColumns?: import("csstype").ColumnsProperty<string | number> | undefined;
+                        MozTransition?: import("csstype").TransitionProperty;
+                        msContentZoomLimit?: import("csstype").GlobalsString;
+                        msContentZoomSnap?: import("csstype").MsContentZoomSnapProperty;
+                        msFlex?: import("csstype").FlexProperty<string | number> | undefined;
+                        msScrollLimit?: import("csstype").GlobalsString;
+                        msScrollSnapX?: import("csstype").GlobalsString;
+                        msScrollSnapY?: import("csstype").GlobalsString;
+                        msTransition?: import("csstype").TransitionProperty;
+                        WebkitAnimation?: import("csstype").AnimationProperty;
+                        WebkitBorderBefore?: import("csstype").WebkitBorderBeforeProperty<string | number> | undefined;
+                        WebkitBorderImage?: import("csstype").BorderImageProperty;
+                        WebkitBorderRadius?: import("csstype").BorderRadiusProperty<string | number> | undefined;
+                        WebkitColumnRule?: import("csstype").ColumnRuleProperty<string | number> | undefined;
+                        WebkitColumns?: import("csstype").ColumnsProperty<string | number> | undefined;
+                        WebkitFlex?: import("csstype").FlexProperty<string | number> | undefined;
+                        WebkitFlexFlow?: import("csstype").FlexFlowProperty;
+                        WebkitMask?: import("csstype").WebkitMaskProperty<string | number> | undefined;
+                        WebkitMaskBoxImage?: import("csstype").MaskBorderProperty;
+                        WebkitTextEmphasis?: import("csstype").TextEmphasisProperty;
+                        WebkitTextStroke?: import("csstype").WebkitTextStrokeProperty<string | number> | undefined;
+                        WebkitTransition?: import("csstype").TransitionProperty;
+                        azimuth?: import("csstype").AzimuthProperty;
+                        boxAlign?: import("csstype").BoxAlignProperty;
+                        boxDirection?: import("csstype").BoxDirectionProperty;
+                        boxFlex?: import("csstype").GlobalsNumber;
+                        boxFlexGroup?: import("csstype").GlobalsNumber;
+                        boxLines?: import("csstype").BoxLinesProperty;
+                        boxOrdinalGroup?: import("csstype").GlobalsNumber;
+                        boxOrient?: import("csstype").BoxOrientProperty;
+                        boxPack?: import("csstype").BoxPackProperty;
+                        clip?: import("csstype").ClipProperty;
+                        gridColumnGap?: import("csstype").GridColumnGapProperty<string | number> | undefined;
+                        gridGap?: import("csstype").GridGapProperty<string | number> | undefined;
+                        gridRowGap?: import("csstype").GridRowGapProperty<string | number> | undefined;
+                        imeMode?: import("csstype").ImeModeProperty;
+                        offsetBlock?: import("csstype").InsetBlockProperty<string | number> | undefined;
+                        offsetBlockEnd?: import("csstype").InsetBlockEndProperty<string | number> | undefined;
+                        offsetBlockStart?: import("csstype").InsetBlockStartProperty<string | number> | undefined;
+                        offsetInline?: import("csstype").InsetInlineProperty<string | number> | undefined;
+                        offsetInlineEnd?: import("csstype").InsetInlineEndProperty<string | number> | undefined;
+                        offsetInlineStart?: import("csstype").InsetInlineStartProperty<string | number> | undefined;
+                        scrollSnapCoordinate?: import("csstype").ScrollSnapCoordinateProperty<string | number> | undefined;
+                        scrollSnapDestination?: import("csstype").ScrollSnapDestinationProperty<string | number> | undefined;
+                        scrollSnapPointsX?: import("csstype").ScrollSnapPointsXProperty;
+                        scrollSnapPointsY?: import("csstype").ScrollSnapPointsYProperty;
+                        scrollSnapTypeX?: import("csstype").ScrollSnapTypeXProperty;
+                        scrollSnapTypeY?: import("csstype").ScrollSnapTypeYProperty;
+                        KhtmlBoxAlign?: import("csstype").BoxAlignProperty;
+                        KhtmlBoxDirection?: import("csstype").BoxDirectionProperty;
+                        KhtmlBoxFlex?: import("csstype").GlobalsNumber;
+                        KhtmlBoxFlexGroup?: import("csstype").GlobalsNumber;
+                        KhtmlBoxLines?: import("csstype").BoxLinesProperty;
+                        KhtmlBoxOrdinalGroup?: import("csstype").GlobalsNumber;
+                        KhtmlBoxOrient?: import("csstype").BoxOrientProperty;
+                        KhtmlBoxPack?: import("csstype").BoxPackProperty;
+                        KhtmlLineBreak?: import("csstype").LineBreakProperty;
+                        KhtmlOpacity?: import("csstype").OpacityProperty;
+                        KhtmlUserSelect?: import("csstype").UserSelectProperty;
+                        MozBackgroundClip?: import("csstype").BackgroundClipProperty;
+                        MozBackgroundInlinePolicy?: import("csstype").BoxDecorationBreakProperty;
+                        MozBackgroundOrigin?: import("csstype").BackgroundOriginProperty;
+                        MozBackgroundSize?: import("csstype").BackgroundSizeProperty<string | number> | undefined;
+                        MozBinding?: import("csstype").MozBindingProperty;
+                        MozBorderRadius?: import("csstype").BorderRadiusProperty<string | number> | undefined;
+                        MozBorderRadiusBottomleft?: import("csstype").BorderBottomLeftRadiusProperty<string | number> | undefined;
+                        MozBorderRadiusBottomright?: import("csstype").BorderBottomRightRadiusProperty<string | number> | undefined;
+                        MozBorderRadiusTopleft?: import("csstype").BorderTopLeftRadiusProperty<string | number> | undefined;
+                        MozBorderRadiusTopright?: import("csstype").BorderTopRightRadiusProperty<string | number> | undefined;
+                        MozBoxAlign?: import("csstype").BoxAlignProperty;
+                        MozBoxDirection?: import("csstype").BoxDirectionProperty;
+                        MozBoxFlex?: import("csstype").GlobalsNumber;
+                        MozBoxOrdinalGroup?: import("csstype").GlobalsNumber;
+                        MozBoxOrient?: import("csstype").BoxOrientProperty;
+                        MozBoxPack?: import("csstype").BoxPackProperty;
+                        MozBoxShadow?: import("csstype").BoxShadowProperty;
+                        MozFloatEdge?: import("csstype").MozFloatEdgeProperty;
+                        MozForceBrokenImageIcon?: import("csstype").MozForceBrokenImageIconProperty;
+                        MozOpacity?: import("csstype").OpacityProperty;
+                        MozOutline?: import("csstype").OutlineProperty<string | number> | undefined;
+                        MozOutlineColor?: import("csstype").OutlineColorProperty;
+                        MozOutlineRadius?: import("csstype").MozOutlineRadiusProperty<string | number> | undefined;
+                        MozOutlineRadiusBottomleft?: import("csstype").MozOutlineRadiusBottomleftProperty<string | number> | undefined;
+                        MozOutlineRadiusBottomright?: import("csstype").MozOutlineRadiusBottomrightProperty<string | number> | undefined;
+                        MozOutlineRadiusTopleft?: import("csstype").MozOutlineRadiusTopleftProperty<string | number> | undefined;
+                        MozOutlineRadiusTopright?: import("csstype").MozOutlineRadiusToprightProperty<string | number> | undefined;
+                        MozOutlineStyle?: import("csstype").OutlineStyleProperty;
+                        MozOutlineWidth?: import("csstype").OutlineWidthProperty<string | number> | undefined;
+                        MozTextAlignLast?: import("csstype").TextAlignLastProperty;
+                        MozTextDecorationColor?: import("csstype").TextDecorationColorProperty;
+                        MozTextDecorationLine?: import("csstype").TextDecorationLineProperty;
+                        MozTextDecorationStyle?: import("csstype").TextDecorationStyleProperty;
+                        MozUserInput?: import("csstype").MozUserInputProperty;
+                        msImeMode?: import("csstype").ImeModeProperty;
+                        OAnimation?: import("csstype").AnimationProperty;
+                        OAnimationDelay?: import("csstype").GlobalsString;
+                        OAnimationDirection?: import("csstype").AnimationDirectionProperty;
+                        OAnimationDuration?: import("csstype").GlobalsString;
+                        OAnimationFillMode?: import("csstype").AnimationFillModeProperty;
+                        OAnimationIterationCount?: import("csstype").AnimationIterationCountProperty;
+                        OAnimationName?: import("csstype").AnimationNameProperty;
+                        OAnimationPlayState?: import("csstype").AnimationPlayStateProperty;
+                        OAnimationTimingFunction?: import("csstype").AnimationTimingFunctionProperty;
+                        OBackgroundSize?: import("csstype").BackgroundSizeProperty<string | number> | undefined;
+                        OBorderImage?: import("csstype").BorderImageProperty;
+                        OObjectFit?: import("csstype").ObjectFitProperty;
+                        OObjectPosition?: import("csstype").ObjectPositionProperty<string | number> | undefined;
+                        OTabSize?: import("csstype").TabSizeProperty<string | number> | undefined;
+                        OTextOverflow?: import("csstype").TextOverflowProperty;
+                        OTransform?: import("csstype").TransformProperty;
+                        OTransformOrigin?: import("csstype").TransformOriginProperty<string | number> | undefined;
+                        OTransition?: import("csstype").TransitionProperty;
+                        OTransitionDelay?: import("csstype").GlobalsString;
+                        OTransitionDuration?: import("csstype").GlobalsString;
+                        OTransitionProperty?: import("csstype").TransitionPropertyProperty;
+                        OTransitionTimingFunction?: import("csstype").TransitionTimingFunctionProperty;
+                        WebkitBoxAlign?: import("csstype").BoxAlignProperty;
+                        WebkitBoxDirection?: import("csstype").BoxDirectionProperty;
+                        WebkitBoxFlex?: import("csstype").GlobalsNumber;
+                        WebkitBoxFlexGroup?: import("csstype").GlobalsNumber;
+                        WebkitBoxLines?: import("csstype").BoxLinesProperty;
+                        WebkitBoxOrdinalGroup?: import("csstype").GlobalsNumber;
+                        WebkitBoxOrient?: import("csstype").BoxOrientProperty;
+                        WebkitBoxPack?: import("csstype").BoxPackProperty;
+                        WebkitScrollSnapPointsX?: import("csstype").ScrollSnapPointsXProperty;
+                        WebkitScrollSnapPointsY?: import("csstype").ScrollSnapPointsYProperty;
+                        alignmentBaseline?: import("csstype").AlignmentBaselineProperty;
+                        baselineShift?: import("csstype").BaselineShiftProperty<string | number> | undefined;
+                        clipRule?: import("csstype").ClipRuleProperty;
+                        colorInterpolation?: import("csstype").ColorInterpolationProperty;
+                        colorRendering?: import("csstype").ColorRenderingProperty;
+                        dominantBaseline?: import("csstype").DominantBaselineProperty;
+                        fill?: import("csstype").FillProperty;
+                        fillOpacity?: import("csstype").GlobalsNumber;
+                        fillRule?: import("csstype").FillRuleProperty;
+                        floodColor?: import("csstype").FloodColorProperty;
+                        floodOpacity?: import("csstype").GlobalsNumber;
+                        glyphOrientationVertical?: import("csstype").GlyphOrientationVerticalProperty;
+                        lightingColor?: import("csstype").LightingColorProperty;
+                        marker?: import("csstype").MarkerProperty;
+                        markerEnd?: import("csstype").MarkerEndProperty;
+                        markerMid?: import("csstype").MarkerMidProperty;
+                        markerStart?: import("csstype").MarkerStartProperty;
+                        shapeRendering?: import("csstype").ShapeRenderingProperty;
+                        stopColor?: import("csstype").StopColorProperty;
+                        stopOpacity?: import("csstype").GlobalsNumber;
+                        stroke?: import("csstype").StrokeProperty;
+                        strokeDasharray?: import("csstype").StrokeDasharrayProperty<string | number> | undefined;
+                        strokeDashoffset?: import("csstype").StrokeDashoffsetProperty<string | number> | undefined;
+                        strokeLinecap?: import("csstype").StrokeLinecapProperty;
+                        strokeLinejoin?: import("csstype").StrokeLinejoinProperty;
+                        strokeMiterlimit?: import("csstype").GlobalsNumber;
+                        strokeOpacity?: import("csstype").GlobalsNumber;
+                        strokeWidth?: import("csstype").StrokeWidthProperty<string | number> | undefined;
+                        textAnchor?: import("csstype").TextAnchorProperty;
+                        vectorEffect?: import("csstype").VectorEffectProperty;
+                        "accent-color"?: import("csstype").AccentColorProperty;
+                        "align-content"?: import("csstype").AlignContentProperty;
+                        "align-items"?: import("csstype").AlignItemsProperty;
+                        "align-self"?: import("csstype").AlignSelfProperty;
+                        "align-tracks"?: import("csstype").AlignTracksProperty;
+                        "animation-composition"?: import("csstype").GlobalsString;
+                        "animation-delay"?: import("csstype").GlobalsString;
+                        "animation-direction"?: import("csstype").AnimationDirectionProperty;
+                        "animation-duration"?: import("csstype").GlobalsString;
+                        "animation-fill-mode"?: import("csstype").AnimationFillModeProperty;
+                        "animation-iteration-count"?: import("csstype").AnimationIterationCountProperty;
+                        "animation-name"?: import("csstype").AnimationNameProperty;
+                        "animation-play-state"?: import("csstype").AnimationPlayStateProperty;
+                        "animation-timeline"?: import("csstype").AnimationTimelineProperty;
+                        "animation-timing-function"?: import("csstype").AnimationTimingFunctionProperty;
+                        "aspect-ratio"?: import("csstype").AspectRatioProperty;
+                        "backdrop-filter"?: import("csstype").BackdropFilterProperty;
+                        "backface-visibility"?: import("csstype").BackfaceVisibilityProperty;
+                        "background-attachment"?: import("csstype").BackgroundAttachmentProperty;
+                        "background-blend-mode"?: import("csstype").BackgroundBlendModeProperty;
+                        "background-clip"?: import("csstype").BackgroundClipProperty;
+                        "background-color"?: import("csstype").BackgroundColorProperty;
+                        "background-image"?: import("csstype").BackgroundImageProperty;
+                        "background-origin"?: import("csstype").BackgroundOriginProperty;
+                        "background-position-x"?: import("csstype").BackgroundPositionXProperty<string | number> | undefined;
+                        "background-position-y"?: import("csstype").BackgroundPositionYProperty<string | number> | undefined;
+                        "background-repeat"?: import("csstype").BackgroundRepeatProperty;
+                        "background-size"?: import("csstype").BackgroundSizeProperty<string | number> | undefined;
+                        "block-overflow"?: import("csstype").BlockOverflowProperty;
+                        "block-size"?: import("csstype").BlockSizeProperty<string | number> | undefined;
+                        "border-block-color"?: import("csstype").BorderBlockColorProperty;
+                        "border-block-end-color"?: import("csstype").BorderBlockEndColorProperty;
+                        "border-block-end-style"?: import("csstype").BorderBlockEndStyleProperty;
+                        "border-block-end-width"?: import("csstype").BorderBlockEndWidthProperty<string | number> | undefined;
+                        "border-block-start-color"?: import("csstype").BorderBlockStartColorProperty;
+                        "border-block-start-style"?: import("csstype").BorderBlockStartStyleProperty;
+                        "border-block-start-width"?: import("csstype").BorderBlockStartWidthProperty<string | number> | undefined;
+                        "border-block-style"?: import("csstype").BorderBlockStyleProperty;
+                        "border-block-width"?: import("csstype").BorderBlockWidthProperty<string | number> | undefined;
+                        "border-bottom-color"?: import("csstype").BorderBottomColorProperty;
+                        "border-bottom-left-radius"?: import("csstype").BorderBottomLeftRadiusProperty<string | number> | undefined;
+                        "border-bottom-right-radius"?: import("csstype").BorderBottomRightRadiusProperty<string | number> | undefined;
+                        "border-bottom-style"?: import("csstype").BorderBottomStyleProperty;
+                        "border-bottom-width"?: import("csstype").BorderBottomWidthProperty<string | number> | undefined;
+                        "border-collapse"?: import("csstype").BorderCollapseProperty;
+                        "border-end-end-radius"?: import("csstype").BorderEndEndRadiusProperty<string | number> | undefined;
+                        "border-end-start-radius"?: import("csstype").BorderEndStartRadiusProperty<string | number> | undefined;
+                        "border-image-outset"?: import("csstype").BorderImageOutsetProperty<string | number> | undefined;
+                        "border-image-repeat"?: import("csstype").BorderImageRepeatProperty;
+                        "border-image-slice"?: import("csstype").BorderImageSliceProperty;
+                        "border-image-source"?: import("csstype").BorderImageSourceProperty;
+                        "border-image-width"?: import("csstype").BorderImageWidthProperty<string | number> | undefined;
+                        "border-inline-color"?: import("csstype").BorderInlineColorProperty;
+                        "border-inline-end-color"?: import("csstype").BorderInlineEndColorProperty;
+                        "border-inline-end-style"?: import("csstype").BorderInlineEndStyleProperty;
+                        "border-inline-end-width"?: import("csstype").BorderInlineEndWidthProperty<string | number> | undefined;
+                        "border-inline-start-color"?: import("csstype").BorderInlineStartColorProperty;
+                        "border-inline-start-style"?: import("csstype").BorderInlineStartStyleProperty;
+                        "border-inline-start-width"?: import("csstype").BorderInlineStartWidthProperty<string | number> | undefined;
+                        "border-inline-style"?: import("csstype").BorderInlineStyleProperty;
+                        "border-inline-width"?: import("csstype").BorderInlineWidthProperty<string | number> | undefined;
+                        "border-left-color"?: import("csstype").BorderLeftColorProperty;
+                        "border-left-style"?: import("csstype").BorderLeftStyleProperty;
+                        "border-left-width"?: import("csstype").BorderLeftWidthProperty<string | number> | undefined;
+                        "border-right-color"?: import("csstype").BorderRightColorProperty;
+                        "border-right-style"?: import("csstype").BorderRightStyleProperty;
+                        "border-right-width"?: import("csstype").BorderRightWidthProperty<string | number> | undefined;
+                        "border-spacing"?: import("csstype").BorderSpacingProperty<string | number> | undefined;
+                        "border-start-end-radius"?: import("csstype").BorderStartEndRadiusProperty<string | number> | undefined;
+                        "border-start-start-radius"?: import("csstype").BorderStartStartRadiusProperty<string | number> | undefined;
+                        "border-top-color"?: import("csstype").BorderTopColorProperty;
+                        "border-top-left-radius"?: import("csstype").BorderTopLeftRadiusProperty<string | number> | undefined;
+                        "border-top-right-radius"?: import("csstype").BorderTopRightRadiusProperty<string | number> | undefined;
+                        "border-top-style"?: import("csstype").BorderTopStyleProperty;
+                        "border-top-width"?: import("csstype").BorderTopWidthProperty<string | number> | undefined;
+                        "box-decoration-break"?: import("csstype").BoxDecorationBreakProperty;
+                        "box-shadow"?: import("csstype").BoxShadowProperty;
+                        "box-sizing"?: import("csstype").BoxSizingProperty;
+                        "break-after"?: import("csstype").BreakAfterProperty;
+                        "break-before"?: import("csstype").BreakBeforeProperty;
+                        "break-inside"?: import("csstype").BreakInsideProperty;
+                        "caption-side"?: import("csstype").CaptionSideProperty;
+                        "caret-color"?: import("csstype").CaretColorProperty;
+                        "clip-path"?: import("csstype").ClipPathProperty;
+                        "color-adjust"?: import("csstype").PrintColorAdjustProperty;
+                        "color-scheme"?: import("csstype").ColorSchemeProperty;
+                        "column-count"?: import("csstype").ColumnCountProperty;
+                        "column-fill"?: import("csstype").ColumnFillProperty;
+                        "column-gap"?: import("csstype").ColumnGapProperty<string | number> | undefined;
+                        "column-rule-color"?: import("csstype").ColumnRuleColorProperty;
+                        "column-rule-style"?: import("csstype").ColumnRuleStyleProperty;
+                        "column-rule-width"?: import("csstype").ColumnRuleWidthProperty<string | number> | undefined;
+                        "column-span"?: import("csstype").ColumnSpanProperty;
+                        "column-width"?: import("csstype").ColumnWidthProperty<string | number> | undefined;
+                        "content-visibility"?: import("csstype").ContentVisibilityProperty;
+                        "counter-increment"?: import("csstype").CounterIncrementProperty;
+                        "counter-reset"?: import("csstype").CounterResetProperty;
+                        "counter-set"?: import("csstype").CounterSetProperty;
+                        "empty-cells"?: import("csstype").EmptyCellsProperty;
+                        "flex-basis"?: import("csstype").FlexBasisProperty<string | number> | undefined;
+                        "flex-direction"?: import("csstype").FlexDirectionProperty;
+                        "flex-grow"?: import("csstype").GlobalsNumber;
+                        "flex-shrink"?: import("csstype").GlobalsNumber;
+                        "flex-wrap"?: import("csstype").FlexWrapProperty;
+                        "font-family"?: import("csstype").FontFamilyProperty;
+                        "font-feature-settings"?: import("csstype").FontFeatureSettingsProperty;
+                        "font-kerning"?: import("csstype").FontKerningProperty;
+                        "font-language-override"?: import("csstype").FontLanguageOverrideProperty;
+                        "font-optical-sizing"?: import("csstype").FontOpticalSizingProperty;
+                        "font-size"?: import("csstype").FontSizeProperty<string | number> | undefined;
+                        "font-size-adjust"?: import("csstype").FontSizeAdjustProperty;
+                        "font-smooth"?: import("csstype").FontSmoothProperty<string | number> | undefined;
+                        "font-stretch"?: import("csstype").FontStretchProperty;
+                        "font-style"?: import("csstype").FontStyleProperty;
+                        "font-synthesis"?: import("csstype").FontSynthesisProperty;
+                        "font-variant"?: import("csstype").FontVariantProperty;
+                        "font-variant-alternates"?: import("csstype").FontVariantAlternatesProperty;
+                        "font-variant-caps"?: import("csstype").FontVariantCapsProperty;
+                        "font-variant-east-asian"?: import("csstype").FontVariantEastAsianProperty;
+                        "font-variant-ligatures"?: import("csstype").FontVariantLigaturesProperty;
+                        "font-variant-numeric"?: import("csstype").FontVariantNumericProperty;
+                        "font-variant-position"?: import("csstype").FontVariantPositionProperty;
+                        "font-variation-settings"?: import("csstype").FontVariationSettingsProperty;
+                        "font-weight"?: import("csstype").FontWeightProperty;
+                        "forced-color-adjust"?: import("csstype").ForcedColorAdjustProperty;
+                        "grid-auto-columns"?: import("csstype").GridAutoColumnsProperty<string | number> | undefined;
+                        "grid-auto-flow"?: import("csstype").GridAutoFlowProperty;
+                        "grid-auto-rows"?: import("csstype").GridAutoRowsProperty<string | number> | undefined;
+                        "grid-column-end"?: import("csstype").GridColumnEndProperty;
+                        "grid-column-start"?: import("csstype").GridColumnStartProperty;
+                        "grid-row-end"?: import("csstype").GridRowEndProperty;
+                        "grid-row-start"?: import("csstype").GridRowStartProperty;
+                        "grid-template-areas"?: import("csstype").GridTemplateAreasProperty;
+                        "grid-template-columns"?: import("csstype").GridTemplateColumnsProperty<string | number> | undefined;
+                        "grid-template-rows"?: import("csstype").GridTemplateRowsProperty<string | number> | undefined;
+                        "hanging-punctuation"?: import("csstype").HangingPunctuationProperty;
+                        "hyphenate-character"?: import("csstype").HyphenateCharacterProperty;
+                        "image-orientation"?: import("csstype").ImageOrientationProperty;
+                        "image-rendering"?: import("csstype").ImageRenderingProperty;
+                        "image-resolution"?: import("csstype").ImageResolutionProperty;
+                        "initial-letter"?: import("csstype").InitialLetterProperty;
+                        "inline-size"?: import("csstype").InlineSizeProperty<string | number> | undefined;
+                        "input-security"?: import("csstype").InputSecurityProperty;
+                        "inset-block"?: import("csstype").InsetBlockProperty<string | number> | undefined;
+                        "inset-block-end"?: import("csstype").InsetBlockEndProperty<string | number> | undefined;
+                        "inset-block-start"?: import("csstype").InsetBlockStartProperty<string | number> | undefined;
+                        "inset-inline"?: import("csstype").InsetInlineProperty<string | number> | undefined;
+                        "inset-inline-end"?: import("csstype").InsetInlineEndProperty<string | number> | undefined;
+                        "inset-inline-start"?: import("csstype").InsetInlineStartProperty<string | number> | undefined;
+                        "justify-content"?: import("csstype").JustifyContentProperty;
+                        "justify-items"?: import("csstype").JustifyItemsProperty;
+                        "justify-self"?: import("csstype").JustifySelfProperty;
+                        "justify-tracks"?: import("csstype").JustifyTracksProperty;
+                        "letter-spacing"?: import("csstype").LetterSpacingProperty<string | number> | undefined;
+                        "line-break"?: import("csstype").LineBreakProperty;
+                        "line-height"?: import("csstype").LineHeightProperty<string | number> | undefined;
+                        "line-height-step"?: import("csstype").LineHeightStepProperty<string | number> | undefined;
+                        "list-style-image"?: import("csstype").ListStyleImageProperty;
+                        "list-style-position"?: import("csstype").ListStylePositionProperty;
+                        "list-style-type"?: import("csstype").ListStyleTypeProperty;
+                        "margin-block"?: import("csstype").MarginBlockProperty<string | number> | undefined;
+                        "margin-block-end"?: import("csstype").MarginBlockEndProperty<string | number> | undefined;
+                        "margin-block-start"?: import("csstype").MarginBlockStartProperty<string | number> | undefined;
+                        "margin-bottom"?: import("csstype").MarginBottomProperty<string | number> | undefined;
+                        "margin-inline"?: import("csstype").MarginInlineProperty<string | number> | undefined;
+                        "margin-inline-end"?: import("csstype").MarginInlineEndProperty<string | number> | undefined;
+                        "margin-inline-start"?: import("csstype").MarginInlineStartProperty<string | number> | undefined;
+                        "margin-left"?: import("csstype").MarginLeftProperty<string | number> | undefined;
+                        "margin-right"?: import("csstype").MarginRightProperty<string | number> | undefined;
+                        "margin-top"?: import("csstype").MarginTopProperty<string | number> | undefined;
+                        "mask-border-mode"?: import("csstype").MaskBorderModeProperty;
+                        "mask-border-outset"?: import("csstype").MaskBorderOutsetProperty<string | number> | undefined;
+                        "mask-border-repeat"?: import("csstype").MaskBorderRepeatProperty;
+                        "mask-border-slice"?: import("csstype").MaskBorderSliceProperty;
+                        "mask-border-source"?: import("csstype").MaskBorderSourceProperty;
+                        "mask-border-width"?: import("csstype").MaskBorderWidthProperty<string | number> | undefined;
+                        "mask-clip"?: import("csstype").MaskClipProperty;
+                        "mask-composite"?: import("csstype").MaskCompositeProperty;
+                        "mask-image"?: import("csstype").MaskImageProperty;
+                        "mask-mode"?: import("csstype").MaskModeProperty;
+                        "mask-origin"?: import("csstype").MaskOriginProperty;
+                        "mask-position"?: import("csstype").MaskPositionProperty<string | number> | undefined;
+                        "mask-repeat"?: import("csstype").MaskRepeatProperty;
+                        "mask-size"?: import("csstype").MaskSizeProperty<string | number> | undefined;
+                        "mask-type"?: import("csstype").MaskTypeProperty;
+                        "math-depth"?: import("csstype").MathDepthProperty;
+                        "math-shift"?: import("csstype").MathShiftProperty;
+                        "math-style"?: import("csstype").MathStyleProperty;
+                        "max-block-size"?: import("csstype").MaxBlockSizeProperty<string | number> | undefined;
+                        "max-height"?: import("csstype").MaxHeightProperty<string | number> | undefined;
+                        "max-inline-size"?: import("csstype").MaxInlineSizeProperty<string | number> | undefined;
+                        "max-lines"?: import("csstype").MaxLinesProperty;
+                        "max-width"?: import("csstype").MaxWidthProperty<string | number> | undefined;
+                        "min-block-size"?: import("csstype").MinBlockSizeProperty<string | number> | undefined;
+                        "min-height"?: import("csstype").MinHeightProperty<string | number> | undefined;
+                        "min-inline-size"?: import("csstype").MinInlineSizeProperty<string | number> | undefined;
+                        "min-width"?: import("csstype").MinWidthProperty<string | number> | undefined;
+                        "mix-blend-mode"?: import("csstype").MixBlendModeProperty;
+                        "motion-distance"?: import("csstype").OffsetDistanceProperty<string | number> | undefined;
+                        "motion-path"?: import("csstype").OffsetPathProperty;
+                        "motion-rotation"?: import("csstype").OffsetRotateProperty;
+                        "object-fit"?: import("csstype").ObjectFitProperty;
+                        "object-position"?: import("csstype").ObjectPositionProperty<string | number> | undefined;
+                        "offset-anchor"?: import("csstype").OffsetAnchorProperty<string | number> | undefined;
+                        "offset-distance"?: import("csstype").OffsetDistanceProperty<string | number> | undefined;
+                        "offset-path"?: import("csstype").OffsetPathProperty;
+                        "offset-rotate"?: import("csstype").OffsetRotateProperty;
+                        "offset-rotation"?: import("csstype").OffsetRotateProperty;
+                        "outline-color"?: import("csstype").OutlineColorProperty;
+                        "outline-offset"?: import("csstype").OutlineOffsetProperty<string | number> | undefined;
+                        "outline-style"?: import("csstype").OutlineStyleProperty;
+                        "outline-width"?: import("csstype").OutlineWidthProperty<string | number> | undefined;
+                        "overflow-anchor"?: import("csstype").OverflowAnchorProperty;
+                        "overflow-block"?: import("csstype").OverflowBlockProperty;
+                        "overflow-clip-box"?: import("csstype").OverflowClipBoxProperty;
+                        "overflow-clip-margin"?: import("csstype").OverflowClipMarginProperty<string | number> | undefined;
+                        "overflow-inline"?: import("csstype").OverflowInlineProperty;
+                        "overflow-wrap"?: import("csstype").OverflowWrapProperty;
+                        "overflow-x"?: import("csstype").OverflowXProperty;
+                        "overflow-y"?: import("csstype").OverflowYProperty;
+                        "overscroll-behavior-block"?: import("csstype").OverscrollBehaviorBlockProperty;
+                        "overscroll-behavior-inline"?: import("csstype").OverscrollBehaviorInlineProperty;
+                        "overscroll-behavior-x"?: import("csstype").OverscrollBehaviorXProperty;
+                        "overscroll-behavior-y"?: import("csstype").OverscrollBehaviorYProperty;
+                        "padding-block"?: import("csstype").PaddingBlockProperty<string | number> | undefined;
+                        "padding-block-end"?: import("csstype").PaddingBlockEndProperty<string | number> | undefined;
+                        "padding-block-start"?: import("csstype").PaddingBlockStartProperty<string | number> | undefined;
+                        "padding-bottom"?: import("csstype").PaddingBottomProperty<string | number> | undefined;
+                        "padding-inline"?: import("csstype").PaddingInlineProperty<string | number> | undefined;
+                        "padding-inline-end"?: import("csstype").PaddingInlineEndProperty<string | number> | undefined;
+                        "padding-inline-start"?: import("csstype").PaddingInlineStartProperty<string | number> | undefined;
+                        "padding-left"?: import("csstype").PaddingLeftProperty<string | number> | undefined;
+                        "padding-right"?: import("csstype").PaddingRightProperty<string | number> | undefined;
+                        "padding-top"?: import("csstype").PaddingTopProperty<string | number> | undefined;
+                        "page-break-after"?: import("csstype").PageBreakAfterProperty;
+                        "page-break-before"?: import("csstype").PageBreakBeforeProperty;
+                        "page-break-inside"?: import("csstype").PageBreakInsideProperty;
+                        "paint-order"?: import("csstype").PaintOrderProperty;
+                        "perspective-origin"?: import("csstype").PerspectiveOriginProperty<string | number> | undefined;
+                        "place-content"?: import("csstype").PlaceContentProperty;
+                        "pointer-events"?: import("csstype").PointerEventsProperty;
+                        "print-color-adjust"?: import("csstype").PrintColorAdjustProperty;
+                        "row-gap"?: import("csstype").RowGapProperty<string | number> | undefined;
+                        "ruby-align"?: import("csstype").RubyAlignProperty;
+                        "ruby-merge"?: import("csstype").RubyMergeProperty;
+                        "ruby-position"?: import("csstype").RubyPositionProperty;
+                        "scroll-behavior"?: import("csstype").ScrollBehaviorProperty;
+                        "scroll-margin"?: import("csstype").ScrollMarginProperty<string | number> | undefined;
+                        "scroll-margin-block"?: import("csstype").ScrollMarginBlockProperty<string | number> | undefined;
+                        "scroll-margin-block-end"?: import("csstype").ScrollMarginBlockEndProperty<string | number> | undefined;
+                        "scroll-margin-block-start"?: import("csstype").ScrollMarginBlockStartProperty<string | number> | undefined;
+                        "scroll-margin-bottom"?: import("csstype").ScrollMarginBottomProperty<string | number> | undefined;
+                        "scroll-margin-inline"?: import("csstype").ScrollMarginInlineProperty<string | number> | undefined;
+                        "scroll-margin-inline-end"?: import("csstype").ScrollMarginInlineEndProperty<string | number> | undefined;
+                        "scroll-margin-inline-start"?: import("csstype").ScrollMarginInlineStartProperty<string | number> | undefined;
+                        "scroll-margin-left"?: import("csstype").ScrollMarginLeftProperty<string | number> | undefined;
+                        "scroll-margin-right"?: import("csstype").ScrollMarginRightProperty<string | number> | undefined;
+                        "scroll-margin-top"?: import("csstype").ScrollMarginTopProperty<string | number> | undefined;
+                        "scroll-padding"?: import("csstype").ScrollPaddingProperty<string | number> | undefined;
+                        "scroll-padding-block"?: import("csstype").ScrollPaddingBlockProperty<string | number> | undefined;
+                        "scroll-padding-block-end"?: import("csstype").ScrollPaddingBlockEndProperty<string | number> | undefined;
+                        "scroll-padding-block-start"?: import("csstype").ScrollPaddingBlockStartProperty<string | number> | undefined;
+                        "scroll-padding-bottom"?: import("csstype").ScrollPaddingBottomProperty<string | number> | undefined;
+                        "scroll-padding-inline"?: import("csstype").ScrollPaddingInlineProperty<string | number> | undefined;
+                        "scroll-padding-inline-end"?: import("csstype").ScrollPaddingInlineEndProperty<string | number> | undefined;
+                        "scroll-padding-inline-start"?: import("csstype").ScrollPaddingInlineStartProperty<string | number> | undefined;
+                        "scroll-padding-left"?: import("csstype").ScrollPaddingLeftProperty<string | number> | undefined;
+                        "scroll-padding-right"?: import("csstype").ScrollPaddingRightProperty<string | number> | undefined;
+                        "scroll-padding-top"?: import("csstype").ScrollPaddingTopProperty<string | number> | undefined;
+                        "scroll-snap-align"?: import("csstype").ScrollSnapAlignProperty;
+                        "scroll-snap-margin"?: import("csstype").ScrollMarginProperty<string | number> | undefined;
+                        "scroll-snap-margin-bottom"?: import("csstype").ScrollMarginBottomProperty<string | number> | undefined;
+                        "scroll-snap-margin-left"?: import("csstype").ScrollMarginLeftProperty<string | number> | undefined;
+                        "scroll-snap-margin-right"?: import("csstype").ScrollMarginRightProperty<string | number> | undefined;
+                        "scroll-snap-margin-top"?: import("csstype").ScrollMarginTopProperty<string | number> | undefined;
+                        "scroll-snap-stop"?: import("csstype").ScrollSnapStopProperty;
+                        "scroll-snap-type"?: import("csstype").ScrollSnapTypeProperty;
+                        "scrollbar-color"?: import("csstype").ScrollbarColorProperty;
+                        "scrollbar-gutter"?: import("csstype").ScrollbarGutterProperty;
+                        "scrollbar-width"?: import("csstype").ScrollbarWidthProperty;
+                        "shape-image-threshold"?: import("csstype").ShapeImageThresholdProperty;
+                        "shape-margin"?: import("csstype").ShapeMarginProperty<string | number> | undefined;
+                        "shape-outside"?: import("csstype").ShapeOutsideProperty;
+                        "tab-size"?: import("csstype").TabSizeProperty<string | number> | undefined;
+                        "table-layout"?: import("csstype").TableLayoutProperty;
+                        "text-align"?: import("csstype").TextAlignProperty;
+                        "text-align-last"?: import("csstype").TextAlignLastProperty;
+                        "text-combine-upright"?: import("csstype").TextCombineUprightProperty;
+                        "text-decoration-color"?: import("csstype").TextDecorationColorProperty;
+                        "text-decoration-line"?: import("csstype").TextDecorationLineProperty;
+                        "text-decoration-skip"?: import("csstype").TextDecorationSkipProperty;
+                        "text-decoration-skip-ink"?: import("csstype").TextDecorationSkipInkProperty;
+                        "text-decoration-style"?: import("csstype").TextDecorationStyleProperty;
+                        "text-decoration-thickness"?: import("csstype").TextDecorationThicknessProperty<string | number> | undefined;
+                        "text-emphasis-color"?: import("csstype").TextEmphasisColorProperty;
+                        "text-emphasis-position"?: import("csstype").GlobalsString;
+                        "text-emphasis-style"?: import("csstype").TextEmphasisStyleProperty;
+                        "text-indent"?: import("csstype").TextIndentProperty<string | number> | undefined;
+                        "text-justify"?: import("csstype").TextJustifyProperty;
+                        "text-orientation"?: import("csstype").TextOrientationProperty;
+                        "text-overflow"?: import("csstype").TextOverflowProperty;
+                        "text-rendering"?: import("csstype").TextRenderingProperty;
+                        "text-shadow"?: import("csstype").TextShadowProperty;
+                        "text-size-adjust"?: import("csstype").TextSizeAdjustProperty;
+                        "text-transform"?: import("csstype").TextTransformProperty;
+                        "text-underline-offset"?: import("csstype").TextUnderlineOffsetProperty<string | number> | undefined;
+                        "text-underline-position"?: import("csstype").TextUnderlinePositionProperty;
+                        "touch-action"?: import("csstype").TouchActionProperty;
+                        "transform-box"?: import("csstype").TransformBoxProperty;
+                        "transform-origin"?: import("csstype").TransformOriginProperty<string | number> | undefined;
+                        "transform-style"?: import("csstype").TransformStyleProperty;
+                        "transition-delay"?: import("csstype").GlobalsString;
+                        "transition-duration"?: import("csstype").GlobalsString;
+                        "transition-property"?: import("csstype").TransitionPropertyProperty;
+                        "transition-timing-function"?: import("csstype").TransitionTimingFunctionProperty;
+                        "unicode-bidi"?: import("csstype").UnicodeBidiProperty;
+                        "user-select"?: import("csstype").UserSelectProperty;
+                        "vertical-align"?: import("csstype").VerticalAlignProperty<string | number> | undefined;
+                        "white-space"?: import("csstype").WhiteSpaceProperty;
+                        "will-change"?: import("csstype").WillChangeProperty;
+                        "word-break"?: import("csstype").WordBreakProperty;
+                        "word-spacing"?: import("csstype").WordSpacingProperty<string | number> | undefined;
+                        "word-wrap"?: import("csstype").WordWrapProperty;
+                        "writing-mode"?: import("csstype").WritingModeProperty;
+                        "z-index"?: import("csstype").ZIndexProperty;
+                        "background-position"?: import("csstype").BackgroundPositionProperty<string | number> | undefined;
+                        "border-block"?: import("csstype").BorderBlockProperty<string | number> | undefined;
+                        "border-block-end"?: import("csstype").BorderBlockEndProperty<string | number> | undefined;
+                        "border-block-start"?: import("csstype").BorderBlockStartProperty<string | number> | undefined;
+                        "border-bottom"?: import("csstype").BorderBottomProperty<string | number> | undefined;
+                        "border-color"?: import("csstype").BorderColorProperty;
+                        "border-image"?: import("csstype").BorderImageProperty;
+                        "border-inline"?: import("csstype").BorderInlineProperty<string | number> | undefined;
+                        "border-inline-end"?: import("csstype").BorderInlineEndProperty<string | number> | undefined;
+                        "border-inline-start"?: import("csstype").BorderInlineStartProperty<string | number> | undefined;
+                        "border-left"?: import("csstype").BorderLeftProperty<string | number> | undefined;
+                        "border-radius"?: import("csstype").BorderRadiusProperty<string | number> | undefined;
+                        "border-right"?: import("csstype").BorderRightProperty<string | number> | undefined;
+                        "border-style"?: import("csstype").BorderStyleProperty;
+                        "border-top"?: import("csstype").BorderTopProperty<string | number> | undefined;
+                        "border-width"?: import("csstype").BorderWidthProperty<string | number> | undefined;
+                        "column-rule"?: import("csstype").ColumnRuleProperty<string | number> | undefined;
+                        "flex-flow"?: import("csstype").FlexFlowProperty;
+                        "grid-area"?: import("csstype").GridAreaProperty;
+                        "grid-column"?: import("csstype").GridColumnProperty;
+                        "grid-row"?: import("csstype").GridRowProperty;
+                        "grid-template"?: import("csstype").GridTemplateProperty;
+                        "line-clamp"?: import("csstype").LineClampProperty;
+                        "list-style"?: import("csstype").ListStyleProperty;
+                        "mask-border"?: import("csstype").MaskBorderProperty;
+                        "overscroll-behavior"?: import("csstype").OverscrollBehaviorProperty;
+                        "place-items"?: import("csstype").PlaceItemsProperty;
+                        "place-self"?: import("csstype").PlaceSelfProperty;
+                        "text-decoration"?: import("csstype").TextDecorationProperty<string | number> | undefined;
+                        "text-emphasis"?: import("csstype").TextEmphasisProperty;
+                        "-moz-animation-delay"?: import("csstype").GlobalsString;
+                        "-moz-animation-direction"?: import("csstype").AnimationDirectionProperty;
+                        "-moz-animation-duration"?: import("csstype").GlobalsString;
+                        "-moz-animation-fill-mode"?: import("csstype").AnimationFillModeProperty;
+                        "-moz-animation-iteration-count"?: import("csstype").AnimationIterationCountProperty;
+                        "-moz-animation-name"?: import("csstype").AnimationNameProperty;
+                        "-moz-animation-play-state"?: import("csstype").AnimationPlayStateProperty;
+                        "-moz-animation-timing-function"?: import("csstype").AnimationTimingFunctionProperty;
+                        "-moz-appearance"?: import("csstype").MozAppearanceProperty;
+                        "-moz-backface-visibility"?: import("csstype").BackfaceVisibilityProperty;
+                        "-moz-border-bottom-colors"?: import("csstype").MozBorderBottomColorsProperty;
+                        "-moz-border-end-color"?: import("csstype").BorderInlineEndColorProperty;
+                        "-moz-border-end-style"?: import("csstype").BorderInlineEndStyleProperty;
+                        "-moz-border-end-width"?: import("csstype").BorderInlineEndWidthProperty<string | number> | undefined;
+                        "-moz-border-left-colors"?: import("csstype").MozBorderLeftColorsProperty;
+                        "-moz-border-right-colors"?: import("csstype").MozBorderRightColorsProperty;
+                        "-moz-border-start-color"?: import("csstype").BorderInlineStartColorProperty;
+                        "-moz-border-start-style"?: import("csstype").BorderInlineStartStyleProperty;
+                        "-moz-border-top-colors"?: import("csstype").MozBorderTopColorsProperty;
+                        "-moz-box-sizing"?: import("csstype").BoxSizingProperty;
+                        "-moz-column-count"?: import("csstype").ColumnCountProperty;
+                        "-moz-column-fill"?: import("csstype").ColumnFillProperty;
+                        "-moz-column-rule-color"?: import("csstype").ColumnRuleColorProperty;
+                        "-moz-column-rule-style"?: import("csstype").ColumnRuleStyleProperty;
+                        "-moz-column-rule-width"?: import("csstype").ColumnRuleWidthProperty<string | number> | undefined;
+                        "-moz-column-width"?: import("csstype").ColumnWidthProperty<string | number> | undefined;
+                        "-moz-context-properties"?: import("csstype").MozContextPropertiesProperty;
+                        "-moz-font-feature-settings"?: import("csstype").FontFeatureSettingsProperty;
+                        "-moz-font-language-override"?: import("csstype").FontLanguageOverrideProperty;
+                        "-moz-hyphens"?: import("csstype").HyphensProperty;
+                        "-moz-image-region"?: import("csstype").MozImageRegionProperty;
+                        "-moz-margin-end"?: import("csstype").MarginInlineEndProperty<string | number> | undefined;
+                        "-moz-margin-start"?: import("csstype").MarginInlineStartProperty<string | number> | undefined;
+                        "-moz-orient"?: import("csstype").MozOrientProperty;
+                        "-moz-osx-font-smoothing"?: import("csstype").FontSmoothProperty<string | number> | undefined;
+                        "-moz-padding-end"?: import("csstype").PaddingInlineEndProperty<string | number> | undefined;
+                        "-moz-padding-start"?: import("csstype").PaddingInlineStartProperty<string | number> | undefined;
+                        "-moz-perspective"?: import("csstype").PerspectiveProperty<string | number> | undefined;
+                        "-moz-perspective-origin"?: import("csstype").PerspectiveOriginProperty<string | number> | undefined;
+                        "-moz-stack-sizing"?: import("csstype").MozStackSizingProperty;
+                        "-moz-tab-size"?: import("csstype").TabSizeProperty<string | number> | undefined;
+                        "-moz-text-blink"?: import("csstype").MozTextBlinkProperty;
+                        "-moz-text-size-adjust"?: import("csstype").TextSizeAdjustProperty;
+                        "-moz-transform-origin"?: import("csstype").TransformOriginProperty<string | number> | undefined;
+                        "-moz-transform-style"?: import("csstype").TransformStyleProperty;
+                        "-moz-transition-delay"?: import("csstype").GlobalsString;
+                        "-moz-transition-duration"?: import("csstype").GlobalsString;
+                        "-moz-transition-property"?: import("csstype").TransitionPropertyProperty;
+                        "-moz-transition-timing-function"?: import("csstype").TransitionTimingFunctionProperty;
+                        "-moz-user-focus"?: import("csstype").MozUserFocusProperty;
+                        "-moz-user-modify"?: import("csstype").MozUserModifyProperty;
+                        "-moz-user-select"?: import("csstype").UserSelectProperty;
+                        "-moz-window-dragging"?: import("csstype").MozWindowDraggingProperty;
+                        "-moz-window-shadow"?: import("csstype").MozWindowShadowProperty;
+                        "-ms-accelerator"?: import("csstype").MsAcceleratorProperty;
+                        "-ms-block-progression"?: import("csstype").MsBlockProgressionProperty;
+                        "-ms-content-zoom-chaining"?: import("csstype").MsContentZoomChainingProperty;
+                        "-ms-content-zoom-limit-max"?: import("csstype").GlobalsString;
+                        "-ms-content-zoom-limit-min"?: import("csstype").GlobalsString;
+                        "-ms-content-zoom-snap-points"?: import("csstype").GlobalsString;
+                        "-ms-content-zoom-snap-type"?: import("csstype").MsContentZoomSnapTypeProperty;
+                        "-ms-content-zooming"?: import("csstype").MsContentZoomingProperty;
+                        "-ms-filter"?: import("csstype").GlobalsString;
+                        "-ms-flex-direction"?: import("csstype").FlexDirectionProperty;
+                        "-ms-flex-positive"?: import("csstype").GlobalsNumber;
+                        "-ms-flow-from"?: import("csstype").MsFlowFromProperty;
+                        "-ms-flow-into"?: import("csstype").MsFlowIntoProperty;
+                        "-ms-grid-columns"?: import("csstype").MsGridColumnsProperty<string | number> | undefined;
+                        "-ms-grid-rows"?: import("csstype").MsGridRowsProperty<string | number> | undefined;
+                        "-ms-high-contrast-adjust"?: import("csstype").MsHighContrastAdjustProperty;
+                        "-ms-hyphenate-limit-chars"?: import("csstype").MsHyphenateLimitCharsProperty;
+                        "-ms-hyphenate-limit-lines"?: import("csstype").MsHyphenateLimitLinesProperty;
+                        "-ms-hyphenate-limit-zone"?: import("csstype").MsHyphenateLimitZoneProperty<string | number> | undefined;
+                        "-ms-hyphens"?: import("csstype").HyphensProperty;
+                        "-ms-ime-align"?: import("csstype").MsImeAlignProperty;
+                        "-ms-line-break"?: import("csstype").LineBreakProperty;
+                        "-ms-order"?: import("csstype").GlobalsNumber;
+                        "-ms-overflow-style"?: import("csstype").MsOverflowStyleProperty;
+                        "-ms-overflow-x"?: import("csstype").OverflowXProperty;
+                        "-ms-overflow-y"?: import("csstype").OverflowYProperty;
+                        "-ms-scroll-chaining"?: import("csstype").MsScrollChainingProperty;
+                        "-ms-scroll-limit-x-max"?: import("csstype").MsScrollLimitXMaxProperty<string | number> | undefined;
+                        "-ms-scroll-limit-x-min"?: import("csstype").MsScrollLimitXMinProperty<string | number> | undefined;
+                        "-ms-scroll-limit-y-max"?: import("csstype").MsScrollLimitYMaxProperty<string | number> | undefined;
+                        "-ms-scroll-limit-y-min"?: import("csstype").MsScrollLimitYMinProperty<string | number> | undefined;
+                        "-ms-scroll-rails"?: import("csstype").MsScrollRailsProperty;
+                        "-ms-scroll-snap-points-x"?: import("csstype").GlobalsString;
+                        "-ms-scroll-snap-points-y"?: import("csstype").GlobalsString;
+                        "-ms-scroll-snap-type"?: import("csstype").MsScrollSnapTypeProperty;
+                        "-ms-scroll-translation"?: import("csstype").MsScrollTranslationProperty;
+                        "-ms-scrollbar-3dlight-color"?: import("csstype").MsScrollbar3dlightColorProperty;
+                        "-ms-scrollbar-arrow-color"?: import("csstype").MsScrollbarArrowColorProperty;
+                        "-ms-scrollbar-base-color"?: import("csstype").MsScrollbarBaseColorProperty;
+                        "-ms-scrollbar-darkshadow-color"?: import("csstype").MsScrollbarDarkshadowColorProperty;
+                        "-ms-scrollbar-face-color"?: import("csstype").MsScrollbarFaceColorProperty;
+                        "-ms-scrollbar-highlight-color"?: import("csstype").MsScrollbarHighlightColorProperty;
+                        "-ms-scrollbar-shadow-color"?: import("csstype").MsScrollbarShadowColorProperty;
+                        "-ms-scrollbar-track-color"?: import("csstype").MsScrollbarTrackColorProperty;
+                        "-ms-text-autospace"?: import("csstype").MsTextAutospaceProperty;
+                        "-ms-text-combine-horizontal"?: import("csstype").TextCombineUprightProperty;
+                        "-ms-text-overflow"?: import("csstype").TextOverflowProperty;
+                        "-ms-touch-action"?: import("csstype").TouchActionProperty;
+                        "-ms-touch-select"?: import("csstype").MsTouchSelectProperty;
+                        "-ms-transform"?: import("csstype").TransformProperty;
+                        "-ms-transform-origin"?: import("csstype").TransformOriginProperty<string | number> | undefined;
+                        "-ms-transition-delay"?: import("csstype").GlobalsString;
+                        "-ms-transition-duration"?: import("csstype").GlobalsString;
+                        "-ms-transition-property"?: import("csstype").TransitionPropertyProperty;
+                        "-ms-transition-timing-function"?: import("csstype").TransitionTimingFunctionProperty;
+                        "-ms-user-select"?: import("csstype").MsUserSelectProperty;
+                        "-ms-word-break"?: import("csstype").WordBreakProperty;
+                        "-ms-wrap-flow"?: import("csstype").MsWrapFlowProperty;
+                        "-ms-wrap-margin"?: import("csstype").MsWrapMarginProperty<string | number> | undefined;
+                        "-ms-wrap-through"?: import("csstype").MsWrapThroughProperty;
+                        "-ms-writing-mode"?: import("csstype").WritingModeProperty;
+                        "-webkit-align-content"?: import("csstype").AlignContentProperty;
+                        "-webkit-align-items"?: import("csstype").AlignItemsProperty;
+                        "-webkit-align-self"?: import("csstype").AlignSelfProperty;
+                        "-webkit-animation-delay"?: import("csstype").GlobalsString;
+                        "-webkit-animation-direction"?: import("csstype").AnimationDirectionProperty;
+                        "-webkit-animation-duration"?: import("csstype").GlobalsString;
+                        "-webkit-animation-fill-mode"?: import("csstype").AnimationFillModeProperty;
+                        "-webkit-animation-iteration-count"?: import("csstype").AnimationIterationCountProperty;
+                        "-webkit-animation-name"?: import("csstype").AnimationNameProperty;
+                        "-webkit-animation-play-state"?: import("csstype").AnimationPlayStateProperty;
+                        "-webkit-animation-timing-function"?: import("csstype").AnimationTimingFunctionProperty;
+                        "-webkit-appearance"?: import("csstype").WebkitAppearanceProperty;
+                        "-webkit-backdrop-filter"?: import("csstype").BackdropFilterProperty;
+                        "-webkit-backface-visibility"?: import("csstype").BackfaceVisibilityProperty;
+                        "-webkit-background-clip"?: import("csstype").BackgroundClipProperty;
+                        "-webkit-background-origin"?: import("csstype").BackgroundOriginProperty;
+                        "-webkit-background-size"?: import("csstype").BackgroundSizeProperty<string | number> | undefined;
+                        "-webkit-border-before-color"?: import("csstype").WebkitBorderBeforeColorProperty;
+                        "-webkit-border-before-style"?: import("csstype").WebkitBorderBeforeStyleProperty;
+                        "-webkit-border-before-width"?: import("csstype").WebkitBorderBeforeWidthProperty<string | number> | undefined;
+                        "-webkit-border-bottom-left-radius"?: import("csstype").BorderBottomLeftRadiusProperty<string | number> | undefined;
+                        "-webkit-border-bottom-right-radius"?: import("csstype").BorderBottomRightRadiusProperty<string | number> | undefined;
+                        "-webkit-border-image-slice"?: import("csstype").BorderImageSliceProperty;
+                        "-webkit-border-top-left-radius"?: import("csstype").BorderTopLeftRadiusProperty<string | number> | undefined;
+                        "-webkit-border-top-right-radius"?: import("csstype").BorderTopRightRadiusProperty<string | number> | undefined;
+                        "-webkit-box-decoration-break"?: import("csstype").BoxDecorationBreakProperty;
+                        "-webkit-box-reflect"?: import("csstype").WebkitBoxReflectProperty<string | number> | undefined;
+                        "-webkit-box-shadow"?: import("csstype").BoxShadowProperty;
+                        "-webkit-box-sizing"?: import("csstype").BoxSizingProperty;
+                        "-webkit-clip-path"?: import("csstype").ClipPathProperty;
+                        "-webkit-column-count"?: import("csstype").ColumnCountProperty;
+                        "-webkit-column-fill"?: import("csstype").ColumnFillProperty;
+                        "-webkit-column-rule-color"?: import("csstype").ColumnRuleColorProperty;
+                        "-webkit-column-rule-style"?: import("csstype").ColumnRuleStyleProperty;
+                        "-webkit-column-rule-width"?: import("csstype").ColumnRuleWidthProperty<string | number> | undefined;
+                        "-webkit-column-span"?: import("csstype").ColumnSpanProperty;
+                        "-webkit-column-width"?: import("csstype").ColumnWidthProperty<string | number> | undefined;
+                        "-webkit-filter"?: import("csstype").FilterProperty;
+                        "-webkit-flex-basis"?: import("csstype").FlexBasisProperty<string | number> | undefined;
+                        "-webkit-flex-direction"?: import("csstype").FlexDirectionProperty;
+                        "-webkit-flex-grow"?: import("csstype").GlobalsNumber;
+                        "-webkit-flex-shrink"?: import("csstype").GlobalsNumber;
+                        "-webkit-flex-wrap"?: import("csstype").FlexWrapProperty;
+                        "-webkit-font-feature-settings"?: import("csstype").FontFeatureSettingsProperty;
+                        "-webkit-font-kerning"?: import("csstype").FontKerningProperty;
+                        "-webkit-font-smoothing"?: import("csstype").FontSmoothProperty<string | number> | undefined;
+                        "-webkit-font-variant-ligatures"?: import("csstype").FontVariantLigaturesProperty;
+                        "-webkit-hyphenate-character"?: import("csstype").HyphenateCharacterProperty;
+                        "-webkit-hyphens"?: import("csstype").HyphensProperty;
+                        "-webkit-initial-letter"?: import("csstype").InitialLetterProperty;
+                        "-webkit-justify-content"?: import("csstype").JustifyContentProperty;
+                        "-webkit-line-break"?: import("csstype").LineBreakProperty;
+                        "-webkit-line-clamp"?: import("csstype").WebkitLineClampProperty;
+                        "-webkit-margin-end"?: import("csstype").MarginInlineEndProperty<string | number> | undefined;
+                        "-webkit-margin-start"?: import("csstype").MarginInlineStartProperty<string | number> | undefined;
+                        "-webkit-mask-attachment"?: import("csstype").WebkitMaskAttachmentProperty;
+                        "-webkit-mask-box-image-outset"?: import("csstype").MaskBorderOutsetProperty<string | number> | undefined;
+                        "-webkit-mask-box-image-repeat"?: import("csstype").MaskBorderRepeatProperty;
+                        "-webkit-mask-box-image-slice"?: import("csstype").MaskBorderSliceProperty;
+                        "-webkit-mask-box-image-source"?: import("csstype").MaskBorderSourceProperty;
+                        "-webkit-mask-box-image-width"?: import("csstype").MaskBorderWidthProperty<string | number> | undefined;
+                        "-webkit-mask-clip"?: import("csstype").WebkitMaskClipProperty;
+                        "-webkit-mask-composite"?: import("csstype").WebkitMaskCompositeProperty;
+                        "-webkit-mask-image"?: import("csstype").WebkitMaskImageProperty;
+                        "-webkit-mask-origin"?: import("csstype").WebkitMaskOriginProperty;
+                        "-webkit-mask-position"?: import("csstype").WebkitMaskPositionProperty<string | number> | undefined;
+                        "-webkit-mask-position-x"?: import("csstype").WebkitMaskPositionXProperty<string | number> | undefined;
+                        "-webkit-mask-position-y"?: import("csstype").WebkitMaskPositionYProperty<string | number> | undefined;
+                        "-webkit-mask-repeat"?: import("csstype").WebkitMaskRepeatProperty;
+                        "-webkit-mask-repeat-x"?: import("csstype").WebkitMaskRepeatXProperty;
+                        "-webkit-mask-repeat-y"?: import("csstype").WebkitMaskRepeatYProperty;
+                        "-webkit-mask-size"?: import("csstype").WebkitMaskSizeProperty<string | number> | undefined;
+                        "-webkit-max-inline-size"?: import("csstype").MaxInlineSizeProperty<string | number> | undefined;
+                        "-webkit-order"?: import("csstype").GlobalsNumber;
+                        "-webkit-overflow-scrolling"?: import("csstype").WebkitOverflowScrollingProperty;
+                        "-webkit-padding-end"?: import("csstype").PaddingInlineEndProperty<string | number> | undefined;
+                        "-webkit-padding-start"?: import("csstype").PaddingInlineStartProperty<string | number> | undefined;
+                        "-webkit-perspective"?: import("csstype").PerspectiveProperty<string | number> | undefined;
+                        "-webkit-perspective-origin"?: import("csstype").PerspectiveOriginProperty<string | number> | undefined;
+                        "-webkit-print-color-adjust"?: import("csstype").PrintColorAdjustProperty;
+                        "-webkit-ruby-position"?: import("csstype").RubyPositionProperty;
+                        "-webkit-scroll-snap-type"?: import("csstype").ScrollSnapTypeProperty;
+                        "-webkit-shape-margin"?: import("csstype").ShapeMarginProperty<string | number> | undefined;
+                        "-webkit-tap-highlight-color"?: import("csstype").WebkitTapHighlightColorProperty;
+                        "-webkit-text-combine"?: import("csstype").TextCombineUprightProperty;
+                        "-webkit-text-decoration-color"?: import("csstype").TextDecorationColorProperty;
+                        "-webkit-text-decoration-line"?: import("csstype").TextDecorationLineProperty;
+                        "-webkit-text-decoration-skip"?: import("csstype").TextDecorationSkipProperty;
+                        "-webkit-text-decoration-style"?: import("csstype").TextDecorationStyleProperty;
+                        "-webkit-text-emphasis-color"?: import("csstype").TextEmphasisColorProperty;
+                        "-webkit-text-emphasis-position"?: import("csstype").GlobalsString;
+                        "-webkit-text-emphasis-style"?: import("csstype").TextEmphasisStyleProperty;
+                        "-webkit-text-fill-color"?: import("csstype").WebkitTextFillColorProperty;
+                        "-webkit-text-orientation"?: import("csstype").TextOrientationProperty;
+                        "-webkit-text-size-adjust"?: import("csstype").TextSizeAdjustProperty;
+                        "-webkit-text-stroke-color"?: import("csstype").WebkitTextStrokeColorProperty;
+                        "-webkit-text-stroke-width"?: import("csstype").WebkitTextStrokeWidthProperty<string | number> | undefined;
+                        "-webkit-text-underline-position"?: import("csstype").TextUnderlinePositionProperty;
+                        "-webkit-touch-callout"?: import("csstype").WebkitTouchCalloutProperty;
+                        "-webkit-transform"?: import("csstype").TransformProperty;
+                        "-webkit-transform-origin"?: import("csstype").TransformOriginProperty<string | number> | undefined;
+                        "-webkit-transform-style"?: import("csstype").TransformStyleProperty;
+                        "-webkit-transition-delay"?: import("csstype").GlobalsString;
+                        "-webkit-transition-duration"?: import("csstype").GlobalsString;
+                        "-webkit-transition-property"?: import("csstype").TransitionPropertyProperty;
+                        "-webkit-transition-timing-function"?: import("csstype").TransitionTimingFunctionProperty;
+                        "-webkit-user-modify"?: import("csstype").WebkitUserModifyProperty;
+                        "-webkit-user-select"?: import("csstype").UserSelectProperty;
+                        "-webkit-writing-mode"?: import("csstype").WritingModeProperty;
+                        "-moz-animation"?: import("csstype").AnimationProperty;
+                        "-moz-border-image"?: import("csstype").BorderImageProperty;
+                        "-moz-column-rule"?: import("csstype").ColumnRuleProperty<string | number> | undefined;
+                        "-moz-columns"?: import("csstype").ColumnsProperty<string | number> | undefined;
+                        "-moz-transition"?: import("csstype").TransitionProperty;
+                        "-ms-content-zoom-limit"?: import("csstype").GlobalsString;
+                        "-ms-content-zoom-snap"?: import("csstype").MsContentZoomSnapProperty;
+                        "-ms-flex"?: import("csstype").FlexProperty<string | number> | undefined;
+                        "-ms-scroll-limit"?: import("csstype").GlobalsString;
+                        "-ms-scroll-snap-x"?: import("csstype").GlobalsString;
+                        "-ms-scroll-snap-y"?: import("csstype").GlobalsString;
+                        "-ms-transition"?: import("csstype").TransitionProperty;
+                        "-webkit-animation"?: import("csstype").AnimationProperty;
+                        "-webkit-border-before"?: import("csstype").WebkitBorderBeforeProperty<string | number> | undefined;
+                        "-webkit-border-image"?: import("csstype").BorderImageProperty;
+                        "-webkit-border-radius"?: import("csstype").BorderRadiusProperty<string | number> | undefined;
+                        "-webkit-column-rule"?: import("csstype").ColumnRuleProperty<string | number> | undefined;
+                        "-webkit-columns"?: import("csstype").ColumnsProperty<string | number> | undefined;
+                        "-webkit-flex"?: import("csstype").FlexProperty<string | number> | undefined;
+                        "-webkit-flex-flow"?: import("csstype").FlexFlowProperty;
+                        "-webkit-mask"?: import("csstype").WebkitMaskProperty<string | number> | undefined;
+                        "-webkit-mask-box-image"?: import("csstype").MaskBorderProperty;
+                        "-webkit-text-emphasis"?: import("csstype").TextEmphasisProperty;
+                        "-webkit-text-stroke"?: import("csstype").WebkitTextStrokeProperty<string | number> | undefined;
+                        "-webkit-transition"?: import("csstype").TransitionProperty;
+                        "box-align"?: import("csstype").BoxAlignProperty;
+                        "box-direction"?: import("csstype").BoxDirectionProperty;
+                        "box-flex"?: import("csstype").GlobalsNumber;
+                        "box-flex-group"?: import("csstype").GlobalsNumber;
+                        "box-lines"?: import("csstype").BoxLinesProperty;
+                        "box-ordinal-group"?: import("csstype").GlobalsNumber;
+                        "box-orient"?: import("csstype").BoxOrientProperty;
+                        "box-pack"?: import("csstype").BoxPackProperty;
+                        "grid-column-gap"?: import("csstype").GridColumnGapProperty<string | number> | undefined;
+                        "grid-gap"?: import("csstype").GridGapProperty<string | number> | undefined;
+                        "grid-row-gap"?: import("csstype").GridRowGapProperty<string | number> | undefined;
+                        "ime-mode"?: import("csstype").ImeModeProperty;
+                        "offset-block"?: import("csstype").InsetBlockProperty<string | number> | undefined;
+                        "offset-block-end"?: import("csstype").InsetBlockEndProperty<string | number> | undefined;
+                        "offset-block-start"?: import("csstype").InsetBlockStartProperty<string | number> | undefined;
+                        "offset-inline"?: import("csstype").InsetInlineProperty<string | number> | undefined;
+                        "offset-inline-end"?: import("csstype").InsetInlineEndProperty<string | number> | undefined;
+                        "offset-inline-start"?: import("csstype").InsetInlineStartProperty<string | number> | undefined;
+                        "scroll-snap-coordinate"?: import("csstype").ScrollSnapCoordinateProperty<string | number> | undefined;
+                        "scroll-snap-destination"?: import("csstype").ScrollSnapDestinationProperty<string | number> | undefined;
+                        "scroll-snap-points-x"?: import("csstype").ScrollSnapPointsXProperty;
+                        "scroll-snap-points-y"?: import("csstype").ScrollSnapPointsYProperty;
+                        "scroll-snap-type-x"?: import("csstype").ScrollSnapTypeXProperty;
+                        "scroll-snap-type-y"?: import("csstype").ScrollSnapTypeYProperty;
+                        "-khtml-box-align"?: import("csstype").BoxAlignProperty;
+                        "-khtml-box-direction"?: import("csstype").BoxDirectionProperty;
+                        "-khtml-box-flex"?: import("csstype").GlobalsNumber;
+                        "-khtml-box-flex-group"?: import("csstype").GlobalsNumber;
+                        "-khtml-box-lines"?: import("csstype").BoxLinesProperty;
+                        "-khtml-box-ordinal-group"?: import("csstype").GlobalsNumber;
+                        "-khtml-box-orient"?: import("csstype").BoxOrientProperty;
+                        "-khtml-box-pack"?: import("csstype").BoxPackProperty;
+                        "-khtml-line-break"?: import("csstype").LineBreakProperty;
+                        "-khtml-opacity"?: import("csstype").OpacityProperty;
+                        "-khtml-user-select"?: import("csstype").UserSelectProperty;
+                        "-moz-background-clip"?: import("csstype").BackgroundClipProperty;
+                        "-moz-background-inline-policy"?: import("csstype").BoxDecorationBreakProperty;
+                        "-moz-background-origin"?: import("csstype").BackgroundOriginProperty;
+                        "-moz-background-size"?: import("csstype").BackgroundSizeProperty<string | number> | undefined;
+                        "-moz-binding"?: import("csstype").MozBindingProperty;
+                        "-moz-border-radius"?: import("csstype").BorderRadiusProperty<string | number> | undefined;
+                        "-moz-border-radius-bottomleft"?: import("csstype").BorderBottomLeftRadiusProperty<string | number> | undefined;
+                        "-moz-border-radius-bottomright"?: import("csstype").BorderBottomRightRadiusProperty<string | number> | undefined;
+                        "-moz-border-radius-topleft"?: import("csstype").BorderTopLeftRadiusProperty<string | number> | undefined;
+                        "-moz-border-radius-topright"?: import("csstype").BorderTopRightRadiusProperty<string | number> | undefined;
+                        "-moz-box-align"?: import("csstype").BoxAlignProperty;
+                        "-moz-box-direction"?: import("csstype").BoxDirectionProperty;
+                        "-moz-box-flex"?: import("csstype").GlobalsNumber;
+                        "-moz-box-ordinal-group"?: import("csstype").GlobalsNumber;
+                        "-moz-box-orient"?: import("csstype").BoxOrientProperty;
+                        "-moz-box-pack"?: import("csstype").BoxPackProperty;
+                        "-moz-box-shadow"?: import("csstype").BoxShadowProperty;
+                        "-moz-float-edge"?: import("csstype").MozFloatEdgeProperty;
+                        "-moz-force-broken-image-icon"?: import("csstype").MozForceBrokenImageIconProperty;
+                        "-moz-opacity"?: import("csstype").OpacityProperty;
+                        "-moz-outline"?: import("csstype").OutlineProperty<string | number> | undefined;
+                        "-moz-outline-color"?: import("csstype").OutlineColorProperty;
+                        "-moz-outline-radius"?: import("csstype").MozOutlineRadiusProperty<string | number> | undefined;
+                        "-moz-outline-radius-bottomleft"?: import("csstype").MozOutlineRadiusBottomleftProperty<string | number> | undefined;
+                        "-moz-outline-radius-bottomright"?: import("csstype").MozOutlineRadiusBottomrightProperty<string | number> | undefined;
+                        "-moz-outline-radius-topleft"?: import("csstype").MozOutlineRadiusTopleftProperty<string | number> | undefined;
+                        "-moz-outline-radius-topright"?: import("csstype").MozOutlineRadiusToprightProperty<string | number> | undefined;
+                        "-moz-outline-style"?: import("csstype").OutlineStyleProperty;
+                        "-moz-outline-width"?: import("csstype").OutlineWidthProperty<string | number> | undefined;
+                        "-moz-text-align-last"?: import("csstype").TextAlignLastProperty;
+                        "-moz-text-decoration-color"?: import("csstype").TextDecorationColorProperty;
+                        "-moz-text-decoration-line"?: import("csstype").TextDecorationLineProperty;
+                        "-moz-text-decoration-style"?: import("csstype").TextDecorationStyleProperty;
+                        "-moz-user-input"?: import("csstype").MozUserInputProperty;
+                        "-ms-ime-mode"?: import("csstype").ImeModeProperty;
+                        "-o-animation"?: import("csstype").AnimationProperty;
+                        "-o-animation-delay"?: import("csstype").GlobalsString;
+                        "-o-animation-direction"?: import("csstype").AnimationDirectionProperty;
+                        "-o-animation-duration"?: import("csstype").GlobalsString;
+                        "-o-animation-fill-mode"?: import("csstype").AnimationFillModeProperty;
+                        "-o-animation-iteration-count"?: import("csstype").AnimationIterationCountProperty;
+                        "-o-animation-name"?: import("csstype").AnimationNameProperty;
+                        "-o-animation-play-state"?: import("csstype").AnimationPlayStateProperty;
+                        "-o-animation-timing-function"?: import("csstype").AnimationTimingFunctionProperty;
+                        "-o-background-size"?: import("csstype").BackgroundSizeProperty<string | number> | undefined;
+                        "-o-border-image"?: import("csstype").BorderImageProperty;
+                        "-o-object-fit"?: import("csstype").ObjectFitProperty;
+                        "-o-object-position"?: import("csstype").ObjectPositionProperty<string | number> | undefined;
+                        "-o-tab-size"?: import("csstype").TabSizeProperty<string | number> | undefined;
+                        "-o-text-overflow"?: import("csstype").TextOverflowProperty;
+                        "-o-transform"?: import("csstype").TransformProperty;
+                        "-o-transform-origin"?: import("csstype").TransformOriginProperty<string | number> | undefined;
+                        "-o-transition"?: import("csstype").TransitionProperty;
+                        "-o-transition-delay"?: import("csstype").GlobalsString;
+                        "-o-transition-duration"?: import("csstype").GlobalsString;
+                        "-o-transition-property"?: import("csstype").TransitionPropertyProperty;
+                        "-o-transition-timing-function"?: import("csstype").TransitionTimingFunctionProperty;
+                        "-webkit-box-align"?: import("csstype").BoxAlignProperty;
+                        "-webkit-box-direction"?: import("csstype").BoxDirectionProperty;
+                        "-webkit-box-flex"?: import("csstype").GlobalsNumber;
+                        "-webkit-box-flex-group"?: import("csstype").GlobalsNumber;
+                        "-webkit-box-lines"?: import("csstype").BoxLinesProperty;
+                        "-webkit-box-ordinal-group"?: import("csstype").GlobalsNumber;
+                        "-webkit-box-orient"?: import("csstype").BoxOrientProperty;
+                        "-webkit-box-pack"?: import("csstype").BoxPackProperty;
+                        "-webkit-scroll-snap-points-x"?: import("csstype").ScrollSnapPointsXProperty;
+                        "-webkit-scroll-snap-points-y"?: import("csstype").ScrollSnapPointsYProperty;
+                        "alignment-baseline"?: import("csstype").AlignmentBaselineProperty;
+                        "baseline-shift"?: import("csstype").BaselineShiftProperty<string | number> | undefined;
+                        "clip-rule"?: import("csstype").ClipRuleProperty;
+                        "color-interpolation"?: import("csstype").ColorInterpolationProperty;
+                        "color-rendering"?: import("csstype").ColorRenderingProperty;
+                        "dominant-baseline"?: import("csstype").DominantBaselineProperty;
+                        "fill-opacity"?: import("csstype").GlobalsNumber;
+                        "fill-rule"?: import("csstype").FillRuleProperty;
+                        "flood-color"?: import("csstype").FloodColorProperty;
+                        "flood-opacity"?: import("csstype").GlobalsNumber;
+                        "glyph-orientation-vertical"?: import("csstype").GlyphOrientationVerticalProperty;
+                        "lighting-color"?: import("csstype").LightingColorProperty;
+                        "marker-end"?: import("csstype").MarkerEndProperty;
+                        "marker-mid"?: import("csstype").MarkerMidProperty;
+                        "marker-start"?: import("csstype").MarkerStartProperty;
+                        "shape-rendering"?: import("csstype").ShapeRenderingProperty;
+                        "stop-color"?: import("csstype").StopColorProperty;
+                        "stop-opacity"?: import("csstype").GlobalsNumber;
+                        "stroke-dasharray"?: import("csstype").StrokeDasharrayProperty<string | number> | undefined;
+                        "stroke-dashoffset"?: import("csstype").StrokeDashoffsetProperty<string | number> | undefined;
+                        "stroke-linecap"?: import("csstype").StrokeLinecapProperty;
+                        "stroke-linejoin"?: import("csstype").StrokeLinejoinProperty;
+                        "stroke-miterlimit"?: import("csstype").GlobalsNumber;
+                        "stroke-opacity"?: import("csstype").GlobalsNumber;
+                        "stroke-width"?: import("csstype").StrokeWidthProperty<string | number> | undefined;
+                        "text-anchor"?: import("csstype").TextAnchorProperty;
+                        "vector-effect"?: import("csstype").VectorEffectProperty;
+                    };
+                    key?: import("pro-design-vue").ProTableKey;
+                    class?: string;
+                    colSpan?: number;
+                    rowSpan?: number;
+                }>;
+                cellInnerClass: import("vue").ComputedRef<{
+                    [x: string]: boolean;
+                }>;
+                cellInnerRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                expandContent: import("vue").ComputedRef<any>;
+                autoHeight: import("vue").ComputedRef<boolean>;
+                cellResizeBind: import("vue").ComputedRef<{
+                    resizeObserver: ResizeObserver | undefined;
+                    calMaxHeight: Function | undefined;
+                } | {
+                    resizeObserver?: undefined;
+                    calMaxHeight?: undefined;
+                }>;
+                onBodyCellContextmenu: (event: MouseEvent, args: Partial<import("pro-design-vue").CellRenderArgs>, type: import("../interface").RowType) => void;
+                contextmenuProps: import("vue").ComputedRef<{
+                    record: Record<string, any>;
+                    index: number | undefined;
+                    recordIndexs: number[];
+                    key: string | number | undefined;
+                    isExpand: boolean;
+                }>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                prefixCls: StringConstructor;
+                rowKey: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                item: {
+                    type: ObjectConstructor;
+                    default: () => {};
+                };
+                rowIndex: NumberConstructor;
+                resizeObserver: {
+                    type: PropType<ResizeObserver>;
+                };
+                calMaxHeight: FunctionConstructor;
+            }>> & Readonly<{}>, {
+                item: Record<string, any>;
+            }, {}, {
+                RenderVNode: import("vue").FunctionalComponent<any, {}, any, {}>;
+            }, {
+                cellResize: import("vue").Directive;
+            }, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            BodyExtraCell: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                prefixCls: PropType<string>;
+                rowIndex: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                type: {
+                    type: PropType<import("../interface").RowType>;
+                };
+                column: {
+                    type: PropType<import("../interface").FinallyColumnType<import("../interface").DefaultRecordType>>;
+                    default: () => {};
+                };
+                record: {
+                    type: PropType<import("../interface").DefaultRecordType>;
+                };
+                rowKey: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                expanded: PropType<boolean>;
+                supportExpand: BooleanConstructor;
+            }>, {
+                handleRadioChange: (e: Event) => void;
+                handleCheckboxChange: (event: Event) => void;
+                onInternalTriggerExpand: (record: import("../interface").DefaultRecordType, e: MouseEvent) => void;
+                rowSelectionType: import("vue").ComputedRef<import("../interface").RowSelectionType>;
+                keySet: import("vue").ComputedRef<Set<import("pro-design-vue").ProTableKey>>;
+                checked: import("vue").Ref<boolean, boolean>;
+                mergedIndeterminate: import("vue").Ref<boolean, boolean>;
+                checkboxProps: import("vue").ComputedRef<Partial<import("vue").ExtractPropTypes<{
+                    prefixCls: PropType<string>;
+                    disabled: PropType<boolean>;
+                    tabindex: (StringConstructor | NumberConstructor)[];
+                    name: PropType<string>;
+                    id: PropType<string>;
+                    style: {
+                        type: PropType<CSSProperties>;
+                        default: () => {};
+                    };
+                    class: PropType<string>;
+                    checked: PropType<boolean>;
+                    indeterminate: PropType<boolean>;
+                    ariaLabel: PropType<string>;
+                }>>>;
+                mergedCellProps: import("vue").ComputedRef<import("../interface").CellType>;
+                onBodyCellContextmenu: (event: MouseEvent, args: Partial<import("pro-design-vue").CellRenderArgs>, type: import("../interface").RowType) => void;
+                contextmenuProps: import("vue").ComputedRef<{
+                    record: import("../interface").DefaultRecordType | undefined;
+                    column: import("pro-design-vue").ProTableColumnType<import("../interface").DefaultRecordType> | import("pro-design-vue").ProTableColumnGroupType<import("../interface").DefaultRecordType> | undefined;
+                    index: number;
+                    recordIndexs: number[];
+                    key: string | number | undefined;
+                }>;
+                level: number | undefined;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                prefixCls: PropType<string>;
+                rowIndex: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                type: {
+                    type: PropType<import("../interface").RowType>;
+                };
+                column: {
+                    type: PropType<import("../interface").FinallyColumnType<import("../interface").DefaultRecordType>>;
+                    default: () => {};
+                };
+                record: {
+                    type: PropType<import("../interface").DefaultRecordType>;
+                };
+                rowKey: {
+                    type: (StringConstructor | NumberConstructor)[];
+                };
+                expanded: PropType<boolean>;
+                supportExpand: BooleanConstructor;
+            }>> & Readonly<{}>, {
+                column: import("../interface").FinallyColumnType<import("../interface").DefaultRecordType>;
+                supportExpand: boolean;
+            }, {}, {
+                Checkbox: import("vue").FunctionalComponent<Partial<import("vue").ExtractPropTypes<{
+                    prefixCls: PropType<string>;
+                    disabled: PropType<boolean>;
+                    tabindex: (StringConstructor | NumberConstructor)[];
+                    name: PropType<string>;
+                    id: PropType<string>;
+                    style: {
+                        type: PropType<CSSProperties>;
+                        default: () => {};
+                    };
+                    class: PropType<string>;
+                    checked: PropType<boolean>;
+                    indeterminate: PropType<boolean>;
+                    ariaLabel: PropType<string>;
+                }>>, {}, any, {}>;
+                Radio: import("vue").FunctionalComponent<Partial<import("vue").ExtractPropTypes<{
+                    prefixCls: PropType<string>;
+                    disabled: PropType<boolean>;
+                    tabindex: (StringConstructor | NumberConstructor)[];
+                    name: PropType<string>;
+                    id: PropType<string>;
+                    style: {
+                        type: PropType<CSSProperties>;
+                        default: () => {};
+                    };
+                    class: PropType<string>;
+                    checked: PropType<boolean>;
+                    indeterminate: PropType<boolean>;
+                    ariaLabel: PropType<string>;
+                }>>, {}, any, {}>;
+                ExpandIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    prefixCls: StringConstructor;
+                    record: ObjectConstructor;
+                    expanded: BooleanConstructor;
+                    expandable: BooleanConstructor;
+                    disabled: BooleanConstructor;
+                    onExpand: FunctionConstructor;
+                }>, {
+                    handleClick: () => void;
+                    className: import("vue").ComputedRef<{
+                        [x: string]: boolean;
+                    }>;
+                    label: import("vue").ComputedRef<string | undefined>;
+                    expandIcon: import("vue").ComputedRef<import("../interface").RenderExpandIcon<import("../interface").DefaultRecordType> | undefined>;
+                    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                        prefixCls: StringConstructor;
+                        record: ObjectConstructor;
+                        expanded: BooleanConstructor;
+                        expandable: BooleanConstructor;
+                        disabled: BooleanConstructor;
+                        onExpand: FunctionConstructor;
+                    }>> & Readonly<{
+                        onExpand?: ((...args: any[]) => any) | undefined;
+                    }> & {}>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "expand"[], "expand", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    prefixCls: StringConstructor;
+                    record: ObjectConstructor;
+                    expanded: BooleanConstructor;
+                    expandable: BooleanConstructor;
+                    disabled: BooleanConstructor;
+                    onExpand: FunctionConstructor;
+                }>> & Readonly<{
+                    onExpand?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    disabled: boolean;
+                    expanded: boolean;
+                    expandable: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                MenuOutlined: import("@ant-design/icons-vue/lib/icons/MenuOutlined").MenuOutlinedIconType;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            RenderSlot: import("vue").FunctionalComponent<any, {}, any, {}>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Empty: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            prefixCls: StringConstructor;
+            imageStyle: {
+                type: import("vue").PropType<CSSProperties>;
+                default: CSSProperties;
+            };
+            image: {
+                default: import("ant-design-vue/es/_util/type").VueNode;
+                type: import("vue").PropType<import("ant-design-vue/es/_util/type").VueNode>;
+            };
+            description: {
+                default: import("ant-design-vue/es/_util/type").VueNode;
+                type: import("vue").PropType<import("ant-design-vue/es/_util/type").VueNode>;
+            };
+        }>> & Readonly<{}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            image: import("ant-design-vue/es/_util/type").VueNode;
+            description: import("ant-design-vue/es/_util/type").VueNode;
+            imageStyle: CSSProperties;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            prefixCls: StringConstructor;
+            imageStyle: {
+                type: import("vue").PropType<CSSProperties>;
+                default: CSSProperties;
+            };
+            image: {
+                default: import("ant-design-vue/es/_util/type").VueNode;
+                type: import("vue").PropType<import("ant-design-vue/es/_util/type").VueNode>;
+            };
+            description: {
+                default: import("ant-design-vue/es/_util/type").VueNode;
+                type: import("vue").PropType<import("ant-design-vue/es/_util/type").VueNode>;
+            };
+        }>> & Readonly<{}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, {
+            image: import("ant-design-vue/es/_util/type").VueNode;
+            description: import("ant-design-vue/es/_util/type").VueNode;
+            imageStyle: CSSProperties;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        prefixCls: StringConstructor;
+        imageStyle: {
+            type: import("vue").PropType<CSSProperties>;
+            default: CSSProperties;
+        };
+        image: {
+            default: import("ant-design-vue/es/_util/type").VueNode;
+            type: import("vue").PropType<import("ant-design-vue/es/_util/type").VueNode>;
+        };
+        description: {
+            default: import("ant-design-vue/es/_util/type").VueNode;
+            type: import("vue").PropType<import("ant-design-vue/es/_util/type").VueNode>;
+        };
+    }>> & Readonly<{}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        image: import("ant-design-vue/es/_util/type").VueNode;
+        description: import("ant-design-vue/es/_util/type").VueNode;
+        imageStyle: CSSProperties;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & (import("vue").AllowedComponentProps & (import("vue").ComponentCustomProps & import("vue").Plugin<any[], any[]>));
+    RenderVNode: import("vue").FunctionalComponent<any, {}, any, {}>;
+    RenderSlot: import("vue").FunctionalComponent<any, {}, any, {}>;
+    HorizontalScroll: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        onlyAutoShow: {
+            type: BooleanConstructor;
+        };
+        notShowAuto: {
+            type: BooleanConstructor;
+        };
+    }>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        onlyAutoShow: {
+            type: BooleanConstructor;
+        };
+        notShowAuto: {
+            type: BooleanConstructor;
+        };
+    }>> & Readonly<{}>, {
+        onlyAutoShow: boolean;
+        notShowAuto: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    YScroll: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        onlyAutoShow: {
+            type: BooleanConstructor;
+        };
+        notShowAuto: {
+            type: BooleanConstructor;
+        };
+    }>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        onlyAutoShow: {
+            type: BooleanConstructor;
+        };
+        notShowAuto: {
+            type: BooleanConstructor;
+        };
+    }>> & Readonly<{}>, {
+        onlyAutoShow: boolean;
+        notShowAuto: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {
+    resize: import("vue").Directive;
+}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;