@salt-ds/lab 1.0.0-alpha.0

package/dist-types/combo-box-deprecated/internal/usePopperStatus.d.ts

@@ -0,0 +1,10 @@
+import { SyntheticEvent, KeyboardEvent } from "react";
+export declare const isToggleList: (event: KeyboardEvent) => boolean;
+export declare const usePopperStatus: (props: {
+    initialOpen?: boolean | undefined;
+    isMultiSelect?: boolean | undefined;
+    onClose?: ((event: SyntheticEvent) => void) | undefined;
+}) => {
+    isOpen: boolean;
+    notifyPopper: (event: SyntheticEvent) => void;
+};

package/dist-types/common-hooks/calcPreferredHeight.d.ts

@@ -0,0 +1 @@
+export function calcPreferredHeight(props?: {}): number | undefined;

package/dist-types/common-hooks/collectionProvider.d.ts

@@ -0,0 +1,13 @@
+import { ReactElement } from "react";
+import { CollectionHookResult } from "./collectionTypes";
+export interface collectionContext<T> {
+    collection: CollectionHookResult<T>;
+}
+export declare const CollectionContext: import("react").Context<CollectionHookResult<any> | undefined>;
+interface ContextProviderProps<Item> {
+    children: ReactElement;
+    collectionHook: CollectionHookResult<Item>;
+}
+export declare function CollectionProvider<Item>({ children, collectionHook, ...props }: ContextProviderProps<Item>): JSX.Element;
+export declare function useCollection<Item>(): CollectionHookResult<Item> | undefined;
+export {};

package/dist-types/common-hooks/collectionTypes.d.ts

@@ -0,0 +1,56 @@
+import { ReactNode } from "react";
+import { SelectionStrategy, SingleSelectionStrategy } from "./selectionTypes";
+export interface CollectionIndexer {
+    value: number;
+}
+export interface CollectionItemBase<T> {
+    id: string;
+    description?: string;
+    disabled?: boolean;
+    focusable?: false | undefined;
+    index?: number;
+    label?: string;
+    value: T | null;
+}
+export interface CollectionItem<T> extends CollectionItemBase<T> {
+    childNodes?: CollectionItem<T>[];
+    count?: number;
+    expanded?: boolean;
+    header?: boolean;
+    level?: number;
+    selectable?: boolean;
+}
+export interface SourceGroup<T> {
+    childNodes: T[];
+}
+export declare type CollectionOptions<T> = {
+    collapsibleHeaders?: boolean;
+    defaultExpanded?: boolean;
+    filterPattern?: string;
+    getFilterRegex?: (inputValue: string) => RegExp;
+    getItemId?: (indexOfItem: number) => string;
+    noChildrenLabel?: string;
+    itemToString?: (item: T) => string;
+    revealSelected?: boolean | T | T[];
+};
+export declare type CollectionHookProps<T> = {
+    children?: ReactNode;
+    id: string;
+    label?: string;
+    source?: ReadonlyArray<T>;
+    options?: CollectionOptions<T>;
+};
+export declare type CollectionHookResult<T> = {
+    /** set expanded to false for target */
+    collapseGroupItem: (item: CollectionItem<T>) => void;
+    /** data items from the collection to be rendered */
+    data: CollectionItem<T>[];
+    /** set expanded to true for target */
+    expandGroupItem: (item: CollectionItem<T>) => void;
+    setFilterPattern: (pattern: undefined | string) => void;
+    itemById: (id: string) => T | never;
+    itemToCollectionItem: <Selection extends SelectionStrategy, U extends T | T[] | null | undefined>(item: U) => Selection extends SingleSelectionStrategy ? CollectionItem<T> | null : CollectionItem<T>[];
+    stringToCollectionItem: <Selection extends SelectionStrategy>(item: string | null | undefined) => Selection extends SingleSelectionStrategy ? CollectionItem<T> | null : CollectionItem<T>[];
+    toCollectionItem: (item: T) => CollectionItem<T>;
+    itemToId: (item: T) => string;
+};

