@salt-ds/lab 1.0.0-alpha.0

package/dist-types/list-deprecated/ListItemContext.d.ts

@@ -0,0 +1,11 @@
+import { Context } from "react";
+export interface ListItemContextProps<Item> {
+    disableMouseDown?: boolean;
+    getItemId: (index: number) => string;
+    getItemHeight?: (index?: number) => number | string;
+    itemToString: (item: Item) => string;
+    itemTextHighlightPattern?: RegExp | string;
+}
+export declare type ListItemContextType<Item> = Context<ListItemContextProps<Item>>;
+export declare const ListItemContext: Context<ListItemContextProps<unknown> | undefined>;
+export declare const useListItemContext: <Item>() => ListItemContextProps<Item>;

package/dist-types/list-deprecated/ListProps.d.ts

@@ -0,0 +1,177 @@
+import { HTMLAttributes, Ref, SyntheticEvent } from "react";
+import { TooltipContextProps } from "../tooltip";
+export declare type ListSingleSelectionVariant = "default" | "deselectable";
+export declare type ListMultiSelectionVariant = "multiple" | "extended";
+export declare type ListSelectionVariant = ListSingleSelectionVariant | ListMultiSelectionVariant;
+export declare type ListChangeHandler<Item = string, Variant extends ListSelectionVariant = "default"> = (event: SyntheticEvent, item: null | (Variant extends ListMultiSelectionVariant ? Array<Item> : Item)) => void;
+export declare type ListSelectHandler<Item = string> = (event: SyntheticEvent, item: Item | null) => void;
+export interface ListBaseProps<Item = string> extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "onSelect"> {
+    /**
+     * The component used for item instead of the default.
+     */
+    ListItem?: any;
+    /**
+     * The component used when there are no items.
+     */
+    ListPlaceholder?: any;
+    /**
+     * If `true`, the component will have no border.
+     */
+    borderless?: boolean;
+    /**
+     * If `true`, the component will not receive focus.
+     *
+     * Useful when list is used with other components to form a tightly coupled atomic component where
+     * other components should receive focus instead. For instance, when used with an input to form a
+     * combo box the list should not be focused, the input should receive focus instead.
+     */
+    disableFocus?: boolean;
+    /**
+     * If `true`, the component will prevent mousedown event from firing.
+     *
+     * Useful when list is used with other components to form a tightly coupled atomic component where
+     * a click/select on list should not cause the focus to blur away from the current active element.
+     */
+    disableMouseDown?: boolean;
+    /**
+     * If `true`, the component will be disabled.
+     */
+    disabled?: boolean;
+    /**
+     * The number of items displayed in the visible area.
+     *
+     * Note that this determines the max height of the list if the list height is not set to 100%.
+     */
+    displayedItemCount?: number;
+    /**
+     * The indexer function used when there is no source. It should return a number.
+     *
+     * @param {number} index The item index.
+     */
+    getItemAtIndex?: (index: number) => Item;
+    /**
+     * Used for providing customized item height. It should return a number or a string if item height
+     * is in percentage. When used with `virtualized` prop a variable-height list will be rendered instead
+     * of a fixed-height one.
+     *
+     * @param {number} index The item index.
+     */
+    getItemHeight?: (index?: number) => number;
+    /**
+     * Used for providing customized item ids.
+     *
+     * @param {number} index The item index.
+     */
+    getItemId?: (index: number) => string;
+    /**
+     * The function for getting item's index.
+     *
+     * @param {object} item The item.
+     */
+    getItemIndex?: (item: Item) => number;
+    /**
+     * Height of the component.
+     */
+    height?: number | string;
+    /**
+     * The total number of items.
+     *
+     * Used for keyboard navigation (when `End` key is pressed) and when the list is virtualized.
+     */
+    itemCount?: number;
+    /**
+     * Size of the gap between list items.
+     */
+    itemGapSize?: number;
+    /**
+     * Height of an item. I can be a number or a string if item height is in percentage. If omitted
+     * default height values from Salt theme will be used.
+     *
+     * Note that when using a percentage value, the list must have a height.
+     */
+    itemHeight?: number | string;
+    /**
+     * Used for providing text highlight.
+     *
+     * It can be a capturing regex or a string for a straightforward string matching.
+     */
+    itemTextHighlightPattern?: RegExp | string;
+    /**
+     * Item `toString` function when list is not used declaratively and its items are objects
+     * instead of strings. The string value is also used in tooltip when item text is truncated.
+     *
+     * If omitted, component will look for a `label` property on the data object.
+     *
+     * @param {object} item The item.
+     */
+    itemToString?: (item: Item) => string;
+    /**
+     * Used for accessing the scrollable list node inside of the component. If you want to access
+     * the outer wrapper node use `ref` instead.
+     */
+    listRef?: Ref<HTMLElement>;
+    /**
+     * Maximum list height.
+     */
+    maxHeight?: number | string;
+    /**
+     * Maximum list width.
+     */
+    maxWidth?: number | string;
+    /**
+     * Minimum list height.
+     */
+    minHeight?: number | string;
+    /**
+     * Minimum list width.
+     */
+    minWidth?: number | string;
+    /**
+     * @external - react-window
+     *
+     * The number of items to render outside of the visible area.
+     */
+    overscanCount?: number;
+    /**
+     * If `true`, the component will remember the last keyboard-interacted position
+     * and highlight it when list is focused again.
+     */
+    restoreLastFocus?: boolean;
+    /**
+     * Data source used. It should be an array of objects or strings.
+     */
+    source?: ReadonlyArray<Item>;
+    /**
+     * @external - react-window
+     *
+     * If `true`, list will be virtualized.
+     * @see https://github.com/bvaughn/react-window
+     */
+    virtualized?: boolean;
+    /**
+     * Width of the component.
+     */
+    width?: number | string;
+}
+export interface ListProps<Item = string, Variant extends ListSelectionVariant = "default"> extends ListBaseProps<Item> {
+    Tooltip?: TooltipContextProps["Tooltip"];
+    disableTypeToSelect?: boolean;
+    getItemIndex?: (item: Item) => number;
+    highlightedIndex?: number;
+    initialSelectedItem?: Variant extends ListMultiSelectionVariant ? Array<Item> : Item;
+    onChange?: ListChangeHandler<Item, Variant>;
+    onSelect?: ListSelectHandler<Item>;
+    selectedItem?: Variant extends ListMultiSelectionVariant ? Array<Item> : Item;
+    selectionVariant?: Variant;
+    /**
+     * When set to `true`, 'Tab' key selects current highlighted item before focus is blurred away
+     * from the component. This would be the desirable behaviour for any dropdown menu based
+     * components like dropdown, combobox.
+     *
+     * @default false
+     */
+    tabToSelect?: boolean;
+    tooltipEnterDelay?: TooltipContextProps["enterDelay"];
+    tooltipLeaveDelay?: TooltipContextProps["leaveDelay"];
+    tooltipPlacement?: TooltipContextProps["placement"];
+}

