@heliux-org/design-system-core 0.0.306-Test → 0.0.306

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/components/VirtualScroll.d.ts

@@ -0,0 +1,76 @@
+import * as React from 'react';
+export type VirtualScrollProps = {
+    /**
+     * Length of the items to virtualize.
+     */
+    itemsLength: number;
+    /**
+     * Single item render function, which gives index of the item (0 based) in the data array
+     * and expects to get the JSX of that element to render.
+     * Recommended to memoize the reference of the function.
+     */
+    itemRenderer: (index: number) => JSX.Element;
+    /**
+     * Number of items to be rendered at the start and the end.
+     * Not recommended to go lower than the visible items in viewport.
+     * @default 10
+     */
+    bufferSize?: number;
+    /**
+     * Index of the first element on initial render.
+     */
+    scrollToIndex?: number;
+} & React.ComponentPropsWithRef<'div'>;
+/**
+ * `VirtualScroll` component is used to render a huge amount of items in the DOM. It renders only the ones which are visible
+ * and the amount provided through `bufferSize` prop at the start and the end. Can be used inside other components like `Table`.
+ *
+ * It has two wrapper elements, so DOM will be changed. One is used for setting full expected height in the scrollable container
+ * and other is for transformation (translateY) to show the correct part of the list.
+ *
+ * Currently it works only with the direct vertically scrollable parent element. It does not work with body scroll.
+ * It supports only static (same) height rows virtualization. Expect some issues, if list consists of different height elements.
+ * @example
+ * const itemRenderer = React.useCallback(() => (
+ *  <div key={index}>
+ *    This is my item #{index}
+ *  </div>
+ * ), [])
+ * <VirtualScroll
+ *  itemsLength={1000}
+ *  itemRenderer={itemRenderer}
+ * />
+ * @private
+ */
+export declare const VirtualScroll: React.ForwardRefExoticComponent<Omit<VirtualScrollProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * `useVirtualization` is used for efficiently rendering only the visible rows from a large list.
+ * It returns `outerProps` and `innerProps`, which need to be applied on 2 container elements and `visibleChildren` which is a list of virtualized items.
+ * @example
+ * const itemRenderer = React.useCallback((index: number) => (
+ *  <li key={index}>
+ *    This is my item #{index}
+ *  </li>
+ * ), [])
+ *
+ * const { outerProps, innerProps, visibleChildren } = useVirtualization({itemsLength: 1000, itemRenderer: itemRenderer});
+ * return (
+ *  <div {...outerProps}>
+ *   <ul {...innerProps}>
+ *    {visibleChildren}
+ *   </ul>
+ *  </div>
+ * );
+ * @private
+ */
+export declare const useVirtualization: (props: VirtualScrollProps) => {
+    outerProps: React.HTMLAttributes<HTMLElement>;
+    innerProps: {
+        readonly style: {
+            readonly willChange: "transform";
+        };
+        readonly ref: (instance: HTMLElement) => void;
+    };
+    visibleChildren: JSX.Element[];
+};
+//# sourceMappingURL=VirtualScroll.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/components/VirtualScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualScroll.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/components/VirtualScroll.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AA8E/B,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,GAAG,CAAC,OAAO,CAAC;IAC7C;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,KAAK,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,wGAWxB,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,iBAAiB,UAAW,kBAAkB;;;;;;;;;CAqR1D,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/components/WithCSSTransition.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { CSSTransition } from "react-transition-group";
+export declare const WithCSSTransition: (props: Partial<React.ComponentPropsWithoutRef<typeof CSSTransition>> & {
+    children: JSX.Element;
+    dimension?: "height" | "width";
+}) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=WithCSSTransition.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/components/WithCSSTransition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WithCSSTransition.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/components/WithCSSTransition.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAGvD,eAAO,MAAM,iBAAiB,UACrB,QAAQ,MAAM,wBAAwB,CAAC,oBAAoB,CAAC,CAAC,GAAG;IACrE,QAAQ,EAAE,WAAW,CAAC;IACtB,SAAS,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;CAChC,4CAoDF,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/components/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/components/index.ts"],"names":[],"mappings":""}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/colors.d.ts

@@ -0,0 +1,21 @@
+export declare const SoftBackgrounds: {
+    readonly skyblue: "var(--iui-color-background-skyblue)";
+    readonly celery: "var(--iui-color-background-celery)";
+    readonly froly: "var(--iui-color-background-froly)";
+    readonly steelblue: "var(--iui-color-background-steelblue)";
+    readonly sunglow: "var(--iui-color-background-sunglow)";
+    readonly seabuckthorn: "var(--iui-color-background-seabuckthorn)";
+    readonly montecarlo: "var(--iui-color-background-montecarlo)";
+    readonly poloblue: "var(--iui-color-background-poloblue)";
+    readonly bouquet: "var(--iui-color-background-bouquet)";
+    readonly ash: "var(--iui-color-background-ash)";
+    readonly oak: "var(--iui-color-background-oak)";
+};
+/** Returns true if a string value is one of the SoftBackgrounds keys */
+export declare const isSoftBackground: (value: string) => value is "skyblue" | "celery" | "froly" | "steelblue" | "sunglow" | "seabuckthorn" | "montecarlo" | "poloblue" | "bouquet" | "ash" | "oak";
+/**
+ * Generate color from user name or email.
+ * Recommended to use for `backgroundColor` in `Avatar` component.
+ */
+export declare const getUserColor: (emailOrName: string) => "var(--iui-color-background-skyblue)" | "var(--iui-color-background-celery)" | "var(--iui-color-background-froly)" | "var(--iui-color-background-steelblue)" | "var(--iui-color-background-sunglow)" | "var(--iui-color-background-seabuckthorn)" | "var(--iui-color-background-montecarlo)" | "var(--iui-color-background-poloblue)" | "var(--iui-color-background-bouquet)" | "var(--iui-color-background-ash)" | "var(--iui-color-background-oak)";
+//# sourceMappingURL=colors.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/colors.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;CAYlB,CAAC;AAEX,wEAAwE;AACxE,eAAO,MAAM,gBAAgB,UACpB,MAAM,+IAGd,CAAC;AAIF;;;GAGG;AACH,eAAO,MAAM,YAAY,gBAAiB,MAAM,0bAS/C,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/date.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Return true if the first date is earlier than the second date
+ */
+export declare const isBefore: (beforeDate: Date | undefined, afterDate: Date | undefined) => boolean;
+//# sourceMappingURL=date.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/date.ts"],"names":[],"mappings":"AAKA;;GAEG;AAEH,eAAO,MAAM,QAAQ,eACP,IAAI,GAAG,SAAS,aACjB,IAAI,GAAG,SAAS,YAU5B,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/dev.d.ts