package/dist-types/common-hooks/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./useAutoSizer";
+export * from "./calcPreferredHeight";
+export * from "./collectionProvider";
+export * from "./collectionTypes";
+export * from "./itemToString";
+export * from "./keyUtils";
+export * from "./useCollapsibleGroups";
+export * from "./list-dom-utils";
+export * from "./navigationTypes";
+export * from "./selectionTypes";
+export * from "./useCollectionItems";
+export * from "./useImperativeScrollingAPI";
+export * from "./useKeyboardNavigation";
+export * from "./useKeyboardNavigationPanel";
+export * from "./useSelection";
+export * from "./useTypeahead";
+export * from "./useViewportTracking";
+export * from "./utils";

package/dist-types/common-hooks/itemToString.d.ts

@@ -0,0 +1,2 @@
+export declare type ItemToStringFunction = (item: any) => string;
+export declare function itemToString(item: unknown): string;

package/dist-types/common-hooks/keyUtils.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+export declare const ArrowUp = "ArrowUp";
+export declare const ArrowDown = "ArrowDown";
+export declare const ArrowLeft = "ArrowLeft";
+export declare const ArrowRight = "ArrowRight";
+export declare const Enter = "Enter";
+export declare const Escape = "Escape";
+export declare const Home = "Home";
+export declare const End = "End";
+export declare const PageUp = "PageUp";
+export declare const PageDown = "PageDown";
+export declare const Space = " ";
+export declare const Tab = "Tab";
+export declare const isCharacterKey: (evt: React.KeyboardEvent) => boolean;
+export declare const isNavigationKey: ({ key }: React.KeyboardEvent) => boolean;

package/dist-types/common-hooks/list-dom-utils.d.ts

@@ -0,0 +1,6 @@
+export declare const listItemElement: (listEl: HTMLElement, listItemIdx: number) => Element | null;
+export declare function listItemIndex(listItemEl?: HTMLElement): number;
+export declare const listItemId: (el: HTMLElement | null) => string | undefined;
+export declare const closestListItem: (el: HTMLElement) => HTMLElement;
+export declare const closestListItemId: (el: HTMLElement) => string | undefined;
+export declare const closestListItemIndex: (el: HTMLElement) => number;

package/dist-types/common-hooks/navigationTypes.d.ts

@@ -0,0 +1,37 @@
+import { FocusEvent, KeyboardEvent, RefObject } from "react";
+import { CollectionItem } from "./collectionTypes";
+import { SelectionStrategy, SingleSelectionStrategy } from "./selectionTypes";
+export interface NavigationProps<Item = unknown> {
+    cycleFocus?: boolean;
+    defaultHighlightedIndex?: number;
+    disableHighlightOnFocus?: boolean;
+    focusOnHighlight?: boolean;
+    focusVisible?: number;
+    highlightedIndex?: number;
+    indexPositions: CollectionItem<Item>[];
+    onHighlight?: (idx: number) => void;
+    onKeyboardNavigation?: (evt: KeyboardEvent, idx: number) => void;
+    restoreLastFocus?: boolean;
+}
+export interface NavigationHookProps<Item, Selection extends SelectionStrategy> extends NavigationProps<Item> {
+    containerRef: RefObject<HTMLElement>;
+    label?: string;
+    selected?: Selection extends SingleSelectionStrategy ? CollectionItem<Item> | null : CollectionItem<Item>[];
+}
+export interface KeyboardHookListProps {
+    onBlur: (evt: FocusEvent) => void;
+    onFocus: (evt: FocusEvent) => void;
+    onKeyDown: (evt: KeyboardEvent) => void;
+    onMouseDownCapture: () => void;
+    onMouseMove: () => void;
+    onMouseLeave: () => void;
+}
+export interface NavigationHookResult {
+    focusVisible: number;
+    controlledHighlighting: boolean;
+    highlightedIndex: number;
+    setHighlightedIndex: (idx: number) => void;
+    keyboardNavigation: RefObject<boolean>;
+    listProps: KeyboardHookListProps;
+    setIgnoreFocus: (ignoreFocus: boolean) => void;
+}

package/dist-types/common-hooks/selectionTypes.d.ts