package/dist-types/list-deprecated/ListStateContext.d.ts

@@ -0,0 +1,2 @@
+export const ListStateContext: import("react").Context<any>;
+export function useListStateContext(): any;

package/dist-types/list-deprecated/filterHelpers.d.ts

@@ -0,0 +1,2 @@
+export declare const getDefaultFilterRegex: (value: string) => RegExp;
+export declare const getDefaultFilter: (inputValue?: string, getFilterRegex?: (value: string) => RegExp) => (itemValue?: string) => boolean;

package/dist-types/list-deprecated/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./ListProps";
+export * from "./List";
+export * from "./ListBase";
+export * from "./ListItemBase";
+export * from "./ListItem";
+export * from "./ListItemContext";
+export * from "./ListStateContext";
+export * from "./useList";
+export * from "./useListItem";
+export * from "./useTypeSelect";
+export * from "./itemToString";

package/dist-types/list-deprecated/internal/DescendantContext.d.ts

@@ -0,0 +1,7 @@
+export function DescendantProvider({ items, ...props }: {
+    [x: string]: any;
+    items: any;
+}): JSX.Element;
+export function useDescendant(descendant: any): number;
+export const DescendantContext: React.Context<any>;
+import React from "react";

package/dist-types/list-deprecated/internal/Highlighter.d.ts