@@ -0,0 +1,12 @@
+declare const isUnitTest: boolean;
+declare let isDev: boolean;
+/**
+ * Logs message one time only in dev environments.
+ *
+ * @example
+ * const logWarningInDev = createWarningLogger();
+ * logWarningInDev("please don't use this")
+ */
+declare const createWarningLogger: () => (message: string) => void;
+export { isUnitTest, isDev, createWarningLogger };
+//# sourceMappingURL=dev.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/dev.ts"],"names":[],"mappings":"AAaA,QAAA,MAAM,UAAU,SAAgC,CAAC;AAEjD,QAAA,IAAI,KAAK,SAAQ,CAAC;AAOlB;;;;;;GAMG;AACH,QAAA,MAAM,mBAAmB,kBAIF,MAAM,SAMxB,CAAC;AAEN,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/dom.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+/**
+ * Get document if it is defined.
+ * Used to support SSR/SSG applications.
+ */
+export declare const getDocument: () => Document;
+/**
+ * Get window if it is defined.
+ * Used to support SSR/SSG applications.
+ */
+export declare const getWindow: () => Window & typeof globalThis;
+/**
+ * Merges multiple event handlers into one, while making sure that
+ * `defaultPrevented` is respected for each callback.
+ */
+export declare const mergeEventHandlers: <E extends import("react").SyntheticEvent<Element, Event>>(...callbacks: ((event: E) => void)[]) => (event: E) => void;
+/**
+ * Returns translate values as an array of a given element.
+ * @param element HTML element you want to get translate value of
+ * @returns Translate values in pixels in an array `[translateX, translateY]`
+ */
+export declare const getTranslateValuesFromElement: (element: HTMLElement | null | undefined) => number[];
+export declare const getTranslateValues: (transformValue: string) => number[];
+//# sourceMappingURL=dom.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/dom.ts"],"names":[],"mappings":";AAKA;;;GAGG;AACH,eAAO,MAAM,WAAW,gBAEvB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS,kCAErB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,0FAEQ,IAAI,0BASxC,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,YAC/B,WAAW,GAAG,IAAI,GAAG,SAAS,aAUxC,CAAC;AAEF,eAAO,MAAM,kBAAkB,mBAAoB,MAAM,aAGxD,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/focusable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Return array of tabbable elements in the container.
+ */
+export declare const getTabbableElements: (container: HTMLElement | undefined | null) => Element[];
+/**
+ * Return array of focusable elements in the container.
+ */
+export declare const getFocusableElements: (container: HTMLElement | undefined | null) => Element[];
+//# sourceMappingURL=focusable.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/focusable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focusable.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/focusable.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,eAAO,MAAM,mBAAmB,cACnB,WAAW,GAAG,SAAS,GAAG,IAAI,cAc1C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,cACpB,WAAW,GAAG,SAAS,GAAG,IAAI,cAgB1C,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/import.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Wrapper around native CSS module scripts (import attributes) for dynamic imports.
+ * In unsupported browsers, it gracefully degrades to import assertions, and then `fetch`.
+ *
+ * Returns a constructable CSSStyleSheet object that can be adopted.
+ *
+ * @see https://web.dev/articles/css-module-scripts
+ * @see https://github.com/tc39/proposal-import-attributes
+ */
+export declare const importCss: (url: string) => Promise<{
+    default: CSSStyleSheet;
+}>;
+//# sourceMappingURL=import.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/import.ts"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,QACf,MAAM,KACV,QAAQ;IAAE,OAAO,EAAE,aAAa,CAAA;CAAE,CAoBpC,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./date";
+export * from "./dom";
+export * from "./colors";
+export * from "./numbers";
+export * from "./focusable";
+export * from "./supports";
+export * from "./polymorphic";
+export * from "./import";
+export * from "./react";
+export * from "./dev";
+//# sourceMappingURL=index.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/index.ts"],"names":[],"mappings":"AAIA,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/numbers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Return input value bounded by specified range.
+ */
+export declare const getBoundedValue: (val: number, min: number, max: number) => number;
+/**
+ * Returns a random value of a given length containing `A-Za-z0-9_-` symbols.
+ */
+export declare const getRandomValue: (length?: number) => string;
+/**
+ * Rounds a pixel value based on the device's pixel ratio. This ensures that values can be
+ * placed evenly on the device’s pixel grid, avoiding any blurring.
+ *
+ * @see https://floating-ui.com/docs/misc#subpixel-and-accelerated-positioning
+ */
+export declare const roundByDPR: (value: number) => number;
+//# sourceMappingURL=numbers.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/numbers.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,eAAO,MAAM,eAAe,QAAS,MAAM,OAAO,MAAM,OAAO,MAAM,WAEpE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,6BAO1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,UAAW,MAAM,WAGvC,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/polymorphic.d.ts