@@ -0,0 +1,40 @@
+import { SyntheticEvent } from "react";
+import { CollectionItem } from "./collectionTypes";
+export declare const SINGLE = "default";
+export declare const MULTIPLE = "multiple";
+export declare const EXTENDED = "extended";
+export declare const DESELECTABLE = "deselectable";
+export declare type SingleSelectionStrategy = "default" | "deselectable";
+export declare type MultiSelectionStrategy = "multiple" | "extended" | "extended-multi-range";
+export declare type SelectionStrategy = SingleSelectionStrategy | MultiSelectionStrategy;
+export declare type selectedType<Item, Selection extends SelectionStrategy> = Selection extends MultiSelectionStrategy ? Item[] : Item | null;
+export declare type SelectHandler<Item = string> = (event: SyntheticEvent, selectedItem: Item) => void;
+export declare type SelectionChangeHandler<Item = string, Selection extends SelectionStrategy = "default"> = (event: SyntheticEvent, selected: Selection extends SingleSelectionStrategy ? Item | null : Item[]) => void;
+export declare const hasSelection: <Item = unknown>(selected: Item | Item[] | null) => boolean;
+export declare const getFirstSelectedItem: <Item = unknown>(selected: Item | Item[] | null) => Item | null;
+export interface SelectionProps<Item, Selection extends SelectionStrategy = "default"> {
+    defaultSelected?: Selection extends SingleSelectionStrategy ? Item | null : Item[];
+    onSelect?: SelectHandler<Item>;
+    onSelectionChange?: SelectionChangeHandler<Item, Selection>;
+    selected?: Selection extends SingleSelectionStrategy ? Item | null : Item[];
+    selectionStrategy?: Selection;
+}
+export interface ListHandlers {
+    onClick?: (event: React.MouseEvent) => void;
+    onKeyDown?: (event: React.KeyboardEvent) => void;
+    onKeyboardNavigation?: (event: React.KeyboardEvent, currentIndex: number) => void;
+    onMouseMove?: (event: React.MouseEvent) => void;
+}
+export interface SelectionHookProps<Item, Selection extends SelectionStrategy = "default"> extends SelectionProps<CollectionItem<Item>, Selection> {
+    disableSelection?: boolean;
+    highlightedIdx: number;
+    indexPositions: CollectionItem<Item>[];
+    label?: string;
+    selectionKeys?: string[];
+    tabToSelect?: boolean;
+}
+export interface SelectionHookResult<Item, Selection extends SelectionStrategy = "default"> {
+    listHandlers: ListHandlers;
+    selected: Selection extends SingleSelectionStrategy ? CollectionItem<Item> | null : CollectionItem<Item>[];
+    setSelected: (selected: Selection extends SingleSelectionStrategy ? CollectionItem<Item> | null : CollectionItem<Item>[]) => void;
+}

package/dist-types/common-hooks/use-drag-drop.d.ts

@@ -0,0 +1,13 @@
+export function useDragDrop({ allowDragDrop, onDrop, orientation, containerRef, itemQuery, }: {
+    allowDragDrop: any;
+    onDrop: any;
+    orientation: any;
+    containerRef: any;
+    itemQuery?: string | undefined;
+}): {
+    draggable: null;
+    dropIndicator: null;
+    draggedItemIndex: any;
+    isDragging: boolean;
+    onMouseDown: ((evt: any) => void) | undefined;
+};

package/dist-types/common-hooks/use-hierarchical-drag-drop.d.ts

@@ -0,0 +1,13 @@
+export function useDragDrop({ allowDragDrop, onDrop, orientation, containerRef, itemQuery, }: {
+    allowDragDrop: any;
+    onDrop: any;
+    orientation: any;
+    containerRef: any;
+    itemQuery?: string | undefined;
+}): {
+    draggable: null;
+    dropIndicator: null;
+    draggedItemIndex: any;
+    isDragging: boolean;
+    onMouseDown: ((evt: any) => void) | undefined;
+};

