@orient-ai/aurora-ui 1.0.0-alpha.11 → 1.0.0-alpha.13

package/dist/components/Collection/Grid/hooks/useGrid.d.ts

@@ -0,0 +1,330 @@
+import { Cell, RowData } from '@tanstack/react-table';
+import { Features } from '../../types';
+import { GridProps } from '../types';
+export declare function useGrid<TFeatures extends Features, TData extends RowData>(options: GridProps<TFeatures, TData>): {
+    getCell: (cell: Cell<TFeatures, TData>) => {
+        canSelect: boolean;
+        renderedCell: Cell<TFeatures, TData>;
+        props: {
+            dirty: boolean;
+            'data-row-id': string;
+            'data-column-id': string;
+            'data-resize-active': true | undefined;
+            'data-editing': true | undefined;
+            children?: import('react').ReactNode;
+            prefix?: import('react').ReactNode;
+            suffix?: import('react').ReactNode;
+            selected?: boolean;
+            readOnly?: boolean;
+            selectionEdges?: readonly import('..').GridCellSelectionEdge[];
+            busy?: boolean;
+            error?: string;
+            key?: import('react').Key | null | undefined;
+            ref?: import('react').Ref<HTMLTableDataCellElement> | undefined;
+            slot?: string | undefined | undefined;
+            abbr?: string | undefined | undefined;
+            style?: import('react').CSSProperties | undefined;
+            title?: string | undefined | undefined;
+            id?: string | undefined | undefined;
+            onLoad?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onError?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            color?: string | undefined | undefined;
+            content?: string | undefined | undefined;
+            defaultChecked?: boolean | undefined | undefined;
+            defaultValue?: string | number | readonly string[] | undefined;
+            suppressContentEditableWarning?: boolean | undefined | undefined;
+            suppressHydrationWarning?: boolean | undefined | undefined;
+            accessKey?: string | undefined | undefined;
+            autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
+            autoFocus?: boolean | undefined | undefined;
+            className?: string | undefined | undefined;
+            contentEditable?: "inherit" | (boolean | "true" | "false") | "plaintext-only" | undefined;
+            contextMenu?: string | undefined | undefined;
+            dir?: string | undefined | undefined;
+            draggable?: (boolean | "true" | "false") | undefined;
+            enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+            hidden?: boolean | undefined | undefined;
+            lang?: string | undefined | undefined;
+            nonce?: string | undefined | undefined;
+            spellCheck?: (boolean | "true" | "false") | undefined;
+            tabIndex?: number | undefined | undefined;
+            translate?: "yes" | "no" | undefined | undefined;
+            radioGroup?: string | undefined | undefined;
+            role?: import('react').AriaRole | undefined;
+            about?: string | undefined | undefined;
+            datatype?: string | undefined | undefined;
+            inlist?: any;
+            property?: string | undefined | undefined;
+            rel?: string | undefined | undefined;
+            resource?: string | undefined | undefined;
+            rev?: string | undefined | undefined;
+            typeof?: string | undefined | undefined;
+            vocab?: string | undefined | undefined;
+            autoCorrect?: string | undefined | undefined;
+            autoSave?: string | undefined | undefined;
+            itemProp?: string | undefined | undefined;
+            itemScope?: boolean | undefined | undefined;
+            itemType?: string | undefined | undefined;
+            itemID?: string | undefined | undefined;
+            itemRef?: string | undefined | undefined;
+            results?: number | undefined | undefined;
+            security?: string | undefined | undefined;
+            unselectable?: "on" | "off" | undefined | undefined;
+            popover?: "" | "auto" | "manual" | "hint" | undefined | undefined;
+            popoverTargetAction?: "toggle" | "show" | "hide" | undefined | undefined;
+            popoverTarget?: string | undefined | undefined;
+            inert?: boolean | undefined | undefined;
+            inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+            is?: string | undefined | undefined;
+            exportparts?: string | undefined | undefined;
+            part?: string | undefined | undefined;
+            "aria-activedescendant"?: string | undefined | undefined;
+            "aria-atomic"?: (boolean | "true" | "false") | undefined;
+            "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | undefined;
+            "aria-braillelabel"?: string | undefined | undefined;
+            "aria-brailleroledescription"?: string | undefined | undefined;
+            "aria-busy"?: (boolean | "true" | "false") | undefined;
+            "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+            "aria-colcount"?: number | undefined | undefined;
+            "aria-colindex"?: number | undefined | undefined;
+            "aria-colindextext"?: string | undefined | undefined;
+            "aria-colspan"?: number | undefined | undefined;
+            "aria-controls"?: string | undefined | undefined;
+            "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined | undefined;
+            "aria-describedby"?: string | undefined | undefined;
+            "aria-description"?: string | undefined | undefined;
+            "aria-details"?: string | undefined | undefined;
+            "aria-disabled"?: (boolean | "true" | "false") | undefined;
+            "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+            "aria-errormessage"?: string | undefined | undefined;
+            "aria-expanded"?: (boolean | "true" | "false") | undefined;
+            "aria-flowto"?: string | undefined | undefined;
+            "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+            "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | undefined;
+            "aria-hidden"?: (boolean | "true" | "false") | undefined;
+            "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined | undefined;
+            "aria-keyshortcuts"?: string | undefined | undefined;
+            "aria-label"?: string | undefined | undefined;
+            "aria-labelledby"?: string | undefined | undefined;
+            "aria-level"?: number | undefined | undefined;
+            "aria-live"?: "off" | "assertive" | "polite" | undefined | undefined;
+            "aria-modal"?: (boolean | "true" | "false") | undefined;
+            "aria-multiline"?: (boolean | "true" | "false") | undefined;
+            "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+            "aria-orientation"?: "horizontal" | "vertical" | undefined | undefined;
+            "aria-owns"?: string | undefined | undefined;
+            "aria-placeholder"?: string | undefined | undefined;
+            "aria-posinset"?: number | undefined | undefined;
+            "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+            "aria-readonly"?: (boolean | "true" | "false") | undefined;
+            "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+            "aria-required"?: (boolean | "true" | "false") | undefined;
+            "aria-roledescription"?: string | undefined | undefined;
+            "aria-rowcount"?: number | undefined | undefined;
+            "aria-rowindex"?: number | undefined | undefined;
+            "aria-rowindextext"?: string | undefined | undefined;
+            "aria-rowspan"?: number | undefined | undefined;
+            "aria-selected"?: (boolean | "true" | "false") | undefined;
+            "aria-setsize"?: number | undefined | undefined;
+            "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+            "aria-valuemax"?: number | undefined | undefined;
+            "aria-valuemin"?: number | undefined | undefined;
+            "aria-valuenow"?: number | undefined | undefined;
+            "aria-valuetext"?: string | undefined | undefined;
+            dangerouslySetInnerHTML?: {
+                __html: string | TrustedHTML;
+            } | undefined | undefined;
+            onCopy?: import('react').ClipboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onCopyCapture?: import('react').ClipboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onCut?: import('react').ClipboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onCutCapture?: import('react').ClipboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onPaste?: import('react').ClipboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onPasteCapture?: import('react').ClipboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onCompositionEnd?: import('react').CompositionEventHandler<HTMLTableDataCellElement> | undefined;
+            onCompositionEndCapture?: import('react').CompositionEventHandler<HTMLTableDataCellElement> | undefined;
+            onCompositionStart?: import('react').CompositionEventHandler<HTMLTableDataCellElement> | undefined;
+            onCompositionStartCapture?: import('react').CompositionEventHandler<HTMLTableDataCellElement> | undefined;
+            onCompositionUpdate?: import('react').CompositionEventHandler<HTMLTableDataCellElement> | undefined;
+            onCompositionUpdateCapture?: import('react').CompositionEventHandler<HTMLTableDataCellElement> | undefined;
+            onFocus?: import('react').FocusEventHandler<HTMLTableDataCellElement> | undefined;
+            onFocusCapture?: import('react').FocusEventHandler<HTMLTableDataCellElement> | undefined;
+            onBlur?: import('react').FocusEventHandler<HTMLTableDataCellElement> | undefined;
+            onBlurCapture?: import('react').FocusEventHandler<HTMLTableDataCellElement> | undefined;
+            onChange?: import('react').ChangeEventHandler<HTMLTableDataCellElement, Element> | undefined;
+            onChangeCapture?: import('react').ChangeEventHandler<HTMLTableDataCellElement, Element> | undefined;
+            onBeforeInput?: import('react').InputEventHandler<HTMLTableDataCellElement> | undefined;
+            onBeforeInputCapture?: import('react').InputEventHandler<HTMLTableDataCellElement> | undefined;
+            onInput?: import('react').InputEventHandler<HTMLTableDataCellElement> | undefined;
+            onInputCapture?: import('react').InputEventHandler<HTMLTableDataCellElement> | undefined;
+            onReset?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onResetCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onSubmit?: import('react').SubmitEventHandler<HTMLTableDataCellElement> | undefined;
+            onSubmitCapture?: import('react').SubmitEventHandler<HTMLTableDataCellElement> | undefined;
+            onInvalid?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onInvalidCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onLoadCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onErrorCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onKeyDown?: import('react').KeyboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onKeyDownCapture?: import('react').KeyboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onKeyPress?: import('react').KeyboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onKeyPressCapture?: import('react').KeyboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onKeyUp?: import('react').KeyboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onKeyUpCapture?: import('react').KeyboardEventHandler<HTMLTableDataCellElement> | undefined;
+            onAbort?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onAbortCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onCanPlay?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onCanPlayCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onCanPlayThrough?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onCanPlayThroughCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onDurationChange?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onDurationChangeCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onEmptied?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onEmptiedCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onEncrypted?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onEncryptedCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onEnded?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onEndedCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onLoadedData?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onLoadedDataCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onLoadedMetadata?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onLoadedMetadataCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onLoadStart?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onLoadStartCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onPause?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onPauseCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onPlay?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onPlayCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onPlaying?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onPlayingCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onProgress?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onProgressCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onRateChange?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onRateChangeCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onSeeked?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onSeekedCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onSeeking?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onSeekingCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onStalled?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onStalledCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onSuspend?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onSuspendCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onTimeUpdate?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onTimeUpdateCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onVolumeChange?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onVolumeChangeCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onWaiting?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onWaitingCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onAuxClick?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onAuxClickCapture?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onClick?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onClickCapture?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onContextMenu?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onContextMenuCapture?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onDoubleClick?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onDoubleClickCapture?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onDrag?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragCapture?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragEnd?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragEndCapture?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragEnter?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragEnterCapture?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragExit?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragExitCapture?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragLeave?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragLeaveCapture?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragOver?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragOverCapture?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragStart?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDragStartCapture?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDrop?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onDropCapture?: import('react').DragEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseDown?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseDownCapture?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseEnter?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseLeave?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseMove?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseMoveCapture?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseOut?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseOutCapture?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseOver?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseOverCapture?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseUp?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onMouseUpCapture?: import('react').MouseEventHandler<HTMLTableDataCellElement> | undefined;
+            onSelect?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onSelectCapture?: import('react').ReactEventHandler<HTMLTableDataCellElement> | undefined;
+            onTouchCancel?: import('react').TouchEventHandler<HTMLTableDataCellElement> | undefined;
+            onTouchCancelCapture?: import('react').TouchEventHandler<HTMLTableDataCellElement> | undefined;
+            onTouchEnd?: import('react').TouchEventHandler<HTMLTableDataCellElement> | undefined;
+            onTouchEndCapture?: import('react').TouchEventHandler<HTMLTableDataCellElement> | undefined;
+            onTouchMove?: import('react').TouchEventHandler<HTMLTableDataCellElement> | undefined;
+            onTouchMoveCapture?: import('react').TouchEventHandler<HTMLTableDataCellElement> | undefined;
+            onTouchStart?: import('react').TouchEventHandler<HTMLTableDataCellElement> | undefined;
+            onTouchStartCapture?: import('react').TouchEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerDown?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerDownCapture?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerMove?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerMoveCapture?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerUp?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerUpCapture?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerCancel?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerCancelCapture?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerEnter?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerLeave?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerOver?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerOverCapture?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerOut?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onPointerOutCapture?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onGotPointerCapture?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onGotPointerCaptureCapture?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onLostPointerCapture?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onLostPointerCaptureCapture?: import('react').PointerEventHandler<HTMLTableDataCellElement> | undefined;
+            onScroll?: import('react').UIEventHandler<HTMLTableDataCellElement> | undefined;
+            onScrollCapture?: import('react').UIEventHandler<HTMLTableDataCellElement> | undefined;
+            onScrollEnd?: import('react').UIEventHandler<HTMLTableDataCellElement> | undefined;
+            onScrollEndCapture?: import('react').UIEventHandler<HTMLTableDataCellElement> | undefined;
+            onWheel?: import('react').WheelEventHandler<HTMLTableDataCellElement> | undefined;
+            onWheelCapture?: import('react').WheelEventHandler<HTMLTableDataCellElement> | undefined;
+            onAnimationStart?: import('react').AnimationEventHandler<HTMLTableDataCellElement> | undefined;
+            onAnimationStartCapture?: import('react').AnimationEventHandler<HTMLTableDataCellElement> | undefined;
+            onAnimationEnd?: import('react').AnimationEventHandler<HTMLTableDataCellElement> | undefined;
+            onAnimationEndCapture?: import('react').AnimationEventHandler<HTMLTableDataCellElement> | undefined;
+            onAnimationIteration?: import('react').AnimationEventHandler<HTMLTableDataCellElement> | undefined;
+            onAnimationIterationCapture?: import('react').AnimationEventHandler<HTMLTableDataCellElement> | undefined;
+            onToggle?: import('react').ToggleEventHandler<HTMLTableDataCellElement> | undefined;
+            onBeforeToggle?: import('react').ToggleEventHandler<HTMLTableDataCellElement> | undefined;
+            onTransitionCancel?: import('react').TransitionEventHandler<HTMLTableDataCellElement> | undefined;
+            onTransitionCancelCapture?: import('react').TransitionEventHandler<HTMLTableDataCellElement> | undefined;
+            onTransitionEnd?: import('react').TransitionEventHandler<HTMLTableDataCellElement> | undefined;
+            onTransitionEndCapture?: import('react').TransitionEventHandler<HTMLTableDataCellElement> | undefined;
+            onTransitionRun?: import('react').TransitionEventHandler<HTMLTableDataCellElement> | undefined;
+            onTransitionRunCapture?: import('react').TransitionEventHandler<HTMLTableDataCellElement> | undefined;
+            onTransitionStart?: import('react').TransitionEventHandler<HTMLTableDataCellElement> | undefined;
+            onTransitionStartCapture?: import('react').TransitionEventHandler<HTMLTableDataCellElement> | undefined;
+            height?: number | string | undefined | undefined;
+            width?: number | string | undefined | undefined;
+            scope?: string | undefined | undefined;
+            align?: "left" | "center" | "right" | "justify" | "char" | undefined | undefined;
+            colSpan?: number | undefined | undefined;
+            headers?: string | undefined | undefined;
+            rowSpan?: number | undefined | undefined;
+            valign?: "top" | "middle" | "bottom" | "baseline" | undefined | undefined;
+        };
+    };
+    resizing: boolean;
+    activeDivider: string | undefined;
+    getResizeHandleProps: (header: import('@tanstack/react-table').Header<TFeatures, TData>) => import('react').ComponentPropsWithRef<"div"> | undefined;
+    virtual: boolean;
+    stickyHeader: boolean;
+    tableRef: import('react').RefObject<HTMLTableElement | null>;
+    rows: import('@tanstack/react-table').Row<TFeatures, TData>[];
+    headerGroups: import('@tanstack/react-table').HeaderGroup<TFeatures, TData>[];
+    leafHeaders: import('@tanstack/react-table').Header<TFeatures, TData, unknown>[];
+    columnWidths: number[];
+    tableWidth: number;
+    footerGroups: import('@tanstack/react-table').HeaderGroup<TFeatures, TData>[];
+    virtualizer: import('@tanstack/react-virtual').ReactVirtualizer<Window, HTMLTableRowElement>;
+    virtualRows: import('@tanstack/react-virtual').VirtualItem[];
+    scrollMargin: number;
+    dragging: boolean;
+};
+//# sourceMappingURL=useGrid.d.ts.map