@@ -0,0 +1 @@
+export function Highlighter(props: any): JSX.Element;

package/dist-types/list-deprecated/internal/calcPreferredListHeight.d.ts

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

package/dist-types/list-deprecated/internal/getWithDefault.d.ts

@@ -0,0 +1 @@
+export function getWithDefault(value: any, defaultValue: any): any;

package/dist-types/list-deprecated/internal/helpers.d.ts

@@ -0,0 +1,2 @@
+export function isPlainObject(obj: any): boolean;
+export function calcPreferredListHeight(props?: {}): number | undefined;

package/dist-types/list-deprecated/internal/scrollIntoView.d.ts

@@ -0,0 +1 @@
+export function scrollIntoView(item: any, list: any): void;

package/dist-types/list-deprecated/internal/useListAutoSizer.d.ts

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

package/dist-types/list-deprecated/internal/useWidth.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from "react";
+export declare function useWidth<Element extends HTMLElement>(responsive: boolean): [RefObject<Element>, number];

package/dist-types/list-deprecated/itemToString.d.ts

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

package/dist-types/list-deprecated/useList.d.ts

@@ -0,0 +1,30 @@
+import { AriaAttributes, Dispatch, KeyboardEvent, KeyboardEventHandler, MouseEvent, Ref, SetStateAction } from "react";
+import { ListMultiSelectionVariant, ListProps, ListSelectionVariant } from "./ListProps";
+interface listBoxAriaProps extends Pick<AriaAttributes, "aria-activedescendant" | "aria-multiselectable"> {
+    role: string;
+}
+export interface ListState<Item = string, Variant extends ListSelectionVariant = "default"> {
+    id?: string;
+    focusVisible: boolean;
+    selectedItem?: Variant extends ListMultiSelectionVariant ? Array<Item> : Item;
+    highlightedIndex?: number;
+    isDeselectable: boolean;
+    isMultiSelect: boolean;
+    isDisabled: boolean;
+}
+export interface ListHelpers<Item = string, Variant extends ListSelectionVariant = "default"> {
+    setFocusVisible: (visible: boolean) => void;
+    setSelectedItem: Dispatch<SetStateAction<(Variant extends ListMultiSelectionVariant ? Item[] : Item) | undefined>>;
+    setHighlightedIndex: (highlightedIndex?: number) => void;
+    handleSelect: (event: MouseEvent<HTMLElement> | KeyboardEvent<HTMLElement>, index: number | undefined, item: Item) => void;
+    keyDownHandlers: {
+        [key: string]: KeyboardEventHandler;
+    };
+}
+export declare function useList<Item, Variant extends ListSelectionVariant>(props?: ListProps<Item, Variant>): {
+    focusedRef: Ref<any>;
+    listProps: Partial<ListProps<Item, Variant>> & listBoxAriaProps;
+    state: ListState<Item, Variant>;
+    helpers: ListHelpers<Item, Variant>;
+};
+export {};

package/dist-types/list-deprecated/useListItem.d.ts

@@ -0,0 +1,32 @@
+import { ListChildComponentProps } from "react-window";
+import { ListItemProps } from "./ListItem";
+import { ListItemBaseProps } from "./ListItemBase";
+declare type UseItemHookReturnType<Item> = {
+    /**
+     * Item data
+     */
+    item: Item;
+    /**
+     * Utility function for converting item data to a string
+     */
+    itemToString: (item: Item) => string;
+    /**
+     * Properties applied to a basic list item component
+     */
+    itemProps: ListItemBaseProps;
+};
+export interface IndexedListItemProps<Item> extends ListItemProps<Item> {
+    ariaProps?: {
+        role?: string;
+        "aria-disabled"?: string;
+        "aria-checked"?: string;
+        "aria-posinset"?: number;
+        "aria-setsize"?: number;
+    };
+    index: number;
+    itemHeight?: number | string;
+}
+export declare function useListItem<Item>(props: IndexedListItemProps<Item>): UseItemHookReturnType<Item>;
+declare type VirtualizedListItemProps = Pick<ListChildComponentProps, "index" | "style" | "data">;
+export declare const useVirtualizedListItem: (props: VirtualizedListItemProps) => UseItemHookReturnType<any>;
+export {};