package/dist-types/common-hooks/useAutoSizer.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from "react";
+export interface ListAutosizerProps {
+    containerRef: RefObject<Element>;
+    responsive: boolean;
+    height?: number | string;
+    width?: number | string;
+}
+interface size {
+    height?: number | string;
+    width?: number | string;
+}
+export declare function useAutoSizer<Element extends HTMLElement>(props: ListAutosizerProps): size;
+export {};

package/dist-types/common-hooks/useCollapsibleGroups.d.ts

@@ -0,0 +1,14 @@
+import { ListHandlers } from "./selectionTypes";
+import { CollectionHookResult } from "./collectionTypes";
+interface CollapsibleHookProps<Item> {
+    collapsibleHeaders?: boolean;
+    collectionHook: CollectionHookResult<Item>;
+    highlightedIdx: number;
+    onToggle?: (node: Item) => void;
+}
+interface CollapsibleHookResult<Item> {
+    onClick?: ListHandlers["onClick"];
+    onKeyDown?: ListHandlers["onKeyDown"];
+}
+export declare const useCollapsibleGroups: <Item>({ collapsibleHeaders, collectionHook, highlightedIdx, onToggle, }: CollapsibleHookProps<Item>) => CollapsibleHookResult<Item>;
+export {};

package/dist-types/common-hooks/useCollectionItems.d.ts

@@ -0,0 +1,2 @@
+import { CollectionHookProps, CollectionHookResult } from "./collectionTypes";
+export declare const useCollectionItems: <Item>({ children, id: idRoot, label, options, source, }: CollectionHookProps<Item>) => CollectionHookResult<Item>;

package/dist-types/common-hooks/useImperativeScrollingAPI.d.ts

@@ -0,0 +1,14 @@
+import { ForwardedRef, MutableRefObject } from "react";
+import { CollectionHookResult, CollectionItem } from "./collectionTypes";
+export interface ScrollingAPI<Item> {
+    scrollToIndex: (itemIndex: number) => void;
+    scrollToItem: (item: Item) => void;
+    scrollTo: (scrollOffset: number) => void;
+}
+export interface ScrollingAPIHook<Item> {
+    collectionHook: CollectionHookResult<Item>;
+    forwardedRef?: ForwardedRef<ScrollingAPI<Item>>;
+    scrollableRef: MutableRefObject<HTMLElement | null>;
+    scrollIntoView?: (item: CollectionItem<Item>) => void;
+}
+export declare const useImperativeScrollingAPI: <Item>({ collectionHook, forwardedRef, scrollableRef, scrollIntoView, }: ScrollingAPIHook<Item>) => void;

package/dist-types/common-hooks/useKeyboardNavigation.d.ts

@@ -0,0 +1,4 @@
+import { NavigationHookProps, NavigationHookResult } from "./navigationTypes";
+import { SelectionStrategy } from "./selectionTypes";
+export declare const LIST_FOCUS_VISIBLE = -2;
+export declare const useKeyboardNavigation: <Item, Selection_1 extends SelectionStrategy>({ containerRef, defaultHighlightedIndex, disableHighlightOnFocus, highlightedIndex: highlightedIndexProp, indexPositions, onHighlight, onKeyboardNavigation, restoreLastFocus, selected, }: NavigationHookProps<Item, Selection_1>) => NavigationHookResult;

package/dist-types/common-hooks/useKeyboardNavigationPanel.d.ts

@@ -0,0 +1,2 @@
+import { NavigationProps, NavigationHookResult } from "./navigationTypes";
+export declare const useKeyboardNavigationPanel: ({ cycleFocus, defaultHighlightedIndex: defaultHighlightedIdx, focusOnHighlight, highlightedIndex: highlightedIdxProp, indexPositions, onHighlight, onKeyboardNavigation, }: NavigationProps) => NavigationHookResult;

package/dist-types/common-hooks/useSelection.d.ts