package/dist/components/Collection/Grid/hooks/useGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGrid.d.ts","sourceRoot":"","sources":["../../../../../src/components/Collection/Grid/hooks/useGrid.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,IAAI,EACT,KAAK,OAAO,EACb,MAAM,uBAAuB,CAAC;AAG/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAkB,SAAS,EAAE,MAAM,UAAU,CAAC;AAK1D,wBAAgB,OAAO,CAAC,SAAS,SAAS,QAAQ,EAAE,KAAK,SAAS,OAAO,EACvE,OAAO,EAAE,SAAS,CAAC,SAAS,EAAE,KAAK,CAAC;oBAyDb,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiD9C"}

package/dist/components/Collection/Grid/hooks/useGridColumnResizing.d.ts

@@ -0,0 +1,15 @@
+import { Header, ReactTable, RowData } from '@tanstack/react-table';
+import { ComponentPropsWithRef } from 'react';
+import { Features } from '../../types';
+interface GridColumnResizingOptions<TFeatures extends Features, TData extends RowData> {
+    table: ReactTable<TFeatures, TData>;
+    enabled: boolean;
+    direction: 'ltr' | 'rtl';
+}
+export declare function useGridColumnResizing<TFeatures extends Features, TData extends RowData>({ table, enabled, direction }: GridColumnResizingOptions<TFeatures, TData>): {
+    resizing: boolean;
+    activeDivider: string | undefined;
+    getResizeHandleProps: (header: Header<TFeatures, TData>) => ComponentPropsWithRef<"div"> | undefined;
+};
+export {};
+//# sourceMappingURL=useGridColumnResizing.d.ts.map