package/dist-types/list-deprecated/useTypeSelect.d.ts

@@ -0,0 +1,3 @@
+export function useTypeSelect(options: any): {
+    onKeyDownCapture: (event: any) => void;
+};

package/dist-types/logo/Logo.d.ts

@@ -0,0 +1,32 @@
+import { ComponentType, ComponentPropsWithoutRef } from "react";
+import { LogoTitleProps } from "./internal/LogoTitle";
+import "./Logo.css";
+export interface LogoProps extends ComponentPropsWithoutRef<"span"> {
+    /**
+     * Used to provide application title
+     */
+    appTitle?: string;
+    /**
+     * If `true`, the logo will be compact;
+     */
+    compact?: boolean;
+    /**
+     * Props passed to the Logo.
+     */
+    ImageProps?: Partial<ComponentPropsWithoutRef<"img">>;
+    /**
+     * Custom Component to render the logo image.
+     * e.g. if a custom renderer instead of static image using `src` prop.
+     */
+    LogoImageComponent?: ComponentType<Partial<ComponentPropsWithoutRef<"img">>>;
+    /**
+     * Image src for logo.
+     */
+    src?: string;
+    /**
+     * Props passed to the Application Title if used.
+     * If using a custom image then ImageProps.alt should be set to include a screen reader alternative text.
+     */
+    TitleProps?: Omit<Partial<LogoTitleProps>, "label">;
+}
+export declare const Logo: import("react").ForwardRefExoticComponent<LogoProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist-types/logo/index.d.ts

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

package/dist-types/logo/internal/LogoTitle.d.ts

@@ -0,0 +1,6 @@
+import { ComponentPropsWithoutRef } from "react";
+export interface LogoTitleProps extends ComponentPropsWithoutRef<"span"> {
+    label?: string;
+    separatorClassname?: string;
+}
+export declare const LogoTitle: import("react").ForwardRefExoticComponent<LogoTitleProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist-types/menu-button/MenuButton.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+import { ButtonProps } from "@salt-ds/core";
+import { CascadingMenuProps } from "../cascading-menu";
+export interface MenuButtonProps extends ButtonProps {
+    CascadingMenuProps: CascadingMenuProps;
+    children: ReactNode;
+    className?: string;
+    hideCaret?: boolean;
+}
+export declare const MenuButton: import("react").ForwardRefExoticComponent<MenuButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist-types/menu-button/MenuButtonTrigger.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+import { ButtonProps } from "@salt-ds/core";
+import "./MenuButtonTrigger.css";
+export interface MenuButtonTriggerProps extends ButtonProps {
+    className?: string;
+    hideCaret?: boolean;
+    isMenuOpen?: boolean;
+    children?: ReactNode;
+}
+export declare const MenuButtonTrigger: import("react").ForwardRefExoticComponent<MenuButtonTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist-types/menu-button/index.d.ts

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

package/dist-types/metric/Metric.d.ts

@@ -0,0 +1,18 @@
+import { HTMLAttributes } from "react";
+import { MetricContextValue } from "./internal";
+import "./Metric.css";
+export interface MetricProps extends MetricContextValue, HTMLAttributes<HTMLDivElement> {
+    /**
+     * The aria-level attribute to be applied to the heading component. The default is 2.
+     *
+     * As an ADA requirement, the heading component should be the first valid component inside the Metric. It is the title
+     * if <MetricHeader/> is placed before <MerticContent/>. It is the main value if <MerticContent/> is placed before <MetricHeader/>.
+     */
+    headingAriaLevel?: number;
+    /**
+     * This prop is used to help implement the accessibility logic.
+     * If you don't provide this prop. It falls back to a randomly generated id.
+     */
+    id?: string;
+}
+export declare const Metric: import("react").ForwardRefExoticComponent<MetricProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/metric/MetricContent.d.ts