@@ -0,0 +1,8 @@
+import { SelectionHookProps, SelectionHookResult, SelectionStrategy } from "./selectionTypes";
+export declare const CHECKBOX = "checkbox";
+export declare const GROUP_SELECTION_NONE = "none";
+export declare const GROUP_SELECTION_SINGLE = "single";
+export declare const GROUP_SELECTION_CASCADE = "cascade";
+export declare type GroupSelectionMode = "none" | "single" | "cascade";
+export declare const groupSelectionEnabled: (groupSelection: GroupSelectionMode) => boolean;
+export declare const useSelection: <Item, Selection_1 extends SelectionStrategy = "default">({ defaultSelected, disableSelection, highlightedIdx, indexPositions, label, onSelect, onSelectionChange, selected: selectedProp, selectionStrategy, selectionKeys, tabToSelect, }: SelectionHookProps<Item, Selection_1>) => SelectionHookResult<Item, Selection_1>;

package/dist-types/common-hooks/useTypeahead.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { CollectionItem } from "./collectionTypes";
+interface TypeaheadHookProps<Item> {
+    disableTypeToSelect?: boolean;
+    highlightedIdx: number;
+    highlightItemAtIndex: (idx: number) => void;
+    applyIncrementalSearch?: boolean;
+    typeToNavigate: boolean;
+    items: CollectionItem<Item>[];
+}
+interface TypeaheadHookResult {
+    onKeyDown?: (e: React.KeyboardEvent) => void;
+}
+export declare const useTypeahead: <Item>({ disableTypeToSelect, highlightedIdx, highlightItemAtIndex, typeToNavigate, items, applyIncrementalSearch, }: TypeaheadHookProps<Item>) => TypeaheadHookResult;
+export {};

package/dist-types/common-hooks/useViewportTracking.d.ts

@@ -0,0 +1,14 @@
+import { MutableRefObject, RefObject } from "react";
+import { CollectionItem } from "./collectionTypes";
+export interface ViewportTrackingProps<Item> {
+    containerRef: RefObject<HTMLElement>;
+    contentRef?: RefObject<HTMLElement>;
+    highlightedIdx?: number;
+    indexPositions: CollectionItem<Item>[];
+    stickyHeaders?: boolean;
+}
+export interface ViewportTrackingResult<Item> {
+    isScrolling: MutableRefObject<boolean>;
+    scrollIntoView: (item: CollectionItem<Item>) => void;
+}
+export declare const useViewportTracking: <Item>({ containerRef, contentRef, highlightedIdx, indexPositions, stickyHeaders, }: ViewportTrackingProps<Item>) => ViewportTrackingResult<Item>;

package/dist-types/common-hooks/utils/collection-item-utils.d.ts

@@ -0,0 +1,21 @@
+import { ReactElement, ReactNode } from "react";
+import { CollectionItem, CollectionOptions } from "../collectionTypes";
+export declare const sourceItemHasProp: (item: unknown, propertyName: string) => boolean;
+export declare const isHeader: (item: unknown) => boolean;
+export declare const isGroupNode: (item: unknown) => boolean;
+export declare const isDisabled: (item: unknown) => boolean;
+export declare const isFocusable: (item: unknown) => boolean;
+export declare const countChildItems: <Item>(item: CollectionItem<Item>, items: CollectionItem<Item>[], idx: number) => number;
+export declare const getChildLabel: (element: ReactElement<{
+    children?: ReactNode;
+    label?: string;
+    title?: string;
+}>) => string | undefined;
+export declare const childIsGroup: (child: ReactElement) => boolean;
+export declare const getChildNodes: (element: ReactElement) => CollectionItem<ReactElement>[] | undefined;
+declare type CollectionItemWithoutId<T> = Omit<CollectionItem<T>, "id">;
+export declare const sourceItems: <T>(source?: readonly T[] | undefined, options?: CollectionOptions<T> | undefined) => CollectionItemWithoutId<T>[] | undefined;
+export declare const childItems: (children: ReactNode) => CollectionItem<ReactElement>[] | undefined;
+export declare const isParentPath: (parentPath: string, childPath: string) => boolean;
+export declare function replaceCollectionItem<Item>(nodes: CollectionItem<Item>[], id: string, props: Partial<CollectionItem<Item>>): CollectionItem<Item>[];
+export {};

package/dist-types/common-hooks/utils/filter-utils.d.ts