package/dist/components/Collection/Grid/hooks/useGridColumnResizing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGridColumnResizing.d.ts","sourceRoot":"","sources":["../../../../../src/components/Collection/Grid/hooks/useGridColumnResizing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,MAAM,EACN,UAAU,EACV,OAAO,EACR,MAAM,uBAAuB,CAAC;AAS/B,OAAO,EAAY,KAAK,qBAAqB,EAAE,MAAM,OAAO,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,UAAU,yBAAyB,CACjC,SAAS,SAAS,QAAQ,EAC1B,KAAK,SAAS,OAAO;IAErB,KAAK,EAAE,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC;CAC1B;AAED,wBAAgB,qBAAqB,CACnC,SAAS,SAAS,QAAQ,EAC1B,KAAK,SAAS,OAAO,EACrB,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,yBAAyB,CAAC,SAAS,EAAE,KAAK,CAAC;;;mCAOhE,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,KAC/B,qBAAqB,CAAC,KAAK,CAAC,GAAG,SAAS;EAyD5C"}

package/dist/components/Collection/Grid/hooks/useGridDragSelection.d.ts

@@ -0,0 +1,11 @@
+import { MouseEvent, RefObject } from 'react';
+interface GridDragSelectionOptions {
+    tableRef: RefObject<HTMLTableElement | null>;
+    onExtend: (cell: HTMLTableCellElement) => void;
+}
+export declare function useGridDragSelection({ tableRef, onExtend, }: GridDragSelectionOptions): {
+    dragging: boolean;
+    start: (event: MouseEvent<HTMLTableCellElement>) => void;
+};
+export {};
+//# sourceMappingURL=useGridDragSelection.d.ts.map