@@ -0,0 +1,25 @@
+import { IconProps } from "@salt-ds/icons";
+import { ComponentType, HTMLAttributes } from "react";
+import "./MetricContent.css";
+export interface MetricContentProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * These props will be passed to the indicator icon. Use this to render a
+     * custom icon.
+     *
+     * @see `Icon` for a list of valid props.
+     */
+    IndicatorIconProps?: Partial<IconProps>;
+    /**
+     * Replace the default Icon component
+     */
+    IndicatorIconComponent?: ComponentType<IconProps>;
+    /**
+     * Other data that may serve as additional information to the main value
+     */
+    subvalue?: string | number;
+    /**
+     * The main value to display in the metric
+     */
+    value: string | number;
+}
+export declare const MetricContent: import("react").ForwardRefExoticComponent<MetricContentProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/metric/MetricHeader.d.ts

@@ -0,0 +1,20 @@
+import { LinkProps } from "@salt-ds/core";
+import { HTMLAttributes } from "react";
+import "./MetricHeader.css";
+export interface MetricHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * If provided, subtitle will be rendered as a `Link` element with these props.
+     *
+     * @see `Link` for a list of valid props.
+     */
+    SubtitleLinkProps?: Omit<Partial<LinkProps>, "children">;
+    /**
+     * Subtitle of the Metric Header
+     */
+    subtitle?: string;
+    /**
+     * Title of the Metric Header
+     */
+    title: string;
+}
+export declare const MetricHeader: import("react").ForwardRefExoticComponent<MetricHeaderProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/metric/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Metric";
+export * from "./MetricHeader";
+export * from "./MetricContent";

package/dist-types/metric/internal/MetricContext.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="react" />
+export interface MetricContextValue {
+    /**
+     * Text and value alignment.
+     */
+    align?: "left" | "center" | "right";
+    /**
+     * The direction of the main value
+     */
+    direction?: "up" | "down";
+    /**
+     * The position of the indicator with regards to the main value.
+     */
+    indicatorPosition?: "start" | "end";
+    /**
+     * The metric orientation (layout flow direction).
+     */
+    orientation?: "horizontal" | "vertical";
+    /**
+     * If 'true', an indicator will be displayed which shows the direction of the main value
+     */
+    showIndicator?: boolean;
+    /**
+     * Set title's heading level. Defaults to 2
+     */
+    headingAriaLevel?: number;
+    /**
+     * Size of the metric value. Defaults to 'medium'
+     */
+    size?: "small" | "medium" | "large";
+}
+export interface MetricContextComponentIds {
+    /**
+     * id of the subtitle
+     */
+    subtitleId?: string;
+    /**
+     * id of the title
+     */
+    titleId?: string;
+    /**
+     * id of the value
+     */
+    valueId?: string;
+}
+export declare const MetricContextProvider: import("react").Provider<MetricContextValue & MetricContextComponentIds>;
+export declare const useMetricContext: () => MetricContextValue & MetricContextComponentIds;

package/dist-types/metric/internal/helpers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This function only capitalise the first letter of a string.
+ */
+export declare const capitalise: (target: any) => string;

package/dist-types/metric/internal/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MetricContext";
+export * from "./helpers";

package/dist-types/overlay/Overlay.d.ts

@@ -0,0 +1,17 @@
+import { ComponentProps, ComponentPropsWithoutRef } from "react";
+import { UseFloatingUIProps } from "../popper";
+import "./Overlay.css";
+interface ADAExceptions {
+    showClose?: boolean;
+}
+export interface OverlayProps extends ComponentPropsWithoutRef<"div">, Partial<Pick<UseFloatingUIProps, "onOpenChange" | "open">> {
+    /**
+     * object that houses ada related props.
+     * adaExceptions.showClose defaults to true. It can be removed at the risk of ADA compliance
+     */
+    adaExceptions?: ADAExceptions;
+    arrowProps?: ComponentProps<"div">;
+    variant?: "primary" | "secondary";
+}
+export declare const Overlay: import("react").ForwardRefExoticComponent<OverlayProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist-types/overlay/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Overlay";
+export * from "./useOverlay";

package/dist-types/overlay/useOverlay.d.ts

