@servicetitan/anvil2 1.44.2 → 1.45.0

package/dist/components/Dialog/DialogFooter.d.ts

@@ -0,0 +1,33 @@
+import { ComponentPropsWithoutRef } from 'react';
+/**
+ * Props for the DialogFooter component
+ * @extends ComponentPropsWithoutRef<"footer">
+ */
+export type DialogFooterProps = ComponentPropsWithoutRef<"footer"> & {
+    /**
+     * @default false
+     */
+    sticky?: boolean;
+};
+/**
+ * DialogFooter component for the footer section of a Dialog.
+ *
+ * Features:
+ * - Container for dialog action buttons
+ * - Optional sticky positioning for long content
+ * - Consistent spacing and alignment
+ * - Right-aligned button layout by default
+ * - Flexible content area for custom layouts
+ *
+ * @example
+ * <Dialog.Footer sticky>
+ *   <Dialog.CancelButton>Cancel</Dialog.CancelButton>
+ *   <Button appearance="primary">Save</Button>
+ * </Dialog.Footer>
+ */
+export declare const DialogFooter: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    /**
+     * @default false
+     */
+    sticky?: boolean;
+} & import('react').RefAttributes<HTMLElement>>;

package/dist/components/Dialog/DialogHeader.d.ts

@@ -0,0 +1,21 @@
+import { ComponentPropsWithoutRef } from 'react';
+import { DataTrackingId } from '../../types';
+/**
+ * Props for the DialogHeader component
+ * @extends ComponentPropsWithoutRef<"header">
+ */
+export type DialogHeaderProps = ComponentPropsWithoutRef<"header"> & DataTrackingId;
+/**
+ * DialogHeader component for the header section of a Dialog.
+ *
+ * Features:
+ * - Displays dialog title with headline typography
+ * - Includes close button with proper accessibility
+ * - Sticky positioning for long content
+ * - Consistent spacing and styling
+ * - Automatic focus management
+ *
+ * @example
+ * <Dialog.Header>Confirm Delete</Dialog.Header>
+ */
+export declare const DialogHeader: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & DataTrackingId & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/Dialog/index.d.ts

@@ -1,2 +1,6 @@
-export * from './Dialog';
-export { Dialog as default } from './Dialog';
+export { Dialog as default, Dialog, type DialogProps, } from './Dialog';
+export { DialogCancelButton, type DialogCancelButtonProps, } from './DialogCancelButton';
+export { DialogContent, type DialogContentProps } from './DialogContent';
+export { DialogFooter, type DialogFooterProps } from './DialogFooter';
+export { DialogHeader, type DialogHeaderProps } from './DialogHeader';
+export type { LayoutUtilProps } from '../../types';

package/dist/components/Dialog/internal/DialogContext.d.ts

@@ -0,0 +1,8 @@
+import { RefObject, Dispatch, SetStateAction, MouseEvent } from 'react';
+export type DialogContextProps = {
+    close: (e?: MouseEvent<HTMLElement>) => void;
+    ref?: RefObject<HTMLDialogElement>;
+    hasOpenPopover?: boolean;
+    setHasOpenPopover?: Dispatch<SetStateAction<boolean | undefined>>;
+};
+export declare const DialogContext: import('react').Context<DialogContextProps | null>;

package/dist/components/Dialog/internal/useDialogContext.d.ts

@@ -0,0 +1 @@
+export declare function useDialogContext(): import('./DialogContext').DialogContextProps;

package/dist/components/Divider/Divider.d.ts

@@ -1,11 +1,27 @@
-import { DividerProps as CoreDividerProps } from '@servicetitan/hammer-react';
+import { ComponentPropsWithoutRef } from 'react';
+import { LayoutUtilProps } from '../../types';
 /**
  * Props for the Divider component
- * @property {"start" | "center" | "end"} [alignContent] - Controls the alignment of content within the divider
- * @property {"0" | "half" | "1" | "2" | "3" | "4" | "5" | "6" | "8" | "12" | 0 | 0.5 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 12} [spacing] - Controls the spacing around the divider
- * @property {boolean} [vertical] - When true, renders the divider vertically instead of horizontally
+ * @extends ComponentPropsWithoutRef<"span">
+ * @extends LayoutUtilProps
  */