package/dist/components/Collection/Grid/hooks/useGridDragSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGridDragSelection.d.ts","sourceRoot":"","sources":["../../../../../src/components/Collection/Grid/hooks/useGridDragSelection.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,UAAU,EACf,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAEf,UAAU,wBAAwB;IAChC,QAAQ,EAAE,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAC7C,QAAQ,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,IAAI,CAAC;CAChD;AAiBD,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,QAAQ,GACT,EAAE,wBAAwB;;mBAYf,UAAU,CAAC,oBAAoB,CAAC;EAgH3C"}

package/dist/components/Collection/Grid/hooks/useGridSelection.d.ts

@@ -0,0 +1,19 @@
+import { Cell, ReactTable, RowData } from '@tanstack/react-table';
+import { RefObject } from 'react';
+import { Features } from '../../types';
+import { GridCellProps } from '../componnets/GridCell';
+interface GridSelectionOptions<TFeatures extends Features, TData extends RowData> {
+    table: ReactTable<TFeatures, TData>;
+    tableRef: RefObject<HTMLTableElement | null>;
+}
+export declare function useGridSelection<TFeatures extends Features, TData extends RowData>({ table, tableRef }: GridSelectionOptions<TFeatures, TData>): {
+    activeRowId: string | undefined;
+    dragging: boolean;
+    getCellSelection: (cell: Cell<TFeatures, TData>) => {
+        canSelect: boolean;
+        isEditing: boolean;
+        props: GridCellProps;
+    };
+};
+export {};
+//# sourceMappingURL=useGridSelection.d.ts.map

