@elliemae/ds-legacy-shuttle-v2 1.0.0-rc.1

package/dist/types/config/useStore/useStore.d.ts

@@ -0,0 +1,301 @@
+/// <reference types="react" />
+import { type ZustandT } from '@elliemae/ds-legacy-zustand-helpers';
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+export declare const PropsProvider: ({ createStore, children, }: {
+    createStore: () => ZustandT.ZustandStore<ZustandT.PropsStore<DSShuttleV2T.InternalProps & {
+        destinationVirtualRef: import("react").MutableRefObject<{
+            scrollTo: (index: number) => void;
+        }>;
+        sourceVirtualRef: import("react").MutableRefObject<{
+            scrollTo: (index: number) => void;
+        }>;
+        destinationSelectedItemsMap: Record<string, {
+            datum: DSShuttleV2T.Datum;
+            index: number;
+        }>;
+        destinationSelectionItemArray: DSShuttleV2T.Datum[];
+        destinationSelectionArray: string[];
+        destinationHasMultipleSelectedItems: boolean;
+        destinationConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+        destinationSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+        destinationSelectionableDataIds: string[];
+        destinationSelectionableIds: string;
+        sourceConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+        sourceSelectedItemsMap: Record<string, {
+            datum: DSShuttleV2T.Datum;
+            index: number;
+        }>;
+        sourceSelectionItemArray: DSShuttleV2T.Datum[];
+        sourceSelectionArray: string[];
+        sourceHasMultipleSelectedItems: boolean;
+        sourceSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+        sourceSelectionableDataIds: string[];
+        sourceSelectionableIds: string;
+    }>>;
+    children: import("react").ReactNode;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<ZustandT.ZustandStore<ZustandT.PropsStore<DSShuttleV2T.InternalProps & {
+    destinationVirtualRef: import("react").MutableRefObject<{
+        scrollTo: (index: number) => void;
+    }>;
+    sourceVirtualRef: import("react").MutableRefObject<{
+        scrollTo: (index: number) => void;
+    }>;
+    destinationSelectedItemsMap: Record<string, {
+        datum: DSShuttleV2T.Datum;
+        index: number;
+    }>;
+    destinationSelectionItemArray: DSShuttleV2T.Datum[];
+    destinationSelectionArray: string[];
+    destinationHasMultipleSelectedItems: boolean;
+    destinationConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+    destinationSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+    destinationSelectionableDataIds: string[];
+    destinationSelectionableIds: string;
+    sourceConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+    sourceSelectedItemsMap: Record<string, {
+        datum: DSShuttleV2T.Datum;
+        index: number;
+    }>;
+    sourceSelectionItemArray: DSShuttleV2T.Datum[];
+    sourceSelectionArray: string[];
+    sourceHasMultipleSelectedItems: boolean;
+    sourceSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+    sourceSelectionableDataIds: string[];
+    sourceSelectionableIds: string;
+}>> | undefined>>, usePropsStore: {
+    (): ZustandT.PropsStore<DSShuttleV2T.InternalProps & {
+        destinationVirtualRef: import("react").MutableRefObject<{
+            scrollTo: (index: number) => void;
+        }>;
+        sourceVirtualRef: import("react").MutableRefObject<{
+            scrollTo: (index: number) => void;
+        }>;
+        destinationSelectedItemsMap: Record<string, {
+            datum: DSShuttleV2T.Datum;
+            index: number;
+        }>;
+        destinationSelectionItemArray: DSShuttleV2T.Datum[];
+        destinationSelectionArray: string[];
+        destinationHasMultipleSelectedItems: boolean;
+        destinationConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+        destinationSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+        destinationSelectionableDataIds: string[];
+        destinationSelectionableIds: string;
+        sourceConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+        sourceSelectedItemsMap: Record<string, {
+            datum: DSShuttleV2T.Datum;
+            index: number;
+        }>;
+        sourceSelectionItemArray: DSShuttleV2T.Datum[];
+        sourceSelectionArray: string[];
+        sourceHasMultipleSelectedItems: boolean;
+        sourceSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+        sourceSelectionableDataIds: string[];
+        sourceSelectionableIds: string;
+    }>;
+    <U>(selector: (state: ZustandT.PropsStore<DSShuttleV2T.InternalProps & {
+        destinationVirtualRef: import("react").MutableRefObject<{
+            scrollTo: (index: number) => void;
+        }>;
+        sourceVirtualRef: import("react").MutableRefObject<{
+            scrollTo: (index: number) => void;
+        }>;
+        destinationSelectedItemsMap: Record<string, {
+            datum: DSShuttleV2T.Datum;
+            index: number;
+        }>;
+        destinationSelectionItemArray: DSShuttleV2T.Datum[];
+        destinationSelectionArray: string[];
+        destinationHasMultipleSelectedItems: boolean;
+        destinationConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+        destinationSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+        destinationSelectionableDataIds: string[];
+        destinationSelectionableIds: string;
+        sourceConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+        sourceSelectedItemsMap: Record<string, {
+            datum: DSShuttleV2T.Datum;
+            index: number;
+        }>;
+        sourceSelectionItemArray: DSShuttleV2T.Datum[];
+        sourceSelectionArray: string[];
+        sourceHasMultipleSelectedItems: boolean;
+        sourceSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+        sourceSelectionableDataIds: string[];
+        sourceSelectionableIds: string;
+    }>) => U, equalityFn?: ((a: U, b: U) => boolean) | undefined): U;
+}, InternalProvider: ({ createStore, children, }: {
+    createStore: () => ZustandT.ZustandStore<ZustandT.InternalStore<DSShuttleV2T.InternalAtoms, DSShuttleV2T.Selectors, DSShuttleV2T.Reducers>>;
+    children: import("react").ReactNode;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<ZustandT.ZustandStore<ZustandT.InternalStore<DSShuttleV2T.InternalAtoms, DSShuttleV2T.Selectors, DSShuttleV2T.Reducers>> | undefined>>, useInternalStore: {
+    (): ZustandT.InternalStore<DSShuttleV2T.InternalAtoms, DSShuttleV2T.Selectors, DSShuttleV2T.Reducers>;
+    <U_1>(selector: (state: ZustandT.InternalStore<DSShuttleV2T.InternalAtoms, DSShuttleV2T.Selectors, DSShuttleV2T.Reducers>) => U_1, equalityFn?: ((a: U_1, b: U_1) => boolean) | undefined): U_1;
+};
+export declare const config: {
+    defaultProps: DSShuttleV2T.InternalProps;
+    internalAtomDefaultValues: DSShuttleV2T.InternalAtoms;
+    useAutoCalculated: (propsWithDefaults: DSShuttleV2T.InternalProps) => {
+        destinationVirtualRef: import("react").MutableRefObject<{
+            scrollTo: (index: number) => void;
+        }>;
+        sourceVirtualRef: import("react").MutableRefObject<{
+            scrollTo: (index: number) => void;
+        }>;
+        destinationSelectedItemsMap: Record<string, {
+            datum: DSShuttleV2T.Datum;
+            index: number;
+        }>;
+        destinationSelectionItemArray: DSShuttleV2T.Datum[];
+        destinationSelectionArray: string[];
+        destinationHasMultipleSelectedItems: boolean;
+        destinationConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+        destinationSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+        destinationSelectionableDataIds: string[];
+        destinationSelectionableIds: string;
+        sourceConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+        sourceSelectedItemsMap: Record<string, {
+            datum: DSShuttleV2T.Datum;
+            index: number;
+        }>;
+        sourceSelectionItemArray: DSShuttleV2T.Datum[];
+        sourceSelectionArray: string[];
+        sourceHasMultipleSelectedItems: boolean;
+        sourceSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+        sourceSelectionableDataIds: string[];
+        sourceSelectionableIds: string;
+    };
+    selectors: ZustandT.SelectorObject<DSShuttleV2T.ShuttleInternalStore, DSShuttleV2T.Selectors>;
+    reducers: ZustandT.ReducerObject<DSShuttleV2T.ShuttleInternalStore, DSShuttleV2T.Reducers>;
+    subscribers: ZustandT.Subscribers<DSShuttleV2T.ShuttleInternalStore>;
+    PropsProvider: ({ createStore, children, }: {
+        createStore: () => ZustandT.ZustandStore<ZustandT.PropsStore<DSShuttleV2T.InternalProps & {
+            destinationVirtualRef: import("react").MutableRefObject<{
+                scrollTo: (index: number) => void;
+            }>;
+            sourceVirtualRef: import("react").MutableRefObject<{
+                scrollTo: (index: number) => void;
+            }>;
+            destinationSelectedItemsMap: Record<string, {
+                datum: DSShuttleV2T.Datum;
+                index: number;
+            }>;
+            destinationSelectionItemArray: DSShuttleV2T.Datum[];
+            destinationSelectionArray: string[];
+            destinationHasMultipleSelectedItems: boolean;
+            destinationConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+            destinationSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+            destinationSelectionableDataIds: string[];
+            destinationSelectionableIds: string;
+            sourceConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+            sourceSelectedItemsMap: Record<string, {
+                datum: DSShuttleV2T.Datum;
+                index: number;
+            }>;
+            sourceSelectionItemArray: DSShuttleV2T.Datum[];
+            sourceSelectionArray: string[];
+            sourceHasMultipleSelectedItems: boolean;
+            sourceSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+            sourceSelectionableDataIds: string[];
+            sourceSelectionableIds: string;
+        }>>;
+        children: import("react").ReactNode;
+    }) => import("react").FunctionComponentElement<import("react").ProviderProps<ZustandT.ZustandStore<ZustandT.PropsStore<DSShuttleV2T.InternalProps & {
+        destinationVirtualRef: import("react").MutableRefObject<{
+            scrollTo: (index: number) => void;
+        }>;
+        sourceVirtualRef: import("react").MutableRefObject<{
+            scrollTo: (index: number) => void;
+        }>;
+        destinationSelectedItemsMap: Record<string, {
+            datum: DSShuttleV2T.Datum;
+            index: number;
+        }>;
+        destinationSelectionItemArray: DSShuttleV2T.Datum[];
+        destinationSelectionArray: string[];
+        destinationHasMultipleSelectedItems: boolean;
+        destinationConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+        destinationSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+        destinationSelectionableDataIds: string[];
+        destinationSelectionableIds: string;
+        sourceConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+        sourceSelectedItemsMap: Record<string, {
+            datum: DSShuttleV2T.Datum;
+            index: number;
+        }>;
+        sourceSelectionItemArray: DSShuttleV2T.Datum[];
+        sourceSelectionArray: string[];
+        sourceHasMultipleSelectedItems: boolean;
+        sourceSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+        sourceSelectionableDataIds: string[];
+        sourceSelectionableIds: string;
+    }>> | undefined>>;
+    usePropsStore: {
+        (): ZustandT.PropsStore<DSShuttleV2T.InternalProps & {
+            destinationVirtualRef: import("react").MutableRefObject<{
+                scrollTo: (index: number) => void;
+            }>;
+            sourceVirtualRef: import("react").MutableRefObject<{
+                scrollTo: (index: number) => void;
+            }>;
+            destinationSelectedItemsMap: Record<string, {
+                datum: DSShuttleV2T.Datum;
+                index: number;
+            }>;
+            destinationSelectionItemArray: DSShuttleV2T.Datum[];
+            destinationSelectionArray: string[];
+            destinationHasMultipleSelectedItems: boolean;
+            destinationConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+            destinationSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+            destinationSelectionableDataIds: string[];
+            destinationSelectionableIds: string;
+            sourceConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+            sourceSelectedItemsMap: Record<string, {
+                datum: DSShuttleV2T.Datum;
+                index: number;
+            }>;
+            sourceSelectionItemArray: DSShuttleV2T.Datum[];
+            sourceSelectionArray: string[];
+            sourceHasMultipleSelectedItems: boolean;
+            sourceSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+            sourceSelectionableDataIds: string[];
+            sourceSelectionableIds: string;
+        }>;
+        <U>(selector: (state: ZustandT.PropsStore<DSShuttleV2T.InternalProps & {
+            destinationVirtualRef: import("react").MutableRefObject<{
+                scrollTo: (index: number) => void;
+            }>;
+            sourceVirtualRef: import("react").MutableRefObject<{
+                scrollTo: (index: number) => void;
+            }>;
+            destinationSelectedItemsMap: Record<string, {
+                datum: DSShuttleV2T.Datum;
+                index: number;
+            }>;
+            destinationSelectionItemArray: DSShuttleV2T.Datum[];
+            destinationSelectionArray: string[];
+            destinationHasMultipleSelectedItems: boolean;
+            destinationConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+            destinationSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+            destinationSelectionableDataIds: string[];
+            destinationSelectionableIds: string;
+            sourceConfiguredData: DSShuttleV2T.ConfiguredDatum[];
+            sourceSelectedItemsMap: Record<string, {
+                datum: DSShuttleV2T.Datum;
+                index: number;
+            }>;
+            sourceSelectionItemArray: DSShuttleV2T.Datum[];
+            sourceSelectionArray: string[];
+            sourceHasMultipleSelectedItems: boolean;
+            sourceSelectionableData: DSShuttleV2T.ConfiguredDatum[];
+            sourceSelectionableDataIds: string[];
+            sourceSelectionableIds: string;
+        }>) => U, equalityFn?: ((a: U, b: U) => boolean) | undefined): U;
+    };
+    InternalProvider: ({ createStore, children, }: {
+        createStore: () => ZustandT.ZustandStore<ZustandT.InternalStore<DSShuttleV2T.InternalAtoms, DSShuttleV2T.Selectors, DSShuttleV2T.Reducers>>;
+        children: import("react").ReactNode;
+    }) => import("react").FunctionComponentElement<import("react").ProviderProps<ZustandT.ZustandStore<ZustandT.InternalStore<DSShuttleV2T.InternalAtoms, DSShuttleV2T.Selectors, DSShuttleV2T.Reducers>> | undefined>>;
+    useInternalStore: {
+        (): ZustandT.InternalStore<DSShuttleV2T.InternalAtoms, DSShuttleV2T.Selectors, DSShuttleV2T.Reducers>;
+        <U_1>(selector: (state: ZustandT.InternalStore<DSShuttleV2T.InternalAtoms, DSShuttleV2T.Selectors, DSShuttleV2T.Reducers>) => U_1, equalityFn?: ((a: U_1, b: U_1) => boolean) | undefined): U_1;
+    };
+};

package/dist/types/config/useValidateProps.d.ts

@@ -0,0 +1,3 @@
+import type { WeakValidationMap } from 'react';
+import type { DSShuttleV2T } from '../react-desc-prop-types.js';
+export declare const useValidateProps: (props: DSShuttleV2T.Props, propTypes: WeakValidationMap<unknown>) => void;

package/dist/types/constants/index.d.ts

@@ -0,0 +1,32 @@
+export declare const DSShuttleV2Name: "DSShuttleV2";
+export declare const REGIONS_FOCUSES: {
+    readonly SOURCE_HEADER: "source-header";
+    readonly SOURCE_PANEL: "source-panel";
+    readonly SOURCE_PANEL_ITEM: "source-panel-item";
+    readonly SOURCE_PANEL_ITEM_MOVE_ALL: "source-panel-move-all";
+    readonly SOURCE_BOTTOM: "source-bottom";
+    readonly DESTINATION_HEADER: "destination-header";
+    readonly DESTINATION_PANEL: "destination-panel";
+    readonly DESTINATION_PANEL_ITEM: "destination-panel-item";
+    readonly DESTINATION_PANEL_ITEM_MOVE_ALL: "destination-panel-move-all";
+    readonly DESTINATION_BOTTOM: "destination-bottom";
+    readonly RESET: "";
+};
+export declare const ACTIONS_FOCUSES: {
+    readonly MOVE_BTN: "move-btn";
+    readonly DRILLDOWN_BTN: "drilldown-btn";
+    readonly DRAG_N_DROP: "drag-n-drop";
+    readonly PARENT: "parent";
+    readonly RESET: "";
+};
+export declare const ITEMS_FOCUSES: {
+    readonly LOAD_MORE_BTN_SOURCE: "load-more-btn-source";
+    readonly LOAD_MORE_BTN_DESTINATION: "load-more-btn-destination";
+    readonly GET_SPECIFIC_ITEM: ({ hydratedId }: {
+        hydratedId: string;
+    }) => string;
+    readonly RESET: "";
+};
+export declare const DATA_TESTID: {
+    readonly SHUTTLE_DRAG_HANDLE: "shuttle-drag-handle";
+};

package/dist/types/exported-related/ShuttleItem.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { DSShuttleV2T } from '../react-desc-prop-types.js';
+export type ShuttleItemProps = React.PropsWithChildren<{
+    componentProps: DSShuttleV2T.ComponentProps;
+    shouldShowTooltip?: boolean;
+    TooltipContent?: React.ComponentType<DSShuttleV2T.ComponentProps>;
+}>;
+export declare const ShuttleItem: React.ComponentType<ShuttleItemProps>;

package/dist/types/exported-related/index.d.ts

@@ -0,0 +1 @@
+export { type ShuttleItemProps, ShuttleItem } from './ShuttleItem.js';

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { DSShuttleV2Name, DSShuttleV2Slots, DSShuttleV2DataTestIds } from './config/DSShuttleV2Definitions.js';
+export { DSShuttleV2, DSShuttleV2WithSchema } from './DSShuttleV2.js';
+export { ShuttleItem, type ShuttleItemProps } from './exported-related/index.js';

package/dist/types/parts/Dnd/DndHandle.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { useSortable } from '@elliemae/ds-legacy-drag-and-drop';
+export declare const StyledGripperButtonOrOverlay: import("styled-components").StyledComponent<"div", import("@elliemae/ds-legacy-system").Theme, {
+    isActive: boolean;
+    isDragOverlay?: boolean | undefined;
+    disabled?: boolean | undefined;
+} & import("@elliemae/ds-legacy-system").OwnerInterface, never>;
+export declare const DragHandle: React.ComponentType<{
+    id: string;
+    innerRef: React.RefObject<HTMLDivElement> | React.RefCallback<HTMLDivElement>;
+    useSortableHelpers: ReturnType<typeof useSortable>;
+    isDndActive: boolean;
+    isDragging: boolean;
+    disabled?: boolean;
+}>;

package/dist/types/parts/Dnd/DragOverlay.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare const DragOverlay: React.ComponentType<{
+    id: string;
+    isDndActive: boolean;
+    isDragging: boolean;
+}>;

package/dist/types/parts/Dnd/DropIndicator.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+declare enum DropIndicatorPosition {
+    None = "none",
+    Before = "before",
+    After = "after"
+}
+interface DropIndicatorProps {
+    vertical: boolean;
+    dropIndicatorPosition: false | DropIndicatorPosition;
+    isDropValid: boolean;
+    isLast?: boolean;
+}
+declare const DropIndicator: React.ComponentType<DropIndicatorProps>;
+export { DropIndicator };
+export default DropIndicator;

package/dist/types/parts/Header.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../react-desc-prop-types.js';
+export declare const Header: React.MemoExoticComponent<(panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/HoC/withConditionalDnDRowContext.d.ts

@@ -0,0 +1,10 @@
+import type { DSShuttleV2T } from '../../react-desc-prop-types.js';
+type HoCConfig = DSShuttleV2T.PanelMetaInfo;
+type InternalHoCStates = {
+    activeId?: DSShuttleV2T.HydratedId;
+    overId?: DSShuttleV2T.HydratedId;
+    isDropValid?: boolean;
+};
+type ResultComponentProps = DSShuttleV2T.PanelMetaInfo & InternalHoCStates;
+export declare const withConditionalDnDRowContext: ConfiguredReactFunctionalHOC<HoCConfig, ResultComponentProps>;
+export {};

package/dist/types/parts/HoC/withConditionalUseSortable.d.ts

@@ -0,0 +1,8 @@
+import { useSortable } from '@elliemae/ds-legacy-drag-and-drop';
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+type HoCConfig = DSShuttleV2T.ItemMeta;
+type ResultComponentProps = DSShuttleV2T.ItemMeta & {
+    useSortableHelpers: ReturnType<typeof useSortable>;
+};
+export declare const withConditionalUseSortable: ConfiguredReactFunctionalHOC<HoCConfig, ResultComponentProps>;
+export {};

package/dist/types/parts/Item/Item.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+export declare const Item: React.MemoExoticComponent<(itemMeta: DSShuttleV2T.ItemMeta) => import("react/jsx-runtime.js").JSX.Element>;
+declare const ItemSortable: React.ComponentType<DSShuttleV2T.ItemMeta>;
+export { ItemSortable };
+export default ItemSortable;

package/dist/types/parts/Item/ItemActions/ItemActions.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const ItemActions: React.MemoExoticComponent<(itemMeta: DSShuttleV2T.ItemMeta) => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/Item/ItemActions/index.d.ts

@@ -0,0 +1 @@
+export * from './ItemActions.js';

package/dist/types/parts/Item/ItemActions/useActionsHandlers.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const useActionsHandlers: (itemMeta: DSShuttleV2T.ItemMeta) => {
+    handleClickDrilldown: (e: React.KeyboardEvent<HTMLButtonElement> | React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    handleClickSingleMove: (e: React.KeyboardEvent<HTMLButtonElement> | React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    handleKeyDownSelectionBubbleUp: React.KeyboardEventHandler<HTMLButtonElement>;
+};

package/dist/types/parts/Item/ItemActions/useActionsLogicHandlers.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const useActionsLogicHandlers: (itemMeta: DSShuttleV2T.ItemMeta) => {
+    handleDrilldown: (event: React.MouseEvent<HTMLButtonElement> | React.KeyboardEvent<HTMLButtonElement>) => void;
+    handleSingleMove: (event: React.MouseEvent<HTMLButtonElement> | React.KeyboardEvent<HTMLButtonElement>) => void;
+    preventKeyDownSelectionBubbleUp: (event: React.KeyboardEvent<HTMLButtonElement>) => void;
+};

package/dist/types/parts/Item/ItemActions/useInnerRefHandlers.d.ts

@@ -0,0 +1,6 @@
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const useInnerRefHandlers: ({ datumInternalMeta, isDestinationPanel }: DSShuttleV2T.ItemMeta) => {
+    innerRefHandlerDnd: (node: HTMLDivElement | null) => void;
+    innerRefHandlerDrilldown: (node: HTMLButtonElement) => void;
+    innerRefHandlerMove: (node: HTMLButtonElement) => void;
+};

package/dist/types/parts/Item/ItemMiddleSection.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+export declare const ItemMiddleSection: React.MemoExoticComponent<(props: DSShuttleV2T.ItemMeta & {
+    tooltipHelpers?: DSShuttleV2T.ComponentProps['tooltipHelpers'];
+}) => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/Item/ItemOverlay.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+export declare const ItemOverlay: React.MemoExoticComponent<(itemMeta: DSShuttleV2T.ItemMeta & {
+    tooltipHelpers?: DSShuttleV2T.ComponentProps['tooltipHelpers'];
+}) => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/Item/ItemSelection.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+export declare const ItemSelection: React.MemoExoticComponent<(itemMeta: DSShuttleV2T.ItemMeta) => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/Item/TextSection.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+export declare const TextSection: React.MemoExoticComponent<(props: DSShuttleV2T.ItemMeta) => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/Item/useItemArrowNavigation.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+export declare const useItemArrowNavigation: (itemMeta: DSShuttleV2T.ItemMeta) => {
+    onItemContainerKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+};

package/dist/types/parts/Item/useItemKeyboardSelection.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+export declare const useItemKeyboardSelection: (itemMeta: DSShuttleV2T.ItemMeta) => {
+    onItemKeyDownSelection: React.KeyboardEventHandler<HTMLDivElement>;
+};

package/dist/types/parts/Item/useSelectionLogic.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+export declare const useSelectionLogic: ({ isDestinationPanel, datumInternalMeta, datum, datumRenderFlags, }: DSShuttleV2T.ItemMeta) => {
+    selectItem: (event: React.KeyboardEvent<HTMLDivElement> | React.MouseEvent<HTMLDivElement | HTMLButtonElement>) => void;
+    onShiftMouseDownPreventTextSelection: (event: React.MouseEvent<HTMLDivElement>) => void;
+};

package/dist/types/parts/Item/useThisItemIsFocused.d.ts

@@ -0,0 +1,4 @@
+import { type DSShuttleV2T } from '../../react-desc-prop-types.js';
+type UseThisItemIsFocused = (itemMeta: DSShuttleV2T.ItemMeta) => boolean;
+export declare const useThisItemIsFocused: UseThisItemIsFocused;
+export {};

package/dist/types/parts/MainContent.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const MainContent: React.MemoExoticComponent<() => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/Panel/bottom/LoadMoreBtn.d.ts

@@ -0,0 +1,2 @@
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const LoadMoreBtn: (panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element;

package/dist/types/parts/Panel/bottom/LoadingMore.d.ts

@@ -0,0 +1,2 @@
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const LoadingMore: (panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element;

package/dist/types/parts/Panel/bottom/PanelContentBottomSection.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const PanelContentBottomSection: React.MemoExoticComponent<(panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/Panel/bottom/useInnerRefHandlers.d.ts

@@ -0,0 +1,4 @@
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const useInnerRefHandlers: ({ isDestinationPanel }: DSShuttleV2T.PanelMetaInfo) => {
+    innerRefHandlerLoadMoreBtn: (node: HTMLButtonElement) => void;
+};

package/dist/types/parts/Panel/bottom/useLoadMoreBtnArrowNavigation.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const useLoadMoreBtnArrowNavigation: (panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => {
+    onLoadMoreButtonKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+};

package/dist/types/parts/Panel/middle/EmptyItems.d.ts

@@ -0,0 +1,2 @@
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const EmptyItems: (panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element;

package/dist/types/parts/Panel/middle/ItemListWrapper/Index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../../../react-desc-prop-types.js';
+export declare const ItemListWrapperWithContext: React.ComponentType<DSShuttleV2T.PanelMetaInfo>;
+export default ItemListWrapperWithContext;

package/dist/types/parts/Panel/middle/ItemListWrapper/getDatumFlags.d.ts

@@ -0,0 +1,15 @@
+type GetDatumFlagsConfig = {
+    softDeleted: boolean;
+    preventMove?: boolean;
+    preventDrilldown?: boolean;
+    hasMultipleSelection?: boolean;
+};
+export declare const getDatumFlags: ({ softDeleted, preventMove, preventDrilldown, hasMultipleSelection, }: GetDatumFlagsConfig) => {
+    selectionPrevented: boolean;
+    withActions: boolean;
+    withMoveBtn: boolean;
+    withDrilldownBtn: boolean;
+    internallyDisabledMove: boolean;
+    internallyDisabledDrilldown: boolean;
+};
+export {};

package/dist/types/parts/Panel/middle/ItemListWrapper/useGetDatumHydratables.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../../../react-desc-prop-types.js';
+export declare const useGetDatumHydratables: (panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => (item: DSShuttleV2T.ConfiguredDatum) => {
+    preventDrilldown?: boolean | undefined;
+    CustomRenderer?: React.ComponentType<DSShuttleV2T.ComponentProps> | undefined;
+    Icon?: React.ComponentType<DSShuttleV2T.ComponentProps> | undefined;
+    subtitle?: string | undefined;
+    id: string;
+    preventMove: boolean;
+    label: string;
+};

package/dist/types/parts/Panel/middle/LoadingItems.d.ts

@@ -0,0 +1,2 @@
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const LoadingItems: (panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element;

package/dist/types/parts/Panel/middle/MultipleSelectionAction.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const MultipleSelectionAction: React.MemoExoticComponent<(panelMeta: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/Panel/middle/PanelContentMiddleSection.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const PanelContentMiddleSection: React.MemoExoticComponent<(panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/Panel/top/PanelContentTopSection.d.ts

@@ -0,0 +1,2 @@
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const PanelContentTopSection: (panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element;

package/dist/types/parts/Panel/top/PanelFilterSection.d.ts

@@ -0,0 +1,2 @@
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const PanelFilterSection: (panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element;

package/dist/types/parts/Panel/top/SelectionHeader.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../../../react-desc-prop-types.js';
+export declare const SelectionHeader: React.MemoExoticComponent<(panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element>;

package/dist/types/parts/PanelWrapper.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type DSShuttleV2T } from '../react-desc-prop-types.js';
+export declare const PanelWrapper: React.MemoExoticComponent<(panelMetaInfo: DSShuttleV2T.PanelMetaInfo) => import("react/jsx-runtime.js").JSX.Element>;