-export type DividerProps = CoreDividerProps;
+export type DividerProps = ComponentPropsWithoutRef<"span"> & LayoutUtilProps & {
+    /**
+     * Controls the alignment of content within the divider.
+     * @default center
+     */
+    alignContent?: "start" | "center" | "end";
+    /**
+     * Controls the spacing around the divider.
+     * @default "0"
+     */
+    spacing?: "0" | "half" | "1" | "2" | "3" | "4" | "5" | "6" | "8" | "12" | 0 | 0.5 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 12;
+    /**
+     * When true, renders the divider vertically instead of horizontally.
+     * @default false
+     */
+    vertical?: boolean;
+};
 /**
  * Divider component for creating visual separators between content sections.
  *
@@ -17,15 +33,26 @@ export type DividerProps = CoreDividerProps;
  * - Supports layout utilities for positioning and spacing
  * - Flexible content placement with automatic line positioning
  * - Responsive design that adapts to container width
- * - Automatic tracking ID generation for analytics
  *
  * @example
  * <Divider spacing="2" alignContent="center">
  *   <b>Section Title</b>
  * </Divider>
  */
-export declare const Divider: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import('@servicetitan/hammer-react').LayoutUtilProps & {
+export declare const Divider: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & LayoutUtilProps & {
+    /**
+     * Controls the alignment of content within the divider.
+     * @default center
+     */
     alignContent?: "start" | "center" | "end";
+    /**
+     * Controls the spacing around the divider.
+     * @default "0"
+     */
     spacing?: "0" | "half" | "1" | "2" | "3" | "4" | "5" | "6" | "8" | "12" | 0 | 0.5 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 12;
+    /**
+     * When true, renders the divider vertically instead of horizontally.
+     * @default false
+     */
     vertical?: boolean;
 } & import('react').RefAttributes<HTMLSpanElement>>;

package/dist/components/Dnd/DndHandle.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Props for the DndHandle component
+ */
+export type DndHandleProps = {
+    /**
+     * Additional CSS class names to apply to the drag handle.
+     */
+    className?: string;
+};
+/**
+ * A reusable drag handle icon component for drag and drop interactions.
+ *
+ * Features:
+ * - Standardized drag indicator icon
+ * - Accessible with proper ARIA attributes
+ * - Customizable styling through className prop
+ * - Consistent visual appearance across applications
+ * - Lightweight and performant
+ * - Supports all standard HTML element props
+ *
+ * @example
+ * <DndHandle className="custom-drag-handle" />
+ */
+export declare function DndHandle({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/Dnd/DndHandleButton.d.ts

@@ -0,0 +1,32 @@
+import { ButtonCompound } from '../ButtonCompound';
+/**
+ * Props for the DndHandleButton component
+ * @extends React.ComponentPropsWithoutRef<typeof ButtonCompound>
+ */
+export interface DndHandleButtonProps extends React.ComponentPropsWithoutRef<typeof ButtonCompound> {
+    /**
+     * Indicates whether the handle is currently being dragged.
+     * @default false
+     */
+    isActive?: boolean;
+}
+/**
+ * A reusable drag handle button component for drag and drop functionality.
+ *
+ * Features:
+ * - Interactive button with drag handle icon
+ * - Visual feedback for active drag state
+ * - Accessible with proper ARIA attributes
+ * - Extends ButtonCompound functionality
+ * - Customizable styling through className prop
+ * - Supports all standard button props
+ * - Consistent visual appearance across applications
+ *
+ * @example
+ * <DndHandleButton
+ *   isActive={isDragging}
+ *   className="custom-handle-button"
+ *   onClick={handleClick}
+ * />
+ */
+export declare const DndHandleButton: import('react').ForwardRefExoticComponent<DndHandleButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/components/Dnd/DndSortLine.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Props for the DndSortLine component
+ * @extends React.ComponentPropsWithoutRef<"div">
+ */
+export type SortLineProps = React.ComponentPropsWithoutRef<"div"> & {
+    /**
+     * The offset of the line from the item. This is a CSS value, typically negative.
+     */
+    offset: string;
+    /**
+     * The orientation of the sort - Note this may be counterintuitive, as the line is rendered perpendicular to the sort.
+     */
+    orientation: "horizontal" | "vertical";
+    /**
+     * The position of the line relative to a target item.
+     */
+    position: "before" | "after";
+};
+/**
+ * A visual indicator line that shows where an item will be dropped during drag and drop operations.
+ *
+ * Features:
+ * - Visual feedback for drop positioning
+ * - Configurable orientation (horizontal/vertical)
+ * - Adjustable positioning (before/after)
+ * - Customizable offset for precise placement
+ * - Accessible with proper ARIA attributes
+ * - Automatic CSS class management
+ * - Supports all standard HTML div props
+ *
+ * @example
+ * <DndSortLine
+ *   offset="-10px"
+ *   orientation="vertical"
+ *   position="after"
+ *   className="custom-drop-line"
+ * />
+ */
+export declare const DndSortLine: ({ offset, orientation, position, ...rest }: SortLineProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Dnd/DndZone.d.ts

@@ -0,0 +1,55 @@
+import { ElementType, ReactNode } from 'react';
+/**
+ * Props for the DndZone component
+ * @extends Omit<React.ComponentPropsWithoutRef<T>, "el" | "ref">
+ */
+export type DndZoneProps<T extends ElementType = "div"> = {
+    /**
+     * The HTML element type to render. Can be any valid HTML element or React component.
+     * @default "div"
+     */
+    el?: T;
+    /**
+     * The content to be rendered inside the drop zone.
+     */
+    children?: ReactNode;
+    /**
+     * Additional CSS class names to apply to the drop zone.
+     */
+    className?: string;
+    /**
+     * Indicates whether a draggable item is currently over this drop zone.
+     */
+    isOver: boolean;
+    /**
+     * Indicates whether the current drag operation is valid for this drop zone.
+     */
+    isValid: boolean;
+    /**
+     * Indicates whether any item is currently being dragged.
+     */
+    isDragging: boolean;
+} & Omit<React.ComponentPropsWithoutRef<T>, "el" | "ref">;
+/**
+ * Base styling component for drop zones that handles visual states and styling.
+ *
+ * Features:
+ * - Configurable HTML element rendering with the 'el' prop
+ * - Visual feedback for drag states (over, valid, dragging)
+ * - Automatic CSS class management based on drag state
+ * - Supports all standard HTML element props
+ * - Accessible with proper ARIA attributes
+ * - Flexible styling through className prop
+ * - Responsive design that adapts to container
+ *
+ * @example
+ * <DndZone
+ *   isOver={isOver}
+ *   isValid={isValid}
+ *   isDragging={isDragging}
+ *   className="custom-drop-zone"
+ * >
+ *   Drop items here
+ * </DndZone>
+ */
+export declare const DndZone: import('react').ForwardRefExoticComponent<Omit<DndZoneProps<ElementType>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/Dnd/index.d.ts

@@ -1 +1,7 @@
-export { Dnd } from '@servicetitan/hammer-react';
+import { DndHandle } from './DndHandle';
+export declare const Dnd: {
+    Handle: typeof DndHandle;
+    HandleButton: import('react').ForwardRefExoticComponent<import('./DndHandleButton').DndHandleButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
+    SortLine: ({ offset, orientation, position, ...rest }: import('./DndSortLine').SortLineProps) => import("react/jsx-runtime").JSX.Element;
+    Zone: import('react').ForwardRefExoticComponent<Omit<import('./DndZone').DndZoneProps<import('react').ElementType>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+};

package/dist/components/DndSort/DndSort.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode } from 'react';
+import { DndSortChangeEvent } from './types';
+/**
+ * Props for the DndSort component
+ */
+export type DndSortProps = {
+    /**
+     * Callback function that is called when an item is dropped.
+     * Provides information about the drop event including source, destination, and validity.
+     */
+    onDrop?: (event: DndSortChangeEvent) => void;
+    /**
+     * The content to be rendered inside the DndSort context.
+     * Should include DndSortZone and DndSortCard components.
+     */
+    children: ReactNode;
+};
+/**
+ * Root component for drag and drop sorting functionality.
+ *
+ * Features:
+ * - Provides drag and drop context for child components
+ * - Supports both mouse and touch interactions
+ * - Keyboard accessibility with arrow key navigation
+ * - Automatic collision detection and positioning
+ * - Screen reader announcements for accessibility
+ * - Flexible drop event handling
+ * - Supports multiple drop zones and draggable items
+ * - Visual feedback during drag operations
+ *
+ * @example
+ * <DndSort onDrop={handleDrop}>
+ *   <DndSortZone id="zone-1" label="Zone 1">
+ *     <DndSortCard id="item-1" label="Item 1">
+ *       Item content
+ *     </DndSortCard>
+ *   </DndSortZone>
+ * </DndSort>
+ */
+export default function DndSort({ children, onDrop, }: DndSortProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/DndSort/DndSortCard.d.ts

@@ -0,0 +1,63 @@
+import { CardProps } from '../Card';
+import { DndSortChangeEvent } from './types';
+/**
+ * Props for the DndSortCard component
+ * @extends Omit<CardProps, "id">
+ */
+export type DndSortCardProps = Omit<CardProps, "id"> & {
+    /**
+     * The content to be displayed inside the card.
+     */
+    children: React.ReactNode;
+    /**
+     * If true, the card can only be dragged when the drag handle is used.
+     * If false, the entire card can be dragged.
+     * @default false
+     */
+    dragOnlyWithHandle?: boolean;
+    /**
+     * The unique identifier for the card.
+     */
+    id: string | number;
+    /**
+     * The label for the card, used for accessibility.
+     */
+    label: string;
+    /**
+     * Callback function that is called when the card is dropped.
+     */
+    onDrop?: (event: DndSortChangeEvent) => void;
+    /**
+     * The type of the card, used for validation.
+     */
+    type?: string;
+    /**
+     * Function to render a custom preview of the card when it's being dragged.
+     */
+    previewRenderer?: () => React.ReactNode;
+};
+/**
+ * A card component that can be dragged and dropped using the DndSort system.
+ *
+ * Features:
+ * - Draggable card with visual feedback
+ * - Optional drag handle for controlled dragging
+ * - Custom preview rendering during drag
+ * - Type-based validation support
+ * - Accessible with proper ARIA attributes
+ * - Extends Card component functionality
+ * - Supports both handle-only and full-card dragging
+ * - Visual feedback for active drag state
+ * - Flexible content rendering
+ *
+ * @example
+ * <DndSortCard
+ *   id="card-1"
+ *   label="Card 1"
+ *   dragOnlyWithHandle={true}
+ *   onDrop={handleCardDrop}
+ * >
+ *   Card content here
+ * </DndSortCard>
+ */
+export default function DndSortCard({ children, dragOnlyWithHandle, id, label, onDrop, type, previewRenderer: previewRendererProp, ...rest }: DndSortCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/DndSort/DndSortZone.d.ts

@@ -0,0 +1,130 @@
+import { ReactNode } from 'react';
+import { FlexProps } from '../Flex';
+import { GapSize } from '../../types';
+import { DndSortZoneAdvancedRenderer } from './types';
+/**
+ * Common properties shared by all zone types
+ */
+type CommonZoneProps = {
+    /**
+     * Array of accepted types for the drop zone. Items with matching types can be dropped here.
+     */
+    acceptedTypes?: string[];
+    /**
+     * The content to be rendered inside the drop zone.
+     */
+    children?: ReactNode;
+    /**
+     * Whether the drop zone is disabled and cannot accept drops.
+     */
+    disabled?: boolean;
+    /**
+     * Unique identifier for the drop zone.
+     */
+    id: string | number;
+    /**
+     * Label for the drop zone, used for accessibility.
+     */
+    label: string;
+    /**
+     * Function to render the drop zone using internal state parameters.
+     */
+    advancedRenderer?: DndSortZoneAdvancedRenderer;
+    /**
+     * Function to validate the drop action. Returns true for valid drops, false for invalid drops.
+     */
+    validator?: (id: string | number) => boolean;
+};
+/**
+ * Properties for sortable zones that can reorder items
+ */
+type SortableZoneProps = CommonZoneProps & {
+    /**
+     * Indicates this zone can sort and reorder items.
+     */
+    sortable: true;
+    /**
+     * Array of sorted IDs for the items in the zone, must match render order.
+     */
+    sortedIds: (string | number)[];
+    /**
+     * Determines where an item will be placed when dropped loosely in a zone.
+     * @default "end"
+     */
+    defaultDropPosition?: "start" | "end";
+    /**
+     * Gap size between items in the drop zone, necessary for the placement of the drop line.
+     * Must reserve space for the drop line.
+     */
+    gap?: Exclude<GapSize, 0 | "0" | "half">;
+    /**
+     * Orientation of the items in the drop zone.
+     */
+    orientation: "horizontal" | "vertical";
+};
+/**
+ * Properties for non-sortable zones that only accept drops
+ */
+type NonSortableZoneProps = CommonZoneProps & {
+    /**
+     * Indicates this zone cannot sort items.
+     * @default false
+     */
+    sortable?: false;
+    /**
+     * Not available for non-sortable zones.
+     */
+    sortedIds?: never;
+    /**
+     * Not available for non-sortable zones.
+     */
+    defaultDropPosition?: never;
+    /**
+     * Gap size between items in the drop zone.
+     */
+    gap?: GapSize;
+    /**
+     * Orientation of the items in the drop zone.
+     */
+    orientation?: "horizontal" | "vertical";
+};
+/**
+ * Props for the DndSortZone component
+ */
+export type DndSortZoneProps = SortableZoneProps | NonSortableZoneProps;
+/**
+ * Props for the DndSortZone component with Flex layout support
+ * @extends Omit<FlexProps, "id" | "gap">
+ * @extends DndSortZoneProps
+ */
+export type DndSortZonePropsWithFlexLayout = Omit<FlexProps, "id" | "gap"> & DndSortZoneProps;
+/**
+ * A drop zone component for drag and drop sorting functionality.
+ *
+ * Features:
+ * - Configurable as sortable or non-sortable zones
+ * - Type-based validation for accepted items
+ * - Custom validation functions
+ * - Visual feedback during drag operations
+ * - Flexible layout with horizontal/vertical orientation
+ * - Advanced rendering with state parameters
+ * - Accessible with proper ARIA attributes
+ * - Extends Flex component functionality
+ * - Automatic drop line positioning
+ * - Support for custom gap sizing
+ *
+ * @example
+ * <DndSortZone
+ *   id="zone-1"
+ *   label="Sortable Zone"
+ *   sortable={true}
+ *   sortedIds={["item-1", "item-2"]}
+ *   orientation="vertical"
+ *   acceptedTypes={["card"]}
+ * >
+ *   <DndSortCard id="item-1" label="Item 1">Content</DndSortCard>
+ *   <DndSortCard id="item-2" label="Item 2">Content</DndSortCard>
+ * </DndSortZone>
+ */
+export default function DndSortZone(props: DndSortZonePropsWithFlexLayout): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/DndSort/index.d.ts

@@ -1,2 +1,12 @@
-export { DndSort, DndSortCard, DndSortZone } from '@servicetitan/hammer-react';
-export type { DndSortProps, DndSortCardProps, DndSortZoneProps, DndSortChangeEvent, DndSortZoneAdvancedRenderer, } from '@servicetitan/hammer-react';
+import { default as DndSortRoot } from './DndSort';
+import { default as DndSortCard } from './DndSortCard';
+import { default as DndSortZone } from './DndSortZone';
+export declare const DndSort: typeof DndSortRoot & {
+    Card: typeof DndSortCard;
+    Zone: typeof DndSortZone;
+};
+export { DndSortCard, DndSortZone };
+export { type DndSortProps } from './DndSort';
+export { type DndSortCardProps } from './DndSortCard';
+export { type DndSortZoneProps } from './DndSortZone';
+export type { DndSortChangeEvent, DndSortZoneAdvancedRenderer } from './types';

package/dist/components/DndSort/internal/DndSortContext.d.ts

@@ -0,0 +1,21 @@
+import { Dispatch, ReactNode, SetStateAction } from 'react';
+import { DndSortChangeEvent } from '../types';
+export type PreviewRendererParams = {
+    valid: boolean;
+};
+export type PreviewRenderer = (params: PreviewRendererParams) => ReactNode;
+export type DndSortContextValue = {
+    previewRenderer: PreviewRenderer;
+    setPreviewRenderer: Dispatch<SetStateAction<PreviewRenderer>>;
+    onDrop: (event: DndSortChangeEvent) => void;
+};
+/**
+ * Our internal context provider for the DndSort system. Not to be confused with DndContext which is the `dnd-kit` context.
+ * @param props
+ * @param props.children The children components that will have access to the context
+ */
+export default function DndSortContextProvider({ children, onDrop, }: {
+    children: ReactNode;
+    onDrop: (event: DndSortChangeEvent) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const useDndSortContext: () => DndSortContextValue;

package/dist/components/DndSort/internal/DndSortItem.d.ts

@@ -0,0 +1,30 @@
+import { DraggableAttributes } from '@dnd-kit/core';
+import { SyntheticListenerMap } from '@dnd-kit/core/dist/hooks/utilities';
+import { DndSortChangeEvent } from '../types';
+type DndSortItemChildrenParams = {
+    setNodeRef: (node: HTMLElement | null) => void;
+    setActivatorNodeRef: (node: HTMLElement | null) => void;
+    attributes: DraggableAttributes;
+    listeners?: SyntheticListenerMap;
+    style: React.CSSProperties;
+};
+type DndSortItemProps = {
+    children: (params: DndSortItemChildrenParams) => React.ReactNode;
+    id: string | number;
+    label: string;
+    onDrop?: (event: DndSortChangeEvent) => void;
+    type?: string;
+};
+/**
+ * A generic draggable component for the DndSort system. Can be used to create any draggable item.
+ *
+ * @param props
+ * @param props.children A function that receives the necessary props to make the item draggable
+ * @param props.id The unique identifier for the draggable item
+ * @param props.label The label for the draggable item
+ * @param props.onDrop The callback function to be called when the item is dropped
+ * @param props.type The type of the draggable item, used for validation (optional)
+ * @returns
+ */
+export default function DndSortItem({ children: childrenFn, id, label, onDrop: onDropProp, type, }: DndSortItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/DndSort/internal/DndSortOverlay.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Component for rendering previews as items are dragged.
+ * The preview is determined by the rendering function stored in context.
+ */
+export default function DndSortOverlay(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/DndSort/internal/DndSortZoneContext.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { DndSortZoneProps } from '../DndSortZone';
+export type PreviewRendererParams = {
+    valid: boolean;
+};
+export type PreviewRenderer = (params: PreviewRendererParams) => ReactNode;
+export type DndSortZoneContextValue = (Omit<DndSortZoneProps, "sortedIds" | "orientation" | "gap"> & {
+    sortable: boolean;
+    sortedIds?: (string | number)[];
+    orientation?: "horizontal" | "vertical";
+}) | null;
+/**
+ * Tells items information about the zone they are contained within.
+ * @param props - The props for the DndSortZoneContextProvider component
+ * @param props.children - The child components to be rendered inside the context provider
+ * @param props.id - The unique identifier for the drop zone
+ * @param props.sortable - Whether the drop zone is sortable
+ * @param props.sortedIds - The sorted IDs of the items in the drop zone
+ * @param props.orientation - The orientation of the drop zone
+ 
+ * @returns
+ */
+export default function DndSortZoneContextProvider(props: DndSortZoneContextValue): import("react/jsx-runtime").JSX.Element;
+export declare const useDndSortZoneContext: () => DndSortZoneContextValue;

package/dist/components/DndSort/internal/announcements.d.ts

@@ -0,0 +1,8 @@
+import { DragCancelEvent, DragEndEvent, DragOverEvent, DragStartEvent } from '@dnd-kit/core';
+declare const announcements: {
+    onDragStart: (event: DragStartEvent) => string;
+    onDragOver: (event: DragOverEvent) => string;
+    onDragEnd: (event: DragEndEvent) => string;
+    onDragCancel: (event: DragCancelEvent) => string;
+};
+export default announcements;

package/dist/components/DndSort/internal/collisionDetection.d.ts

@@ -0,0 +1,3 @@
+import { CollisionDetection } from '@dnd-kit/core';
+declare const collisionDetection: CollisionDetection;
+export default collisionDetection;