package/dist/components/Collection/Grid/hooks/useGridSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGridSelection.d.ts","sourceRoot":"","sources":["../../../../../src/components/Collection/Grid/hooks/useGridSelection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAUvE,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EACV,aAAa,EAEd,MAAM,wBAAwB,CAAC;AAIhC,UAAU,oBAAoB,CAC5B,SAAS,SAAS,QAAQ,EAC1B,KAAK,SAAS,OAAO;IAErB,KAAK,EAAE,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IACpC,QAAQ,EAAE,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;CAC9C;AAYD,wBAAgB,gBAAgB,CAC9B,SAAS,SAAS,QAAQ,EAC1B,KAAK,SAAS,OAAO,EACrB,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,oBAAoB,CAAC,SAAS,EAAE,KAAK,CAAC;;;6BAkB3B,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC;;;;;EAyHvD"}

package/dist/components/Collection/Grid/hooks/useGridVirtualizer.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+interface GridVirtualizerOptions {
+    tableRef: RefObject<HTMLTableElement | null>;
+    enabled: boolean;
+    count: number;
+    getItemKey: (index: number) => string;
+    focusedRowIndex: number;
+}
+export declare function useGridVirtualizer({ tableRef, enabled, count, getItemKey, focusedRowIndex, }: GridVirtualizerOptions): import('@tanstack/react-virtual').ReactVirtualizer<Window, HTMLTableRowElement>;
+export {};
+//# sourceMappingURL=useGridVirtualizer.d.ts.map