@@ -0,0 +1,8 @@
+import { ComponentPropsWithRef, JSXElementConstructor } from "react";
+import { OverlayProps } from "./Overlay";
+import { UseFloatingUIProps } from "../popper";
+export declare type UseOverlayProps = Partial<Pick<UseFloatingUIProps, "onOpenChange" | "open" | "placement">>;
+export declare function useOverlay(props: UseOverlayProps): {
+    getTriggerProps: <Element_1 extends JSXElementConstructor<any> | keyof JSX.IntrinsicElements = "div">(userProps?: import("react").PropsWithoutRef<import("react").ComponentProps<Element_1>> | undefined) => ComponentPropsWithRef<Element_1>;
+    getOverlayProps: (userProps?: OverlayProps | undefined) => OverlayProps;
+};

package/dist-types/pagination/ArrowButton.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { ButtonProps } from "@salt-ds/core";
+export declare type ArrowButtonType = "previous" | "next";
+export interface ArrowButtonProps extends ButtonProps {
+    arrowButtonType: ArrowButtonType;
+    onPress: () => void;
+}
+export declare const ArrowButton: ({ arrowButtonType, onPress, onKeyDown: onKeyDownProp, onClick: onClickProp, ...restProps }: ArrowButtonProps) => JSX.Element;

package/dist-types/pagination/CompactControls.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { FormFieldProps } from "../form-field";
+export interface CompactControlsProps {
+    count: number;
+    page: number;
+    onPageChange: (page: number) => void;
+    FormFieldProps?: Partial<FormFieldProps>;
+}
+export declare const CompactControls: ({ page, count, onPageChange, FormFieldProps, }: CompactControlsProps) => JSX.Element;

package/dist-types/pagination/CompactInput.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { FormFieldProps } from "../form-field";
+export interface CompactInputProps {
+    count: number;
+    page: number;
+    onPageChange: (page: number) => void;
+    FormFieldProps?: Partial<FormFieldProps>;
+}
+export declare const CompactInput: ({ page, count, onPageChange, FormFieldProps: { className, ...restFormFieldProps }, }: CompactInputProps) => JSX.Element;

package/dist-types/pagination/GoToInput.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes } from "react";
+import { FormFieldProps } from "../form-field";
+export interface GoToInputProps extends HTMLAttributes<HTMLSpanElement> {
+    label?: string;
+    FormFieldProps?: Partial<FormFieldProps>;
+}
+export declare const GoToInput: import("react").ForwardRefExoticComponent<GoToInputProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist-types/pagination/PageButton.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export interface PageButtonProps {
+    page: number;
+    isSelected?: boolean;
+    onPageChange: (page: number) => void;
+    disabled?: boolean;
+}
+export declare const PageButton: ({ page, isSelected, onPageChange, disabled, }: PageButtonProps) => JSX.Element;

package/dist-types/pagination/Pagination.d.ts

@@ -0,0 +1,9 @@
+import { HTMLAttributes } from "react";
+export interface PaginationProps extends HTMLAttributes<HTMLElement> {
+    count: number;
+    page?: number;
+    initialPage?: number;
+    onPageChange?: (page: number) => void;
+    compact?: boolean;
+}
+export declare const Pagination: import("react").ForwardRefExoticComponent<PaginationProps & import("react").RefAttributes<HTMLElement>>;

package/dist-types/pagination/PaginationContext.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+export interface PaginationContext {
+    page: number;
+    count: number;
+    compact: boolean;
+    onPageChange: (page: number) => void;
+    paginatorElement?: HTMLDivElement;
+    setPaginatorElement: (element: HTMLDivElement) => void;
+}
+export declare const paginationContext: import("react").Context<PaginationContext>;

package/dist-types/pagination/Paginator.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes } from "react";
+import { FormFieldProps } from "../form-field";
+import "./Pagination.css";
+export interface PaginatorProps extends HTMLAttributes<HTMLDivElement> {
+    boundaryCount?: number;
+    siblingCount?: number;
+    showPreviousNext?: boolean;
+    FormFieldProps?: Partial<FormFieldProps>;
+}
+export declare const Paginator: import("react").ForwardRefExoticComponent<PaginatorProps & import("react").RefAttributes<HTMLDivElement>>;