@@ -0,0 +1,203 @@
+import * as React from "react";
+import type { PolymorphicForwardRefComponent } from "../props";
+/**
+ * Utility to create a type-safe polymorphic component with a simple class.
+ *
+ * Can be called directly or as a property of the `polymorphic` object.
+ * In both cases, returns a component that:
+ * - uses CSS-modules scoped classes
+ * - supports `as` prop with default element
+ * - forwards ref and spreads rest props
+ * - adds and merges CSS classes
+ * - adds tabIndex to interactive elements (Safari workaround)
+ *
+ * @example
+ * const MyPolyDiv = polymorphic('my-poly-div');
+ * <MyPolyDiv>...</MyPolyDiv>;
+ *
+ * @example
+ * const MyPolyButton = polymorphic.button('my-poly-button', { type: 'button' });
+ * <MyPolyButton as='a' href='#'>...</MyPolyButton>;
+ *
+ * @private
+ */
+export declare const polymorphic: ((className: string, attrs?: React.SVGProps<SVGSymbolElement> | React.DetailedHTMLProps<React.ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement> | React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> | React.DetailedHTMLProps<React.AreaHTMLAttributes<HTMLAreaElement>, HTMLAreaElement> | React.DetailedHTMLProps<React.AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement> | React.DetailedHTMLProps<React.BaseHTMLAttributes<HTMLBaseElement>, HTMLBaseElement> | React.DetailedHTMLProps<React.BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLBodyElement>, HTMLBodyElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLBRElement>, HTMLBRElement> | React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement> | React.DetailedHTMLProps<React.CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement> | React.DetailedHTMLProps<React.ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement> | React.DetailedHTMLProps<React.ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement> | React.DetailedHTMLProps<React.DataHTMLAttributes<HTMLDataElement>, HTMLDataElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLDataListElement>, HTMLDataListElement> | React.DetailedHTMLProps<React.DelHTMLAttributes<HTMLModElement>, HTMLModElement> | React.DetailedHTMLProps<React.DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement> | React.DetailedHTMLProps<React.DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLDListElement>, HTMLDListElement> | React.DetailedHTMLProps<React.EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement> | React.DetailedHTMLProps<React.FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement> | React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadElement>, HTMLHeadElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLHRElement>, HTMLHRElement> | React.DetailedHTMLProps<React.HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement> | React.DetailedHTMLProps<React.IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement> | React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement> | React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> | React.DetailedHTMLProps<React.InsHTMLAttributes<HTMLModElement>, HTMLModElement> | React.DetailedHTMLProps<React.KeygenHTMLAttributes<HTMLElement>, HTMLElement> | React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLLegendElement>, HTMLLegendElement> | React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement> | React.DetailedHTMLProps<React.LinkHTMLAttributes<HTMLLinkElement>, HTMLLinkElement> | React.DetailedHTMLProps<React.MapHTMLAttributes<HTMLMapElement>, HTMLMapElement> | React.DetailedHTMLProps<React.MenuHTMLAttributes<HTMLElement>, HTMLElement> | React.DetailedHTMLProps<React.MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement> | React.DetailedHTMLProps<React.MeterHTMLAttributes<HTMLMeterElement>, HTMLMeterElement> | React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement> | React.DetailedHTMLProps<React.OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement> | React.DetailedHTMLProps<React.OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement> | React.DetailedHTMLProps<React.OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement> | React.DetailedHTMLProps<React.ParamHTMLAttributes<HTMLParamElement>, HTMLParamElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLPreElement>, HTMLPreElement> | React.DetailedHTMLProps<React.ProgressHTMLAttributes<HTMLProgressElement>, HTMLProgressElement> | React.DetailedHTMLProps<React.QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement> | React.DetailedHTMLProps<React.SlotHTMLAttributes<HTMLSlotElement>, HTMLSlotElement> | React.DetailedHTMLProps<React.ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement> | React.DetailedHTMLProps<React.SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement> | React.DetailedHTMLProps<React.SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement> | React.DetailedHTMLProps<React.StyleHTMLAttributes<HTMLStyleElement>, HTMLStyleElement> | React.DetailedHTMLProps<React.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement> | React.DetailedHTMLProps<React.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement> | React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement> | React.DetailedHTMLProps<React.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement> | React.DetailedHTMLProps<React.TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLTitleElement>, HTMLTitleElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement> | React.DetailedHTMLProps<React.TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement> | React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement> | React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement> | React.DetailedHTMLProps<React.WebViewHTMLAttributes<HTMLWebViewElement>, HTMLWebViewElement> | React.SVGProps<SVGSVGElement> | React.SVGProps<SVGElement> | React.SVGProps<SVGCircleElement> | React.SVGProps<SVGClipPathElement> | React.SVGProps<SVGDefsElement> | React.SVGProps<SVGDescElement> | React.SVGProps<SVGEllipseElement> | React.SVGProps<SVGFEBlendElement> | React.SVGProps<SVGFEColorMatrixElement> | React.SVGProps<SVGFEComponentTransferElement> | React.SVGProps<SVGFECompositeElement> | React.SVGProps<SVGFEConvolveMatrixElement> | React.SVGProps<SVGFEDiffuseLightingElement> | React.SVGProps<SVGFEDisplacementMapElement> | React.SVGProps<SVGFEDistantLightElement> | React.SVGProps<SVGFEDropShadowElement> | React.SVGProps<SVGFEFloodElement> | React.SVGProps<SVGFEFuncAElement> | React.SVGProps<SVGFEFuncBElement> | React.SVGProps<SVGFEFuncGElement> | React.SVGProps<SVGFEFuncRElement> | React.SVGProps<SVGFEGaussianBlurElement> | React.SVGProps<SVGFEImageElement> | React.SVGProps<SVGFEMergeElement> | React.SVGProps<SVGFEMergeNodeElement> | React.SVGProps<SVGFEMorphologyElement> | React.SVGProps<SVGFEOffsetElement> | React.SVGProps<SVGFEPointLightElement> | React.SVGProps<SVGFESpecularLightingElement> | React.SVGProps<SVGFESpotLightElement> | React.SVGProps<SVGFETileElement> | React.SVGProps<SVGFETurbulenceElement> | React.SVGProps<SVGFilterElement> | React.SVGProps<SVGForeignObjectElement> | React.SVGProps<SVGGElement> | React.SVGProps<SVGImageElement> | React.SVGLineElementAttributes<SVGLineElement> | React.SVGProps<SVGLinearGradientElement> | React.SVGProps<SVGMarkerElement> | React.SVGProps<SVGMaskElement> | React.SVGProps<SVGMetadataElement> | React.SVGProps<SVGPathElement> | React.SVGProps<SVGPatternElement> | React.SVGProps<SVGPolygonElement> | React.SVGProps<SVGPolylineElement> | React.SVGProps<SVGRadialGradientElement> | React.SVGProps<SVGRectElement> | React.SVGProps<SVGStopElement> | React.SVGProps<SVGSwitchElement> | React.SVGTextElementAttributes<SVGTextElement> | React.SVGProps<SVGTextPathElement> | React.SVGProps<SVGTSpanElement> | React.SVGProps<SVGUseElement> | React.SVGProps<SVGViewElement>) => PolymorphicForwardRefComponent<NonNullable<keyof JSX.IntrinsicElements>, {}>) & {
+    a: (className: string, attrs?: React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>) => PolymorphicForwardRefComponent<"a", {}>;
+    abbr: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"abbr", {}>;
+    address: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"address", {}>;
+    area: (className: string, attrs?: React.DetailedHTMLProps<React.AreaHTMLAttributes<HTMLAreaElement>, HTMLAreaElement>) => PolymorphicForwardRefComponent<"area", {}>;
+    article: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"article", {}>;
+    aside: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"aside", {}>;
+    audio: (className: string, attrs?: React.DetailedHTMLProps<React.AudioHTMLAttributes<HTMLAudioElement>, HTMLAudioElement>) => PolymorphicForwardRefComponent<"audio", {}>;
+    b: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"b", {}>;
+    base: (className: string, attrs?: React.DetailedHTMLProps<React.BaseHTMLAttributes<HTMLBaseElement>, HTMLBaseElement>) => PolymorphicForwardRefComponent<"base", {}>;
+    bdi: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"bdi", {}>;
+    bdo: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"bdo", {}>;
+    big: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"big", {}>;
+    blockquote: (className: string, attrs?: React.DetailedHTMLProps<React.BlockquoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>) => PolymorphicForwardRefComponent<"blockquote", {}>;
+    body: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLBodyElement>, HTMLBodyElement>) => PolymorphicForwardRefComponent<"body", {}>;
+    br: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLBRElement>, HTMLBRElement>) => PolymorphicForwardRefComponent<"br", {}>;
+    button: (className: string, attrs?: React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>) => PolymorphicForwardRefComponent<"button", {}>;
+    canvas: (className: string, attrs?: React.DetailedHTMLProps<React.CanvasHTMLAttributes<HTMLCanvasElement>, HTMLCanvasElement>) => PolymorphicForwardRefComponent<"canvas", {}>;
+    caption: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"caption", {}>;
+    center: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"center", {}>;
+    cite: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"cite", {}>;
+    code: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"code", {}>;
+    col: (className: string, attrs?: React.DetailedHTMLProps<React.ColHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>) => PolymorphicForwardRefComponent<"col", {}>;
+    colgroup: (className: string, attrs?: React.DetailedHTMLProps<React.ColgroupHTMLAttributes<HTMLTableColElement>, HTMLTableColElement>) => PolymorphicForwardRefComponent<"colgroup", {}>;
+    data: (className: string, attrs?: React.DetailedHTMLProps<React.DataHTMLAttributes<HTMLDataElement>, HTMLDataElement>) => PolymorphicForwardRefComponent<"data", {}>;
+    datalist: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDataListElement>, HTMLDataListElement>) => PolymorphicForwardRefComponent<"datalist", {}>;
+    dd: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"dd", {}>;
+    del: (className: string, attrs?: React.DetailedHTMLProps<React.DelHTMLAttributes<HTMLModElement>, HTMLModElement>) => PolymorphicForwardRefComponent<"del", {}>;
+    details: (className: string, attrs?: React.DetailedHTMLProps<React.DetailsHTMLAttributes<HTMLDetailsElement>, HTMLDetailsElement>) => PolymorphicForwardRefComponent<"details", {}>;
+    dfn: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"dfn", {}>;
+    dialog: (className: string, attrs?: React.DetailedHTMLProps<React.DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>) => PolymorphicForwardRefComponent<"dialog", {}>;
+    div: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => PolymorphicForwardRefComponent<"div", {}>;
+    dl: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDListElement>, HTMLDListElement>) => PolymorphicForwardRefComponent<"dl", {}>;
+    dt: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"dt", {}>;
+    em: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"em", {}>;
+    embed: (className: string, attrs?: React.DetailedHTMLProps<React.EmbedHTMLAttributes<HTMLEmbedElement>, HTMLEmbedElement>) => PolymorphicForwardRefComponent<"embed", {}>;
+    fieldset: (className: string, attrs?: React.DetailedHTMLProps<React.FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>) => PolymorphicForwardRefComponent<"fieldset", {}>;
+    figcaption: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"figcaption", {}>;
+    figure: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"figure", {}>;
+    footer: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"footer", {}>;
+    form: (className: string, attrs?: React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>) => PolymorphicForwardRefComponent<"form", {}>;
+    h1: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => PolymorphicForwardRefComponent<"h1", {}>;
+    h2: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => PolymorphicForwardRefComponent<"h2", {}>;
+    h3: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => PolymorphicForwardRefComponent<"h3", {}>;
+    h4: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => PolymorphicForwardRefComponent<"h4", {}>;
+    h5: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => PolymorphicForwardRefComponent<"h5", {}>;
+    h6: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => PolymorphicForwardRefComponent<"h6", {}>;
+    head: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadElement>, HTMLHeadElement>) => PolymorphicForwardRefComponent<"head", {}>;
+    header: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"header", {}>;
+    hgroup: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"hgroup", {}>;
+    hr: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLHRElement>, HTMLHRElement>) => PolymorphicForwardRefComponent<"hr", {}>;
+    html: (className: string, attrs?: React.DetailedHTMLProps<React.HtmlHTMLAttributes<HTMLHtmlElement>, HTMLHtmlElement>) => PolymorphicForwardRefComponent<"html", {}>;
+    i: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"i", {}>;
+    iframe: (className: string, attrs?: React.DetailedHTMLProps<React.IframeHTMLAttributes<HTMLIFrameElement>, HTMLIFrameElement>) => PolymorphicForwardRefComponent<"iframe", {}>;
+    img: (className: string, attrs?: React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>) => PolymorphicForwardRefComponent<"img", {}>;
+    input: (className: string, attrs?: React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>) => PolymorphicForwardRefComponent<"input", {}>;
+    ins: (className: string, attrs?: React.DetailedHTMLProps<React.InsHTMLAttributes<HTMLModElement>, HTMLModElement>) => PolymorphicForwardRefComponent<"ins", {}>;
+    kbd: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"kbd", {}>;
+    keygen: (className: string, attrs?: React.DetailedHTMLProps<React.KeygenHTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"keygen", {}>;
+    label: (className: string, attrs?: React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>) => PolymorphicForwardRefComponent<"label", {}>;
+    legend: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLLegendElement>, HTMLLegendElement>) => PolymorphicForwardRefComponent<"legend", {}>;
+    li: (className: string, attrs?: React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>) => PolymorphicForwardRefComponent<"li", {}>;
+    link: (className: string, attrs?: React.DetailedHTMLProps<React.LinkHTMLAttributes<HTMLLinkElement>, HTMLLinkElement>) => PolymorphicForwardRefComponent<"link", {}>;
+    main: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"main", {}>;
+    map: (className: string, attrs?: React.DetailedHTMLProps<React.MapHTMLAttributes<HTMLMapElement>, HTMLMapElement>) => PolymorphicForwardRefComponent<"map", {}>;
+    mark: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"mark", {}>;
+    menu: (className: string, attrs?: React.DetailedHTMLProps<React.MenuHTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"menu", {}>;
+    menuitem: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"menuitem", {}>;
+    meta: (className: string, attrs?: React.DetailedHTMLProps<React.MetaHTMLAttributes<HTMLMetaElement>, HTMLMetaElement>) => PolymorphicForwardRefComponent<"meta", {}>;
+    meter: (className: string, attrs?: React.DetailedHTMLProps<React.MeterHTMLAttributes<HTMLMeterElement>, HTMLMeterElement>) => PolymorphicForwardRefComponent<"meter", {}>;
+    nav: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"nav", {}>;
+    noindex: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"noindex", {}>;
+    noscript: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"noscript", {}>;
+    object: (className: string, attrs?: React.DetailedHTMLProps<React.ObjectHTMLAttributes<HTMLObjectElement>, HTMLObjectElement>) => PolymorphicForwardRefComponent<"object", {}>;
+    ol: (className: string, attrs?: React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>) => PolymorphicForwardRefComponent<"ol", {}>;
+    optgroup: (className: string, attrs?: React.DetailedHTMLProps<React.OptgroupHTMLAttributes<HTMLOptGroupElement>, HTMLOptGroupElement>) => PolymorphicForwardRefComponent<"optgroup", {}>;
+    option: (className: string, attrs?: React.DetailedHTMLProps<React.OptionHTMLAttributes<HTMLOptionElement>, HTMLOptionElement>) => PolymorphicForwardRefComponent<"option", {}>;
+    output: (className: string, attrs?: React.DetailedHTMLProps<React.OutputHTMLAttributes<HTMLOutputElement>, HTMLOutputElement>) => PolymorphicForwardRefComponent<"output", {}>;
+    p: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>) => PolymorphicForwardRefComponent<"p", {}>;
+    param: (className: string, attrs?: React.DetailedHTMLProps<React.ParamHTMLAttributes<HTMLParamElement>, HTMLParamElement>) => PolymorphicForwardRefComponent<"param", {}>;
+    picture: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"picture", {}>;
+    pre: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLPreElement>, HTMLPreElement>) => PolymorphicForwardRefComponent<"pre", {}>;
+    progress: (className: string, attrs?: React.DetailedHTMLProps<React.ProgressHTMLAttributes<HTMLProgressElement>, HTMLProgressElement>) => PolymorphicForwardRefComponent<"progress", {}>;
+    q: (className: string, attrs?: React.DetailedHTMLProps<React.QuoteHTMLAttributes<HTMLQuoteElement>, HTMLQuoteElement>) => PolymorphicForwardRefComponent<"q", {}>;
+    rp: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"rp", {}>;
+    rt: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"rt", {}>;
+    ruby: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"ruby", {}>;
+    s: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"s", {}>;
+    samp: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"samp", {}>;
+    search: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"search", {}>;
+    slot: (className: string, attrs?: React.DetailedHTMLProps<React.SlotHTMLAttributes<HTMLSlotElement>, HTMLSlotElement>) => PolymorphicForwardRefComponent<"slot", {}>;
+    script: (className: string, attrs?: React.DetailedHTMLProps<React.ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement>) => PolymorphicForwardRefComponent<"script", {}>;
+    section: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"section", {}>;
+    select: (className: string, attrs?: React.DetailedHTMLProps<React.SelectHTMLAttributes<HTMLSelectElement>, HTMLSelectElement>) => PolymorphicForwardRefComponent<"select", {}>;
+    small: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"small", {}>;
+    source: (className: string, attrs?: React.DetailedHTMLProps<React.SourceHTMLAttributes<HTMLSourceElement>, HTMLSourceElement>) => PolymorphicForwardRefComponent<"source", {}>;
+    span: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>) => PolymorphicForwardRefComponent<"span", {}>;
+    strong: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"strong", {}>;
+    style: (className: string, attrs?: React.DetailedHTMLProps<React.StyleHTMLAttributes<HTMLStyleElement>, HTMLStyleElement>) => PolymorphicForwardRefComponent<"style", {}>;
+    sub: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"sub", {}>;
+    summary: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"summary", {}>;
+    sup: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"sup", {}>;
+    table: (className: string, attrs?: React.DetailedHTMLProps<React.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>) => PolymorphicForwardRefComponent<"table", {}>;
+    template: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLTemplateElement>, HTMLTemplateElement>) => PolymorphicForwardRefComponent<"template", {}>;
+    tbody: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>) => PolymorphicForwardRefComponent<"tbody", {}>;
+    td: (className: string, attrs?: React.DetailedHTMLProps<React.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>) => PolymorphicForwardRefComponent<"td", {}>;
+    textarea: (className: string, attrs?: React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>) => PolymorphicForwardRefComponent<"textarea", {}>;
+    tfoot: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>) => PolymorphicForwardRefComponent<"tfoot", {}>;
+    th: (className: string, attrs?: React.DetailedHTMLProps<React.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>) => PolymorphicForwardRefComponent<"th", {}>;
+    thead: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>) => PolymorphicForwardRefComponent<"thead", {}>;
+    time: (className: string, attrs?: React.DetailedHTMLProps<React.TimeHTMLAttributes<HTMLTimeElement>, HTMLTimeElement>) => PolymorphicForwardRefComponent<"time", {}>;
+    title: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLTitleElement>, HTMLTitleElement>) => PolymorphicForwardRefComponent<"title", {}>;
+    tr: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>) => PolymorphicForwardRefComponent<"tr", {}>;
+    track: (className: string, attrs?: React.DetailedHTMLProps<React.TrackHTMLAttributes<HTMLTrackElement>, HTMLTrackElement>) => PolymorphicForwardRefComponent<"track", {}>;
+    u: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"u", {}>;
+    ul: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>) => PolymorphicForwardRefComponent<"ul", {}>;
+    var: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"var", {}>;
+    video: (className: string, attrs?: React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>) => PolymorphicForwardRefComponent<"video", {}>;
+    wbr: (className: string, attrs?: React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>) => PolymorphicForwardRefComponent<"wbr", {}>;
+    webview: (className: string, attrs?: React.DetailedHTMLProps<React.WebViewHTMLAttributes<HTMLWebViewElement>, HTMLWebViewElement>) => PolymorphicForwardRefComponent<"webview", {}>;
+    svg: (className: string, attrs?: React.SVGProps<SVGSVGElement>) => PolymorphicForwardRefComponent<"svg", {}>;
+    animate: (className: string, attrs?: React.SVGProps<SVGElement>) => PolymorphicForwardRefComponent<"animate", {}>;
+    animateMotion: (className: string, attrs?: React.SVGProps<SVGElement>) => PolymorphicForwardRefComponent<"animateMotion", {}>;
+    animateTransform: (className: string, attrs?: React.SVGProps<SVGElement>) => PolymorphicForwardRefComponent<"animateTransform", {}>;
+    circle: (className: string, attrs?: React.SVGProps<SVGCircleElement>) => PolymorphicForwardRefComponent<"circle", {}>;
+    clipPath: (className: string, attrs?: React.SVGProps<SVGClipPathElement>) => PolymorphicForwardRefComponent<"clipPath", {}>;
+    defs: (className: string, attrs?: React.SVGProps<SVGDefsElement>) => PolymorphicForwardRefComponent<"defs", {}>;
+    desc: (className: string, attrs?: React.SVGProps<SVGDescElement>) => PolymorphicForwardRefComponent<"desc", {}>;
+    ellipse: (className: string, attrs?: React.SVGProps<SVGEllipseElement>) => PolymorphicForwardRefComponent<"ellipse", {}>;
+    feBlend: (className: string, attrs?: React.SVGProps<SVGFEBlendElement>) => PolymorphicForwardRefComponent<"feBlend", {}>;
+    feColorMatrix: (className: string, attrs?: React.SVGProps<SVGFEColorMatrixElement>) => PolymorphicForwardRefComponent<"feColorMatrix", {}>;
+    feComponentTransfer: (className: string, attrs?: React.SVGProps<SVGFEComponentTransferElement>) => PolymorphicForwardRefComponent<"feComponentTransfer", {}>;
+    feComposite: (className: string, attrs?: React.SVGProps<SVGFECompositeElement>) => PolymorphicForwardRefComponent<"feComposite", {}>;
+    feConvolveMatrix: (className: string, attrs?: React.SVGProps<SVGFEConvolveMatrixElement>) => PolymorphicForwardRefComponent<"feConvolveMatrix", {}>;
+    feDiffuseLighting: (className: string, attrs?: React.SVGProps<SVGFEDiffuseLightingElement>) => PolymorphicForwardRefComponent<"feDiffuseLighting", {}>;
+    feDisplacementMap: (className: string, attrs?: React.SVGProps<SVGFEDisplacementMapElement>) => PolymorphicForwardRefComponent<"feDisplacementMap", {}>;
+    feDistantLight: (className: string, attrs?: React.SVGProps<SVGFEDistantLightElement>) => PolymorphicForwardRefComponent<"feDistantLight", {}>;
+    feDropShadow: (className: string, attrs?: React.SVGProps<SVGFEDropShadowElement>) => PolymorphicForwardRefComponent<"feDropShadow", {}>;
+    feFlood: (className: string, attrs?: React.SVGProps<SVGFEFloodElement>) => PolymorphicForwardRefComponent<"feFlood", {}>;
+    feFuncA: (className: string, attrs?: React.SVGProps<SVGFEFuncAElement>) => PolymorphicForwardRefComponent<"feFuncA", {}>;
+    feFuncB: (className: string, attrs?: React.SVGProps<SVGFEFuncBElement>) => PolymorphicForwardRefComponent<"feFuncB", {}>;
+    feFuncG: (className: string, attrs?: React.SVGProps<SVGFEFuncGElement>) => PolymorphicForwardRefComponent<"feFuncG", {}>;
+    feFuncR: (className: string, attrs?: React.SVGProps<SVGFEFuncRElement>) => PolymorphicForwardRefComponent<"feFuncR", {}>;
+    feGaussianBlur: (className: string, attrs?: React.SVGProps<SVGFEGaussianBlurElement>) => PolymorphicForwardRefComponent<"feGaussianBlur", {}>;
+    feImage: (className: string, attrs?: React.SVGProps<SVGFEImageElement>) => PolymorphicForwardRefComponent<"feImage", {}>;
+    feMerge: (className: string, attrs?: React.SVGProps<SVGFEMergeElement>) => PolymorphicForwardRefComponent<"feMerge", {}>;
+    feMergeNode: (className: string, attrs?: React.SVGProps<SVGFEMergeNodeElement>) => PolymorphicForwardRefComponent<"feMergeNode", {}>;
+    feMorphology: (className: string, attrs?: React.SVGProps<SVGFEMorphologyElement>) => PolymorphicForwardRefComponent<"feMorphology", {}>;
+    feOffset: (className: string, attrs?: React.SVGProps<SVGFEOffsetElement>) => PolymorphicForwardRefComponent<"feOffset", {}>;
+    fePointLight: (className: string, attrs?: React.SVGProps<SVGFEPointLightElement>) => PolymorphicForwardRefComponent<"fePointLight", {}>;
+    feSpecularLighting: (className: string, attrs?: React.SVGProps<SVGFESpecularLightingElement>) => PolymorphicForwardRefComponent<"feSpecularLighting", {}>;
+    feSpotLight: (className: string, attrs?: React.SVGProps<SVGFESpotLightElement>) => PolymorphicForwardRefComponent<"feSpotLight", {}>;
+    feTile: (className: string, attrs?: React.SVGProps<SVGFETileElement>) => PolymorphicForwardRefComponent<"feTile", {}>;
+    feTurbulence: (className: string, attrs?: React.SVGProps<SVGFETurbulenceElement>) => PolymorphicForwardRefComponent<"feTurbulence", {}>;
+    filter: (className: string, attrs?: React.SVGProps<SVGFilterElement>) => PolymorphicForwardRefComponent<"filter", {}>;
+    foreignObject: (className: string, attrs?: React.SVGProps<SVGForeignObjectElement>) => PolymorphicForwardRefComponent<"foreignObject", {}>;
+    g: (className: string, attrs?: React.SVGProps<SVGGElement>) => PolymorphicForwardRefComponent<"g", {}>;
+    image: (className: string, attrs?: React.SVGProps<SVGImageElement>) => PolymorphicForwardRefComponent<"image", {}>;
+    line: (className: string, attrs?: React.SVGLineElementAttributes<SVGLineElement>) => PolymorphicForwardRefComponent<"line", {}>;
+    linearGradient: (className: string, attrs?: React.SVGProps<SVGLinearGradientElement>) => PolymorphicForwardRefComponent<"linearGradient", {}>;
+    marker: (className: string, attrs?: React.SVGProps<SVGMarkerElement>) => PolymorphicForwardRefComponent<"marker", {}>;
+    mask: (className: string, attrs?: React.SVGProps<SVGMaskElement>) => PolymorphicForwardRefComponent<"mask", {}>;
+    metadata: (className: string, attrs?: React.SVGProps<SVGMetadataElement>) => PolymorphicForwardRefComponent<"metadata", {}>;
+    mpath: (className: string, attrs?: React.SVGProps<SVGElement>) => PolymorphicForwardRefComponent<"mpath", {}>;
+    path: (className: string, attrs?: React.SVGProps<SVGPathElement>) => PolymorphicForwardRefComponent<"path", {}>;
+    pattern: (className: string, attrs?: React.SVGProps<SVGPatternElement>) => PolymorphicForwardRefComponent<"pattern", {}>;
+    polygon: (className: string, attrs?: React.SVGProps<SVGPolygonElement>) => PolymorphicForwardRefComponent<"polygon", {}>;
+    polyline: (className: string, attrs?: React.SVGProps<SVGPolylineElement>) => PolymorphicForwardRefComponent<"polyline", {}>;
+    radialGradient: (className: string, attrs?: React.SVGProps<SVGRadialGradientElement>) => PolymorphicForwardRefComponent<"radialGradient", {}>;
+    rect: (className: string, attrs?: React.SVGProps<SVGRectElement>) => PolymorphicForwardRefComponent<"rect", {}>;
+    stop: (className: string, attrs?: React.SVGProps<SVGStopElement>) => PolymorphicForwardRefComponent<"stop", {}>;
+    switch: (className: string, attrs?: React.SVGProps<SVGSwitchElement>) => PolymorphicForwardRefComponent<"switch", {}>;
+    symbol: (className: string, attrs?: React.SVGProps<SVGSymbolElement>) => PolymorphicForwardRefComponent<"symbol", {}>;
+    text: (className: string, attrs?: React.SVGTextElementAttributes<SVGTextElement>) => PolymorphicForwardRefComponent<"text", {}>;
+    textPath: (className: string, attrs?: React.SVGProps<SVGTextPathElement>) => PolymorphicForwardRefComponent<"textPath", {}>;
+    tspan: (className: string, attrs?: React.SVGProps<SVGTSpanElement>) => PolymorphicForwardRefComponent<"tspan", {}>;
+    use: (className: string, attrs?: React.SVGProps<SVGUseElement>) => PolymorphicForwardRefComponent<"use", {}>;
+    view: (className: string, attrs?: React.SVGProps<SVGViewElement>) => PolymorphicForwardRefComponent<"view", {}>;
+};
+//# sourceMappingURL=polymorphic.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/polymorphic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polymorphic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/polymorphic.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,UAAU,CAAC;AAwC/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,WAAW,eAtDH,MAAM;mBAAN,MAAM;sBAAN,MAAM;yBAAN,MAAM;sBAAN,MAAM;yBAAN,MAAM;uBAAN,MAAM;uBAAN,MAAM;mBAAN,MAAM;sBAAN,MAAM;qBAAN,MAAM;qBAAN,MAAM;qBAAN,MAAM;4BAAN,MAAM;sBAAN,MAAM;oBAAN,MAAM;wBAAN,MAAM;wBAAN,MAAM;yBAAN,MAAM;wBAAN,MAAM;sBAAN,MAAM;sBAAN,MAAM;qBAAN,MAAM;0BAAN,MAAM;sBAAN,MAAM;0BAAN,MAAM;oBAAN,MAAM;qBAAN,MAAM;yBAAN,MAAM;qBAAN,MAAM;wBAAN,MAAM;qBAAN,MAAM;oBAAN,MAAM;oBAAN,MAAM;oBAAN,MAAM;uBAAN,MAAM;0BAAN,MAAM;4BAAN,MAAM;wBAAN,MAAM;wBAAN,MAAM;sBAAN,MAAM;oBAAN,MAAM;oBAAN,MAAM;oBAAN,MAAM;oBAAN,MAAM;oBAAN,MAAM;oBAAN,MAAM;sBAAN,MAAM;wBAAN,MAAM;wBAAN,MAAM;oBAAN,MAAM;sBAAN,MAAM;mBAAN,MAAM;wBAAN,MAAM;qBAAN,MAAM;uBAAN,MAAM;qBAAN,MAAM;qBAAN,MAAM;wBAAN,MAAM;uBAAN,MAAM;wBAAN,MAAM;oBAAN,MAAM;sBAAN,MAAM;sBAAN,MAAM;qBAAN,MAAM;sBAAN,MAAM;sBAAN,MAAM;0BAAN,MAAM;sBAAN,MAAM;uBAAN,MAAM;qBAAN,MAAM;yBAAN,MAAM;0BAAN,MAAM;wBAAN,MAAM;oBAAN,MAAM;0BAAN,MAAM;wBAAN,MAAM;wBAAN,MAAM;mBAAN,MAAM;uBAAN,MAAM;yBAAN,MAAM;qBAAN,MAAM;0BAAN,MAAM;mBAAN,MAAM;oBAAN,MAAM;oBAAN,MAAM;sBAAN,MAAM;mBAAN,MAAM;sBAAN,MAAM;wBAAN,MAAM;sBAAN,MAAM;wBAAN,MAAM;yBAAN,MAAM;wBAAN,MAAM;uBAAN,MAAM;wBAAN,MAAM;sBAAN,MAAM;wBAAN,MAAM;uBAAN,MAAM;qBAAN,MAAM;yBAAN,MAAM;qBAAN,MAAM;uBAAN,MAAM;0BAAN,MAAM;uBAAN,MAAM;oBAAN,MAAM;0BAAN,MAAM;uBAAN,MAAM;oBAAN,MAAM;uBAAN,MAAM;sBAAN,MAAM;uBAAN,MAAM;oBAAN,MAAM;uBAAN,MAAM;mBAAN,MAAM;oBAAN,MAAM;qBAAN,MAAM;uBAAN,MAAM;qBAAN,MAAM;yBAAN,MAAM;qBAAN,MAAM;yBAAN,MAAM;+BAAN,MAAM;kCAAN,MAAM;wBAAN,MAAM;0BAAN,MAAM;sBAAN,MAAM;sBAAN,MAAM;yBAAN,MAAM;yBAAN,MAAM;+BAAN,MAAM;qCAAN,MAAM;6BAAN,MAAM;kCAAN,MAAM;mCAAN,MAAM;mCAAN,MAAM;gCAAN,MAAM;8BAAN,MAAM;yBAAN,MAAM;yBAAN,MAAM;yBAAN,MAAM;yBAAN,MAAM;yBAAN,MAAM;gCAAN,MAAM;yBAAN,MAAM;yBAAN,MAAM;6BAAN,MAAM;8BAAN,MAAM;0BAAN,MAAM;8BAAN,MAAM;oCAAN,MAAM;6BAAN,MAAM;wBAAN,MAAM;8BAAN,MAAM;wBAAN,MAAM;+BAAN,MAAM;mBAAN,MAAM;uBAAN,MAAM;sBAAN,MAAM;gCAAN,MAAM;wBAAN,MAAM;sBAAN,MAAM;0BAAN,MAAM;uBAAN,MAAM;sBAAN,MAAM;yBAAN,MAAM;yBAAN,MAAM;0BAAN,MAAM;gCAAN,MAAM;sBAAN,MAAM;sBAAN,MAAM;wBAAN,MAAM;wBAAN,MAAM;sBAAN,MAAM;0BAAN,MAAM;uBAAN,MAAM;qBAAN,MAAM;sBAAN,MAAM;CAiE1B,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/react.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+/**
+ * Wrapper over `cloneElement` that automatically checks for `isValidElement`
+ * and automatically merges `children.ref` with the ref passed in props.
+ *
+ * @private
+ */
+export declare const cloneElementWithRef: (children: React.ReactNode, getProps: (children: JSX.Element) => Record<string, unknown>) => string | number | true | Iterable<React.ReactNode> | React.DetailedReactHTMLElement<unknown, HTMLElement>;
+//# sourceMappingURL=react.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/react.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,aACpB,MAAM,SAAS,uBACJ,WAAW,KAAK,OAAO,MAAM,EAAE,OAAO,CAAC,8GA0B7D,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/supports.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns true if the :has selector is supported in the browser
+ */
+export declare const supportsHas: () => boolean;
+//# sourceMappingURL=supports.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/functions/supports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supports.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/functions/supports.ts"],"names":[],"mappings":"AAOA;;GAEG;AAEH,eAAO,MAAM,WAAW,eAC6B,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/hooks/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./useEventListener";
+export * from "./useMergedRefs";
+export * from "./useOverflow";
+export * from "./useResizeObserver";
+export * from "./useContainerWidth";
+export * from "./useGlobals";
+export * from "./useIntersection";
+export * from "./useMediaQuery";
+export * from "./useSafeContext";
+export * from "./useLatestRef";
+export * from "./useIsomorphicLayoutEffect";
+export * from "./useIsClient";
+export * from "./useId";
+export * from "./useControlledState";
+//# sourceMappingURL=index.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/hooks/index.ts"],"names":[],"mappings":"AAIA,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/hooks/useContainerWidth.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hook that returns the width of an element in three stages:
+ *  - initialized with 0
+ *  - immediately set to element's initial width as soon as it's mounted
+ *  - update to new width every time it changes (using `useResizeObserver` hook)
+ *
+ * @private
+ * @param watchResizes If false, ResizeObserver will not be connected and only the initial width will be returned
+ * @returns [ref to attach to the element, stateful width of the element]
+ *
+ * @example
+ * const [ref, width] = useContainerWidth();
+ * ... // do something with width
+ * return <div ref={ref}>...</div>;
+ */
+export declare const useContainerWidth: <T extends HTMLElement>(watchResizes?: boolean) => readonly [(instance: HTMLElement) => void, number];
+//# sourceMappingURL=useContainerWidth.d.ts.map

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/hooks/useContainerWidth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContainerWidth.d.ts","sourceRoot":"","sources":["../../../../../../../../src/components/Table/components/newComponents/utils/hooks/useContainerWidth.tsx"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,uGA0B7B,CAAC"}

package/dist/mocked_classnames_esm/components/Table/components/newComponents/utils/hooks/useControlledState.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+/**
+ * Wrapper over `useState` that always gives preference to the
+ * controlled state (which often comes from a prop).
+ *
+ * This is helpful when a component needs to support both uncontrolled
+ * and controlled states. If controlled value/setter is not passed,
+ * then it will work just like a regular `useState`.
+ *
+ * @example
+ * const [state, setState] = useControlledState(null, props.value, props.onChange);
+ */
+export declare const useControlledState: <T>(initialValue: T, controlledState: T, setControlledState?: React.Dispatch<React.SetStateAction<T>>) => readonly [T, React.Dispatch<React.SetStateAction<T>>];
+//# sourceMappingURL=useControlledState.d.ts.map