package/dist/components/Collection/Grid/hooks/useGridVirtualizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGridVirtualizer.d.ts","sourceRoot":"","sources":["../../../../../src/components/Collection/Grid/hooks/useGridVirtualizer.ts"],"names":[],"mappings":"AAKA,OAAO,EAA0C,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE/E,UAAU,sBAAsB;IAC9B,QAAQ,EAAE,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACtC,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,OAAO,EACP,KAAK,EACL,UAAU,EACV,eAAe,GAChB,EAAE,sBAAsB,mFAyExB"}

package/dist/components/Collection/Grid/index.d.ts

@@ -0,0 +1,6 @@
+export { Grid } from './Grid';
+export type { GridProps } from './Grid';
+export { GridCell } from './componnets/GridCell';
+export type { GridCellProps, GridCellSelectionEdge, } from './componnets/GridCell';
+export type { GridCellAddress, GridCellUpdate, GridUpdates } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Collection/Grid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/Collection/Grid/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,YAAY,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,YAAY,EACV,aAAa,EACb,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/components/Collection/Grid/types.d.ts

@@ -0,0 +1,18 @@
+import { OnChangeFn, RowData, TableOptions } from '@tanstack/react-table';
+import { Features } from '../types';
+export interface GridCellAddress {
+    rowId: string;
+    columnId: string;
+}
+export interface GridCellUpdate<TValue = unknown> {
+    old: TValue;
+    new: TValue;
+}
+export type GridUpdates = ReadonlyMap<GridCellAddress, GridCellUpdate>;
+export type GridProps<TFeatures extends Features, TData extends RowData> = TableOptions<TFeatures, TData> & Required<Pick<TableOptions<TFeatures, TData>, 'getRowId'>> & {
+    virtual?: boolean;
+    stickyHeader?: boolean;
+    updates?: GridUpdates;
+    onUpdatesChange?: OnChangeFn<GridUpdates>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/components/Collection/Grid/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/components/Collection/Grid/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc,CAAC,MAAM,GAAG,OAAO;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;AAEvE,MAAM,MAAM,SAAS,CACnB,SAAS,SAAS,QAAQ,EAC1B,KAAK,SAAS,OAAO,IACnB,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,GAChC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,UAAU,CAAC,CAAC,GAAG;IAC3D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,eAAe,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;CAC3C,CAAC"}

package/dist/components/Collection/Pagination/Pagination.d.ts

@@ -0,0 +1,12 @@
+import { ComponentPropsWithoutRef } from 'react';
+export interface PaginationProps extends Omit<ComponentPropsWithoutRef<'nav'>, 'children' | 'onChange'> {
+    total: number;
+    pageNum: number;
+    pageSize: number;
+    onPageNumChange: (pageNum: number) => void;
+    onPageSizeChange: (pageSize: number) => void;
+    pageSizeOptions?: readonly number[];
+    className?: string;
+}
+export declare function Pagination({ total, pageNum, pageSize, onPageNumChange, onPageSizeChange, pageSizeOptions, className, ...restProps }: PaginationProps): import('react').JSX.Element;
+//# sourceMappingURL=Pagination.d.ts.map

package/dist/components/Collection/Pagination/Pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pagination.d.ts","sourceRoot":"","sources":["../../../../src/components/Collection/Pagination/Pagination.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,OAAO,CAAC;AAKtD,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAC3C,wBAAwB,CAAC,KAAK,CAAC,EAC/B,UAAU,GAAG,UAAU,CACxB;IACC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,OAAO,EACP,QAAQ,EACR,eAAe,EACf,gBAAgB,EAChB,eAAmC,EACnC,SAAS,EACT,GAAG,SAAS,EACb,EAAE,eAAe,+BAoEjB"}

package/dist/components/Collection/Pagination/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/Collection/Pagination/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/components/Collection/Report/Report.d.ts

@@ -0,0 +1,5 @@
+import { RowData } from '@tanstack/react-table';
+import { Features } from '../types';
+import { ReportProps } from './types';
+export declare function Report<TFeatures extends Features, TData extends RowData>({ stickyHeader, loading, emptyState, footer, ref, style, className, ...options }: ReportProps<TFeatures, TData>): import('react').JSX.Element;
+//# sourceMappingURL=Report.d.ts.map

package/dist/components/Collection/Report/Report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Report.d.ts","sourceRoot":"","sources":["../../../../src/components/Collection/Report/Report.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,OAAO,EAGb,MAAM,uBAAuB,CAAC;AAsB/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAK3C,wBAAgB,MAAM,CAAC,SAAS,SAAS,QAAQ,EAAE,KAAK,SAAS,OAAO,EAAE,EACxE,YAAoB,EACpB,OAAe,EACf,UAAU,EACV,MAAM,EACN,GAAG,EACH,KAAK,EACL,SAAS,EACT,GAAG,OAAO,EACX,EAAE,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,+BAoU/B"}

package/dist/components/Collection/Report/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useColumnResizing } from './useColumnResizing';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Collection/Report/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/Collection/Report/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/components/Collection/Report/hooks/useColumnResizing.d.ts