@@ -0,0 +1,4 @@
+export declare type GetFilterRegex = (inputValue: string) => RegExp;
+export declare type FilterPredicate = (item: string) => boolean;
+export declare const getDefaultFilterRegex: GetFilterRegex;
+export declare const getDefaultFilter: (inputValue?: string, getFilterRegex?: GetFilterRegex) => (itemValue?: string) => boolean;

package/dist-types/common-hooks/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./collection-item-utils";
+export * from "./filter-utils";
+export * from "./isSelected";

package/dist-types/common-hooks/utils/isSelected.d.ts

@@ -0,0 +1,2 @@
+import { CollectionItem } from "../collectionTypes";
+export declare function isSelected<Item>(selected: CollectionItem<Item> | CollectionItem<Item>[] | null, item: CollectionItem<Item>): boolean;

package/dist-types/contact-details/ContactAction.d.ts

@@ -0,0 +1,15 @@
+import { ButtonProps } from "@salt-ds/core";
+import { IconProps } from "@salt-ds/icons";
+import { ComponentType } from "react";
+import { TooltipProps } from "../tooltip";
+export declare type ContactActionProps = ButtonProps & {
+    accessibleText?: string;
+    tooltipProps?: TooltipProps;
+} & ({
+    label: string;
+    icon?: ComponentType<IconProps>;
+} | {
+    label?: string;
+    icon: ComponentType<IconProps>;
+});
+export declare const ContactAction: import("react").ForwardRefExoticComponent<ContactActionProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist-types/contact-details/ContactActions.d.ts

@@ -0,0 +1,4 @@
+import { HTMLAttributes } from "react";
+export interface ContactActionsProps extends HTMLAttributes<HTMLDivElement> {
+}
+export declare const ContactActions: import("react").ForwardRefExoticComponent<ContactActionsProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/contact-details/ContactAvatar.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { AvatarProps } from "../avatar";
+export interface ContactAvatarProps extends AvatarProps {
+}
+export declare const ContactAvatar: import("react").ForwardRefExoticComponent<ContactAvatarProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/contact-details/ContactDetails.d.ts

@@ -0,0 +1,9 @@
+import { HTMLAttributes } from "react";
+import "./ContactDetails.css";
+export declare type ContactDetailsVariant = "default" | "compact" | "mini";
+export interface ContactDetailsProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: ContactDetailsVariant;
+    stackAtBreakpoint?: number;
+    embedded?: boolean;
+}
+export declare const ContactDetails: import("react").ForwardRefExoticComponent<ContactDetailsProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/contact-details/ContactFavoriteToggle.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { FavoriteToggleWithTooltipProps } from "./internal";
+import { TooltipProps } from "../tooltip";
+export interface ContactFavoriteToggleProps extends FavoriteToggleWithTooltipProps {
+    isFavorite?: boolean;
+    defaultIsFavorite?: boolean;
+    onChange?: (isFavorite: boolean) => void;
+    tooltipProps?: TooltipProps;
+}
+export declare const ContactFavoriteToggle: import("react").ForwardRefExoticComponent<ContactFavoriteToggleProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist-types/contact-details/ContactMetadata.d.ts

@@ -0,0 +1,6 @@
+import { HTMLAttributes } from "react";
+export interface ContactMetadataProps extends HTMLAttributes<HTMLDivElement> {
+    collapsible?: boolean;
+    collapseButtonId?: string;
+}
+export declare const ContactMetadata: import("react").ForwardRefExoticComponent<ContactMetadataProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/contact-details/ContactMetadataItem.d.ts

@@ -0,0 +1,10 @@
+import { IconProps } from "@salt-ds/icons";
+import { ComponentType, HTMLAttributes } from "react";
+import { ValueComponentProps } from "./types";
+export interface ContactMetadataItemProps extends HTMLAttributes<HTMLDivElement> {
+    label?: string;
+    value: string;
+    icon?: ComponentType<IconProps>;
+    ValueComponent?: ComponentType<ValueComponentProps>;
+}
+export declare const ContactMetadataItem: import("react").ForwardRefExoticComponent<ContactMetadataItemProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/contact-details/ContactPrimaryInfo.d.ts

@@ -0,0 +1,5 @@
+import { HTMLAttributes } from "react";
+export interface ContactPrimaryInfoProps extends HTMLAttributes<HTMLDivElement> {
+    text: string;
+}
+export declare const ContactPrimaryInfo: import("react").ForwardRefExoticComponent<ContactPrimaryInfoProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/contact-details/ContactSecondaryInfo.d.ts

@@ -0,0 +1,9 @@
+import { IconProps } from "@salt-ds/icons";
+import { ComponentType, HTMLAttributes } from "react";
+import { ValueComponentProps } from "./types";
+export interface ContactSecondaryInfoProps extends HTMLAttributes<HTMLDivElement> {
+    icon?: ComponentType<IconProps>;
+    text: string;
+    ValueComponent?: ComponentType<ValueComponentProps>;
+}
+export declare const ContactSecondaryInfo: import("react").ForwardRefExoticComponent<ContactSecondaryInfoProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/contact-details/ContactTertiaryInfo.d.ts

@@ -0,0 +1,7 @@
+import { IconProps } from "@salt-ds/icons";
+import { ComponentType, HTMLAttributes } from "react";
+export interface ContactTertiaryInfoProps extends HTMLAttributes<HTMLDivElement> {
+    icon?: ComponentType<IconProps>;
+    text: string;
+}
+export declare const ContactTertiaryInfo: import("react").ForwardRefExoticComponent<ContactTertiaryInfoProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/contact-details/MailLinkComponent.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { ValueComponentProps } from "./types";
+export declare const MailLinkComponent: (props: ValueComponentProps) => JSX.Element;

package/dist-types/contact-details/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./ContactAction";
+export * from "./ContactActions";
+export * from "./ContactAvatar";
+export * from "./ContactDetails";
+export * from "./ContactMetadata";
+export * from "./ContactMetadataItem";
+export * from "./ContactPrimaryInfo";
+export * from "./ContactSecondaryInfo";
+export * from "./ContactTertiaryInfo";
+export * from "./ContactFavoriteToggle";
+export * from "./MailLinkComponent";
+export * from "./types";

package/dist-types/contact-details/internal/ContactDetailsContext.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { ContactDetailsVariant } from "../ContactDetails";
+export interface ContactDetailsContext {
+    variant: ContactDetailsVariant;
+    primary?: string;
+    setPrimary: (primary?: string) => void;
+    primaryId?: string;
+    setPrimaryId: (primaryId?: string) => void;
+    secondary?: string;
+    setSecondary: (secondary?: string) => void;
+    secondaryId?: string;
+    setSecondaryId: (secondaryId?: string) => void;
+    tertiary?: string;
+    setTertiary: (tertiary?: string) => void;
+    tertiaryId?: string;
+    setTertiaryId: (tertiaryId?: string) => void;
+    hasAvatar?: boolean;
+    setHasAvatar: (hasAvatar: boolean) => void;
+    isStacked?: boolean;
+}
+export declare const ContactDetailsContext: import("react").Context<ContactDetailsContext | undefined>;
+export declare const useContactDetailsContext: () => ContactDetailsContext;

package/dist-types/contact-details/internal/FavoriteToggle.d.ts

@@ -0,0 +1,12 @@
+import React, { FocusEventHandler, KeyboardEventHandler, MouseEventHandler } from "react";
+import { StarIconContainerProps } from "./StarIconContainer";
+export interface FavoriteToggleProps extends Omit<StarIconContainerProps, "onChange"> {
+    onBlur?: FocusEventHandler;
+    onChange?: (isSelected: boolean) => void;
+    onClick?: (event: React.MouseEvent<HTMLSpanElement>) => void;
+    onFocus?: FocusEventHandler;
+    onKeyDown?: KeyboardEventHandler<HTMLSpanElement>;
+    onMouseEnter?: MouseEventHandler<HTMLSpanElement>;
+    onMouseLeave?: MouseEventHandler<HTMLSpanElement>;
+}
+export declare const FavoriteToggle: React.ForwardRefExoticComponent<FavoriteToggleProps & React.RefAttributes<HTMLSpanElement>>;