@@ -0,0 +1,19 @@
+import { Header, ReactTable, RowData } from '@tanstack/react-table';
+import { ComponentPropsWithRef } from 'react';
+import { Features } from '../../types';
+interface ColumnResizingOptions<TFeatures extends Features, TData extends RowData> {
+    table: ReactTable<TFeatures, TData>;
+    enabled: boolean;
+    loading: boolean;
+    direction: 'ltr' | 'rtl';
+}
+type ResizeHandleProps = ComponentPropsWithRef<'div'> & {
+    'data-disabled'?: boolean;
+};
+export declare function useColumnResizing<TFeatures extends Features, TData extends RowData>({ table, enabled, loading, direction, }: ColumnResizingOptions<TFeatures, TData>): {
+    resizing: boolean;
+    activeDivider: string | undefined;
+    getResizeHandleProps: (header: Header<TFeatures, TData>) => ResizeHandleProps | undefined;
+};
+export {};
+//# sourceMappingURL=useColumnResizing.d.ts.map

package/dist/components/Collection/Report/hooks/useColumnResizing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useColumnResizing.d.ts","sourceRoot":"","sources":["../../../../../src/components/Collection/Report/hooks/useColumnResizing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,MAAM,EACN,UAAU,EACV,OAAO,EACR,MAAM,uBAAuB,CAAC;AAS/B,OAAO,EAAY,KAAK,qBAAqB,EAAE,MAAM,OAAO,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,UAAU,qBAAqB,CAC7B,SAAS,SAAS,QAAQ,EAC1B,KAAK,SAAS,OAAO;IAErB,KAAK,EAAE,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC;CAC1B;AAED,KAAK,iBAAiB,GAAG,qBAAqB,CAAC,KAAK,CAAC,GAAG;IACtD,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,wBAAgB,iBAAiB,CAC/B,SAAS,SAAS,QAAQ,EAC1B,KAAK,SAAS,OAAO,EACrB,EACA,KAAK,EACL,OAAO,EACP,OAAO,EACP,SAAS,GACV,EAAE,qBAAqB,CAAC,SAAS,EAAE,KAAK,CAAC;;;mCAO9B,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,KAC/B,iBAAiB,GAAG,SAAS;EA8DjC"}

package/dist/components/Collection/Report/index.d.ts

@@ -0,0 +1,3 @@
+export { Report } from './Report';
+export type { ReportProps } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Collection/Report/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/Collection/Report/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/components/Collection/Report/types.d.ts