package/dist-types/contact-details/internal/FavoriteToggleWithTooltip.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { FavoriteToggleProps } from "./FavoriteToggle";
+import { TooltipProps } from "../../tooltip";
+export interface FavoriteToggleWithTooltipProps extends FavoriteToggleProps {
+    tooltipProps?: TooltipProps;
+    tooltipTitle?: string;
+}
+export declare const FavoriteToggleWithTooltip: import("react").ForwardRefExoticComponent<FavoriteToggleWithTooltipProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist-types/contact-details/internal/StarIcon.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+export interface StarIconProps {
+    className?: string;
+    selected?: boolean;
+    highlighted?: boolean;
+}
+export declare const StarIcon: React.ForwardRefExoticComponent<StarIconProps & React.RefAttributes<SVGSVGElement>>;

package/dist-types/contact-details/internal/StarIconContainer.d.ts

@@ -0,0 +1,9 @@
+import React, { HTMLAttributes } from "react";
+export interface StarIconContainerProps extends HTMLAttributes<HTMLSpanElement> {
+    className?: string;
+    isFocusVisible?: boolean;
+    isFocused?: boolean;
+    isHighlighted?: boolean;
+    isSelected?: boolean;
+}
+export declare const StarIconContainer: React.ForwardRefExoticComponent<StarIconContainerProps & React.RefAttributes<HTMLSpanElement>>;

package/dist-types/contact-details/internal/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./FavoriteToggleWithTooltip";
+export * from "./ContactDetailsContext";
+export * from "./useComponentSize";

package/dist-types/contact-details/internal/useComponentSize.d.ts

@@ -0,0 +1,6 @@
+import { MutableRefObject } from "react";
+export interface ComponentSize {
+    height?: number;
+    width: number;
+}
+export declare function useComponentSize<T extends HTMLElement>(initialWidth: number): [MutableRefObject<T | null>, ComponentSize];

package/dist-types/contact-details/types.d.ts

@@ -0,0 +1,4 @@
+import { HTMLAttributes } from "react";
+export interface ValueComponentProps extends HTMLAttributes<HTMLSpanElement> {
+    value?: string;
+}

package/dist-types/content-status/ContentStatus.d.ts

@@ -0,0 +1,9 @@
+import { HTMLAttributes, MouseEvent, Ref } from "react";
+import { StatusIndicatorProps } from "./internal/StatusIndicator";
+import "./ContentStatus.css";
+export interface ContentStatusProps extends HTMLAttributes<HTMLDivElement>, StatusIndicatorProps {
+    actionLabel?: string;
+    buttonRef?: Ref<any>;
+    onActionClick?: (evt: MouseEvent<HTMLButtonElement>) => void;
+}
+export declare const ContentStatus: import("react").ForwardRefExoticComponent<ContentStatusProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/content-status/index.d.ts

@@ -0,0 +1 @@
+export * from "./ContentStatus";

package/dist-types/content-status/internal/StatusIndicator.d.ts

@@ -0,0 +1,13 @@
+import { StatusIndicatorProps as BaseStatusIndicatorProps } from "@salt-ds/core";
+import { ReactElement } from "react";
+import { CircularProgressProps } from "../../progress";
+import { SpinnerProps } from "../../spinner";
+export interface StatusIndicatorProps extends Pick<SpinnerProps, "disableAnnouncer">, Pick<CircularProgressProps, "unit" | "value"> {
+    title?: string;
+    message?: string;
+    CircularProgressProps?: Partial<CircularProgressProps>;
+    SpinnerProps?: Partial<SpinnerProps>;
+    id?: string;
+    status?: BaseStatusIndicatorProps["status"] | "loading";
+}
+export declare function StatusIndicator({ status, disableAnnouncer, unit, value, title, message, CircularProgressProps: { className: circularProgressClassName, ...restCircularProgressProps }, SpinnerProps: { className: spinnerClassName, ...restSpinnerProps }, id, }: StatusIndicatorProps): ReactElement;