@@ -0,0 +1,12 @@
+import { RowData, TableOptions } from '@tanstack/react-table';
+import { ComponentPropsWithRef, ReactNode } from 'react';
+import { Features } from '../types';
+/** ColumnDef.footer renders summary rows beneath the column headers. */
+export type ReportProps<TFeatures extends Features, TData extends RowData> = TableOptions<TFeatures, TData> & Pick<ComponentPropsWithRef<'div'>, 'ref' | 'style' | 'className'> & {
+    stickyHeader?: boolean;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    /** Content rendered below the horizontal scrollbar. */
+    footer?: ReactNode;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/components/Collection/Report/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/components/Collection/Report/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,qBAAqB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,wEAAwE;AACxE,MAAM,MAAM,WAAW,CACrB,SAAS,SAAS,QAAQ,EAC1B,KAAK,SAAS,OAAO,IACnB,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,GAChC,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,WAAW,CAAC,GAAG;IAClE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,uDAAuD;IACvD,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB,CAAC"}

package/dist/components/Collection/Table/Table.d.ts

@@ -0,0 +1,17 @@
+import { Row, RowData, TableOptions } from '@tanstack/react-table';
+import { Ref } from 'react';
+import { ComplexAction } from '../../../types';
+import { Features } from '../types';
+export type TableProps<TFeatures extends Features, TData extends RowData> = TableOptions<TFeatures, TData> & {
+    ref?: Ref<HTMLDivElement>;
+    stickyHeader?: boolean;
+    selectable?: 'rowSelectionFeature' extends keyof TFeatures ? boolean : false;
+    renderExpandedContent?: 'rowExpandingFeature' extends keyof TFeatures ? (row: Row<TFeatures, TData>) => React.ReactNode : never;
+    promotedBulkActions?: readonly ComplexAction[];
+    bulkActions?: readonly ComplexAction[];
+    footer?: React.ReactNode;
+    loading?: boolean;
+    emptyState?: React.ReactNode;
+};
+export declare function Table<TFeatures extends Features, TData extends RowData>({ ref, stickyHeader, selectable, renderExpandedContent, promotedBulkActions, bulkActions, footer, loading, emptyState, ...options }: TableProps<TFeatures, TData>): import('react').JSX.Element;
+//# sourceMappingURL=Table.d.ts.map

package/dist/components/Collection/Table/Table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Table.d.ts","sourceRoot":"","sources":["../../../../src/components/Collection/Table/Table.tsx"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,GAAG,EACR,KAAK,OAAO,EAEZ,KAAK,YAAY,EAElB,MAAM,uBAAuB,CAAC;AAwB/B,OAAO,EAML,KAAK,GAAG,EACT,MAAM,OAAO,CAAC;AAKf,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAOzC,MAAM,MAAM,UAAU,CACpB,SAAS,SAAS,QAAQ,EAC1B,KAAK,SAAS,OAAO,IACnB,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,GAAG;IACnC,GAAG,CAAC,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,qBAAqB,SAAS,MAAM,SAAS,GAAG,OAAO,GAAG,KAAK,CAAC;IAC7E,qBAAqB,CAAC,EAAE,qBAAqB,SAAS,MAAM,SAAS,GACjE,CAAC,GAAG,EAAE,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,KAAK,KAAK,CAAC,SAAS,GAC/C,KAAK,CAAC;IACV,mBAAmB,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC/C,WAAW,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IACvC,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC9B,CAAC;AAEF,wBAAgB,KAAK,CAAC,SAAS,SAAS,QAAQ,EAAE,KAAK,SAAS,OAAO,EAAE,EACvE,GAAG,EACH,YAAoB,EACpB,UAAkB,EAClB,qBAAqB,EACrB,mBAAwB,EACxB,WAAgB,EAChB,MAAM,EACN,OAAe,EACf,UAAU,EACV,GAAG,OAAO,EACX,EAAE,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,+BA6b9B"}

package/dist/components/Collection/Table/componnets/BulkActions/BulkActions.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { ComplexAction } from '../../../../../types';
+export interface BulkActionsProps {
+    checkbox: ReactNode;
+    checkboxOffset?: number;
+    count: number;
+    disabled?: boolean;
+    onClear: () => void;
+    promotedActions?: readonly ComplexAction[];
+    actions?: readonly ComplexAction[];
+}
+export declare function BulkActions({ checkbox, checkboxOffset, count, disabled, onClear, promotedActions, actions, }: BulkActionsProps): import('react').JSX.Element;
+//# sourceMappingURL=BulkActions.d.ts.map

package/dist/components/Collection/Table/componnets/BulkActions/BulkActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BulkActions.d.ts","sourceRoot":"","sources":["../../../../../../src/components/Collection/Table/componnets/BulkActions/BulkActions.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAI7C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,SAAS,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,eAAe,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACpC;AAYD,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,cAAkB,EAClB,KAAK,EACL,QAAgB,EAChB,OAAO,EACP,eAAoB,EACpB,OAAY,GACb,EAAE,gBAAgB,+BAyDlB"}

package/dist/components/Collection/Table/componnets/BulkActions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/components/Collection/Table/componnets/BulkActions/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/components/Collection/Table/index.d.ts

@@ -0,0 +1,3 @@
+export { Table } from './Table';
+export type { TableProps } from './Table';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Collection/Table/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/Collection/Table/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}