fluxo-ui 0.0.1

package/src/components/canvas-draw/canvas-draw-types.d.ts

@@ -0,0 +1,200 @@
+export type DrawTool = 'select' | 'arrow' | 'line' | 'rect' | 'circle' | 'freehand' | 'text' | 'balloon' | 'step' | 'highlighter' | 'callout' | 'dimension' | 'curvedArrow';
+export type DrawColor = 'red' | 'orange' | 'yellow' | 'green' | 'teal' | 'blue' | 'purple' | 'black' | 'white';
+export type FontFamily = 'sans-serif' | 'serif' | 'monospace' | 'cursive';
+export type ArrowheadStyle = 'single' | 'double';
+export type DrawTransition = 'none' | 'fade' | 'scale' | 'slide-up' | 'slide-down' | 'slide-left' | 'slide-right';
+export interface DrawPoint {
+    x: number;
+    y: number;
+}
+export interface BaseObject {
+    id: string;
+    strokeColor: DrawColor;
+    strokeWidth: number;
+}
+export interface ArrowObject extends BaseObject {
+    type: 'arrow';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    arrowheadStyle: ArrowheadStyle;
+}
+export interface LineObject extends BaseObject {
+    type: 'line';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+export interface RectObject extends BaseObject {
+    type: 'rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fillColor: DrawColor | 'transparent';
+    rounded: boolean;
+}
+export interface CircleObject extends BaseObject {
+    type: 'circle';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fillColor: DrawColor | 'transparent';
+}
+export interface FreehandObject extends BaseObject {
+    type: 'freehand';
+    points: DrawPoint[];
+}
+export interface TextObject extends BaseObject {
+    type: 'text';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+    fontFamily: FontFamily;
+    fontSize: number;
+    fontColor: DrawColor;
+    fillColor: DrawColor | 'transparent';
+    fontBold?: boolean;
+    fontItalic?: boolean;
+    fontUnderline?: boolean;
+}
+export interface BalloonObject extends BaseObject {
+    type: 'balloon';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+    fontFamily: FontFamily;
+    fontSize: number;
+    fontColor: DrawColor;
+    fillColor: DrawColor | 'transparent';
+    tailDirection: 'down' | 'up' | 'left' | 'right';
+    fontBold?: boolean;
+    fontItalic?: boolean;
+    fontUnderline?: boolean;
+}
+export interface StepObject extends BaseObject {
+    type: 'step';
+    x: number;
+    y: number;
+    radius: number;
+    stepNumber: number;
+    fillColor: DrawColor;
+    fontColor: DrawColor;
+}
+export interface HighlighterObject extends BaseObject {
+    type: 'highlighter';
+    points: DrawPoint[];
+}
+export interface CalloutObject extends BaseObject {
+    type: 'callout';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    stepNumber: number;
+    fillColor: DrawColor;
+    fontColor: DrawColor;
+    radius: number;
+}
+export interface DimensionObject extends BaseObject {
+    type: 'dimension';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    customLabel?: string;
+}
+export interface CurvedArrowObject extends BaseObject {
+    type: 'curvedArrow';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    cpx: number;
+    cpy: number;
+}
+export type DrawObject = ArrowObject | LineObject | RectObject | CircleObject | FreehandObject | TextObject | BalloonObject | StepObject | HighlighterObject | CalloutObject | DimensionObject | CurvedArrowObject;
+export interface DrawToolDefaults {
+    strokeColor: DrawColor;
+    fillColor: DrawColor | 'transparent';
+    strokeWidth: number;
+    fontFamily: FontFamily;
+    fontSize: number;
+    fontColor: DrawColor;
+    fontBold: boolean;
+    fontItalic: boolean;
+    fontUnderline: boolean;
+    rounded: boolean;
+    arrowheadStyle: ArrowheadStyle;
+}
+export interface DrawItem {
+    id: string;
+    object: DrawObject;
+    showAtMs: number;
+    hideAtMs: number | null;
+    transition: DrawTransition;
+    groupId: string | null;
+    xPct: number;
+    yPct: number;
+    wPct: number | null;
+    hPct: number | null;
+    rotation?: number;
+}
+export interface DrawGroup {
+    id: string;
+    label: string;
+    showAtMs: number;
+    hideAtMs: number | null;
+    transition: DrawTransition;
+}
+export type CanvasBackground = {
+    type: 'video';
+    videoRef: React.RefObject<HTMLVideoElement | null>;
+} | {
+    type: 'image';
+    src: string;
+} | {
+    type: 'color';
+    color: string;
+};
+export type ImageExportFormat = 'png' | 'jpg' | 'webp' | 'svg';
+export interface ToolConfig {
+    select?: boolean;
+    arrow?: boolean;
+    line?: boolean;
+    rect?: boolean;
+    circle?: boolean;
+    freehand?: boolean;
+    text?: boolean;
+    balloon?: boolean;
+    step?: boolean;
+    highlighter?: boolean;
+    callout?: boolean;
+    dimension?: boolean;
+    curvedArrow?: boolean;
+}
+export interface CanvasDrawFeatures {
+    tools?: ToolConfig;
+    timing?: boolean;
+    groups?: boolean;
+    transitions?: boolean;
+    undo?: boolean;
+    export?: boolean;
+    clearAll?: boolean;
+    strokeColor?: boolean;
+    strokeWidth?: boolean;
+    fillColor?: boolean;
+    fontControls?: boolean;
+    roundedCorners?: boolean;
+}
+export declare const colorMap: Record<DrawColor, string>;
+export declare const defaultToolDefaults: DrawToolDefaults;
+export declare function contrastColor(hex: string): string;
+export declare function autoFontColor(fillColor: string, explicitFontColor: DrawColor): string;

package/src/components/canvas-draw/index.d.ts

@@ -0,0 +1,10 @@
+export { default as CanvasDraw } from './CanvasDraw';
+export { default as CanvasDrawOverlay } from './CanvasDrawOverlay';
+export { default as CanvasDrawToolbar } from './CanvasDrawToolbar';
+export { default as MediaTimeline } from './MediaTimeline';
+export type { CanvasDrawProps } from './CanvasDraw';
+export type { CanvasDrawOverlayHandle } from './CanvasDrawOverlay';
+export type { CanvasDrawToolbarProps } from './CanvasDrawToolbar';
+export type { MediaTimelineProps, TimelineItem, TimelineGroup } from './MediaTimeline';
+export type { DrawTool, DrawColor, FontFamily, ArrowheadStyle, DrawTransition, DrawPoint, DrawObject, ArrowObject, LineObject, RectObject, CircleObject, FreehandObject, TextObject, BalloonObject, StepObject, DrawItem, DrawGroup, DrawToolDefaults, CanvasBackground, ImageExportFormat, ToolConfig, CanvasDrawFeatures, } from './canvas-draw-types';
+export { colorMap, defaultToolDefaults, contrastColor, autoFontColor } from './canvas-draw-types';

package/src/components/carousel/Carousel.d.ts

@@ -0,0 +1,35 @@
+import { default as React } from 'react';
+interface CarouselSlide {
+    id: string;
+    type: 'image' | 'video' | 'custom';
+    src?: string;
+    alt?: string;
+    videoId?: string;
+    thumbnail?: string;
+    content?: React.ReactNode;
+    name?: string;
+    description?: string;
+}
+type ThumbnailMode = 'inline' | 'hamburger';
+interface CarouselProps {
+    slides: CarouselSlide[];
+    activeIndex?: number;
+    onSlideChange?: (index: number) => void;
+    navigation?: 'dots' | 'arrows' | 'thumbnails' | 'none';
+    thumbnailPosition?: 'top' | 'bottom' | 'left' | 'right';
+    thumbnailMode?: ThumbnailMode;
+    showThumbnailInfo?: boolean;
+    autoplay?: boolean;
+    autoplayInterval?: number;
+    loop?: boolean;
+    showArrows?: boolean;
+    showDots?: boolean;
+    lazyLoad?: boolean;
+    swipeable?: boolean;
+    className?: string;
+    slideClassName?: string;
+    aspectRatio?: string;
+}
+declare function Carousel({ slides, activeIndex: controlledIndex, onSlideChange, navigation, thumbnailPosition, thumbnailMode, showThumbnailInfo, autoplay, autoplayInterval, loop, showArrows, showDots, lazyLoad, swipeable, className, slideClassName, aspectRatio, }: CarouselProps): import("react/jsx-runtime").JSX.Element;
+export { Carousel };
+export type { CarouselProps, CarouselSlide, ThumbnailMode };

package/src/components/carousel/CarouselSlide.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+interface CarouselSlideData {
+    id: string;
+    type: 'image' | 'video' | 'custom';
+    src?: string;
+    alt?: string;
+    videoId?: string;
+    thumbnail?: string;
+    content?: React.ReactNode;
+    name?: string;
+    description?: string;
+}
+interface CarouselSlideProps {
+    slide: CarouselSlideData;
+    isActive: boolean;
+    lazyLoad: boolean;
+    aspectRatio?: string;
+    className?: string;
+}
+declare function CarouselSlide({ slide, isActive, lazyLoad, aspectRatio, className }: CarouselSlideProps): import("react/jsx-runtime").JSX.Element;
+export default CarouselSlide;
+export type { CarouselSlideData };

package/src/components/carousel/CarouselThumbnails.d.ts

@@ -0,0 +1,10 @@
+import { CarouselSlideData } from './CarouselSlide';
+interface CarouselThumbnailsProps {
+    slides: CarouselSlideData[];
+    activeIndex: number;
+    position: 'top' | 'bottom' | 'left' | 'right';
+    onSelect: (index: number) => void;
+    showInfo?: boolean;
+}
+declare function CarouselThumbnails({ slides, activeIndex, position, onSelect, showInfo }: CarouselThumbnailsProps): import("react/jsx-runtime").JSX.Element;
+export default CarouselThumbnails;

package/src/components/carousel/index.d.ts

@@ -0,0 +1,2 @@
+export { Carousel } from './Carousel';
+export type { CarouselProps, CarouselSlide, ThumbnailMode } from './Carousel';

package/src/components/collapsible-panel/CollapsiblePanel.d.ts

@@ -0,0 +1,45 @@
+import { default as React } from 'react';
+export type CollapsiblePanelVariant = 'default' | 'bordered' | 'elevated' | 'ghost' | 'separated';
+export type CollapsiblePanelSize = 'sm' | 'md' | 'lg';
+export type CollapsiblePanelIconPosition = 'start' | 'end';
+export interface CollapsiblePanelProps {
+    children: React.ReactNode;
+    title: React.ReactNode;
+    subtitle?: React.ReactNode;
+    icon?: React.ReactNode;
+    variant?: CollapsiblePanelVariant;
+    size?: CollapsiblePanelSize;
+    iconPosition?: CollapsiblePanelIconPosition;
+    expandIcon?: React.ReactNode;
+    collapseIcon?: React.ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onToggle?: (open: boolean) => void;
+    disabled?: boolean;
+    headerActions?: React.ReactNode;
+    headerTemplate?: (props: {
+        isOpen: boolean;
+        toggle: () => void;
+    }) => React.ReactNode;
+    className?: string;
+    headerClassName?: string;
+    contentClassName?: string;
+    style?: React.CSSProperties;
+    lazy?: boolean;
+    destroyOnCollapse?: boolean;
+    id?: string;
+}
+export declare const CollapsiblePanel: React.FC<CollapsiblePanelProps>;
+export interface CollapsiblePanelGroupProps {
+    children: React.ReactNode;
+    variant?: CollapsiblePanelVariant;
+    size?: CollapsiblePanelSize;
+    iconPosition?: CollapsiblePanelIconPosition;
+    accordion?: boolean;
+    defaultOpenKeys?: string[];
+    className?: string;
+    style?: React.CSSProperties;
+    gap?: number;
+    onChange?: (openKeys: string[]) => void;
+}
+export declare const CollapsiblePanelGroup: React.FC<CollapsiblePanelGroupProps>;

package/src/components/collapsible-panel/CollapsibleTabs.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+export interface CollapsibleTabItem {
+    id: string;
+    label: string;
+    isOpen?: boolean;
+    render: (props: CollapsibleTabRenderProps) => React.ReactNode;
+}
+export interface CollapsibleTabRenderProps {
+    index: number;
+    isOpen: boolean;
+    totalOpen: number;
+    maxWidth?: string;
+}
+export type CollapsibleTabsVariant = 'default' | 'bordered' | 'elevated';
+export interface CollapsibleTabsProps {
+    tabs: CollapsibleTabItem[];
+    height?: number | string;
+    minOpenTabs?: number;
+    variant?: CollapsibleTabsVariant;
+    className?: string;
+    style?: React.CSSProperties;
+    onTabToggle?: (tabId: string, isOpen: boolean) => void;
+}
+export declare const CollapsibleTabs: React.FC<CollapsibleTabsProps>;

package/src/components/collapsible-panel/index.d.ts

@@ -0,0 +1,4 @@
+export { CollapsiblePanel, CollapsiblePanelGroup } from './CollapsiblePanel';
+export type { CollapsiblePanelGroupProps, CollapsiblePanelIconPosition, CollapsiblePanelProps, CollapsiblePanelSize, CollapsiblePanelVariant, } from './CollapsiblePanel';
+export { CollapsibleTabs } from './CollapsibleTabs';
+export type { CollapsibleTabItem, CollapsibleTabRenderProps, CollapsibleTabsProps, CollapsibleTabsVariant, } from './CollapsibleTabs';

package/src/components/confirm-popover/ConfirmPopoverManager.d.ts

@@ -0,0 +1,18 @@
+import { ConfirmPopoverOptions } from './types';
+import { ReactPortal } from 'react';
+export declare const showConfirmPopover: (options: ConfirmPopoverOptions) => number;
+export declare const closeConfirmPopover: (id?: number) => void;
+export declare class Confirm {
+    static show(options: ConfirmPopoverOptions): number;
+    static close(id?: number): void;
+    static yesNo(target: HTMLElement, message: ConfirmPopoverOptions['message'], onConfirm: () => void, onCancel?: () => void, options?: Partial<Omit<ConfirmPopoverOptions, 'target' | 'message' | 'actions'>>): number;
+    static confirm(target: HTMLElement, message: ConfirmPopoverOptions['message'], onConfirm: () => void, onCancel?: () => void, options?: Partial<Omit<ConfirmPopoverOptions, 'target' | 'message' | 'actions'>> & {
+        confirmText?: string;
+        cancelText?: string;
+    }): number;
+    static ok(target: HTMLElement, message: ConfirmPopoverOptions['message'], onOk?: () => void, options?: Partial<Omit<ConfirmPopoverOptions, 'target' | 'message' | 'actions'>> & {
+        okText?: string;
+    }): number;
+}
+declare function ConfirmPopoverManager(): ReactPortal | null;
+export default ConfirmPopoverManager;

package/src/components/confirm-popover/ConfirmPopoverPanel.d.ts

@@ -0,0 +1,7 @@
+import { ConfirmPopoverData } from './types';
+interface ConfirmPopoverPanelProps {
+    data: ConfirmPopoverData;
+    onDismiss: (id: number) => void;
+}
+declare const ConfirmPopoverPanel: ({ data, onDismiss }: ConfirmPopoverPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default ConfirmPopoverPanel;

package/src/components/confirm-popover/index.d.ts

@@ -0,0 +1,3 @@
+export { Confirm, closeConfirmPopover, showConfirmPopover } from './ConfirmPopoverManager';
+export { default as ConfirmPopoverManager } from './ConfirmPopoverManager';
+export type { ConfirmPopoverAction, ConfirmPopoverData, ConfirmPopoverOptions, ConfirmPopoverPlacement } from './types';

package/src/components/confirm-popover/types.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+export type ConfirmPopoverPlacement = 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight' | 'left' | 'right' | 'auto';
+export interface ConfirmPopoverAction {
+    label: string;
+    onClick: () => void;
+    variant?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'info';
+    layout?: 'default' | 'outlined' | 'plain';
+}
+export interface ConfirmPopoverOptions {
+    target: HTMLElement;
+    title?: string;
+    message: string | React.ReactNode;
+    icon?: React.ComponentType<React.SVGProps<SVGSVGElement>> | React.ReactElement;
+    placement?: ConfirmPopoverPlacement;
+    actions: ConfirmPopoverAction[];
+    onClose?: () => void;
+}
+export interface ConfirmPopoverData extends ConfirmPopoverOptions {
+    id: number;
+}

package/src/components/confirm-popover/useConfirmPopoverPosition.d.ts

@@ -0,0 +1,10 @@
+import { ConfirmPopoverPlacement } from './types';
+export interface PopoverPosition {
+    top: number;
+    left: number;
+    resolvedPlacement: ConfirmPopoverPlacement;
+}
+export declare const useConfirmPopoverPosition: () => {
+    position: PopoverPosition;
+    calculatePosition: (triggerElement: HTMLElement, popoverElement: HTMLElement, placement: ConfirmPopoverPlacement) => void;
+};

package/src/components/context/ThemeContext.d.ts

@@ -0,0 +1,24 @@
+import { default as React, ReactNode } from 'react';
+import { Size, Theme, ThemeConfig } from '../../types';
+interface ThemeContextValue {
+    size?: Size;
+    theme?: Theme;
+    borderRadius?: string;
+    borderColor?: string;
+    borderWidth?: string;
+    backgroundColor?: string;
+    fontSize?: string;
+    fontColor?: string;
+    placeholderStyles?: {
+        fontSize?: string;
+        color?: string;
+        fontStyle?: string;
+    };
+    getThemeConfig: () => ThemeConfig;
+}
+interface ThemeProviderProps extends Partial<ThemeContextValue> {
+    children: ReactNode;
+}
+export declare const ThemeProvider: React.FC<ThemeProviderProps>;
+export declare const useTheme: () => ThemeContextValue;
+export {};

package/src/components/context-menu/ContextMenuManager.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export declare const ContextMenuManager: React.FC;
+export default ContextMenuManager;

package/src/components/context-menu/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ContextMenuManager } from './ContextMenuManager';
+export { showContextMenu } from './utils';

package/src/components/context-menu/types.d.ts

@@ -0,0 +1,28 @@
+import { PlacementCorners } from '../../types';
+export interface MenuItemBase {
+    id?: any;
+    label?: string;
+    icon?: React.ReactNode;
+    command?: (id?: any) => void;
+    seperator?: boolean;
+    disabled?: boolean;
+}
+export interface MenuItem extends MenuItemBase {
+    items?: MenuItemBase[];
+}
+export type Handler = ((event: React.MouseEvent, menus: MenuItem[], options?: ContextMenuOptions) => void) | null;
+export interface ContextMenuOptions {
+    placement?: PlacementCorners;
+}
+export type ContextMenuState = {
+    visible: boolean;
+    menus: MenuItem[];
+    eventX: number;
+    eventY: number;
+    placement: PlacementCorners;
+    style: {
+        left: number;
+        top: number;
+        opacity: number;
+    };
+};

package/src/components/context-menu/utils.d.ts

@@ -0,0 +1,3 @@
+import { ContextMenuOptions, Handler, MenuItem } from './types';
+export declare function setContextMenuHandler(func: Handler): void;
+export declare function showContextMenu(event: React.MouseEvent, menus: MenuItem[], options?: ContextMenuOptions): void;

package/src/components/date-range/Calendar.d.ts

@@ -0,0 +1,15 @@
+import { SelectionMode } from './types';
+interface CalendarProps {
+    currentMonth: Date;
+    selectedFrom: Date;
+    selectedTo: Date;
+    activeField: 'from' | 'to';
+    onSelectDate: (date: Date) => void;
+    onSelectWeek?: (weekStart: Date, weekEnd: Date) => void;
+    minDate?: Date;
+    maxDate?: Date;
+    firstDayOfWeek?: number;
+    selectionMode?: SelectionMode;
+}
+declare function Calendar({ currentMonth, selectedFrom, selectedTo, activeField, onSelectDate, onSelectWeek, minDate, maxDate, firstDayOfWeek, selectionMode, }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+export default Calendar;

package/src/components/date-range/CustomDatePicker.d.ts

@@ -0,0 +1,2 @@
+declare function CustomDatePicker(): import("react/jsx-runtime").JSX.Element;
+export default CustomDatePicker;

package/src/components/date-range/DatePopover.d.ts

@@ -0,0 +1,5 @@
+import { ReactPortal } from 'react';
+declare function DatePopover({ controlRef }: {
+    controlRef: React.RefObject<HTMLButtonElement>;
+}): ReactPortal;
+export default DatePopover;

package/src/components/date-range/DateRangePicker.d.ts

@@ -0,0 +1,3 @@
+import { DateRangePickerProps } from './types';
+declare function DateRangePicker(props: DateRangePickerProps): import("react/jsx-runtime").JSX.Element;
+export default DateRangePicker;

package/src/components/date-range/Footer.d.ts

@@ -0,0 +1,2 @@
+declare function Footer({ onDone, onSelectToday }: any): import("react/jsx-runtime").JSX.Element;
+export default Footer;

package/src/components/date-range/MonthPicker.d.ts

@@ -0,0 +1,10 @@
+type MonthPickerProps = {
+    onBackClick: () => void;
+    onSelect: (index: number) => void;
+    year: number;
+    selectedFrom: Date;
+    selectedTo: Date;
+    selectionMode: string;
+};
+declare function MonthPicker({ onBackClick, onSelect, year, selectedFrom, selectedTo, selectionMode }: MonthPickerProps): import("react/jsx-runtime").JSX.Element;
+export default MonthPicker;

package/src/components/date-range/QuickRangeDropdown.d.ts

@@ -0,0 +1,2 @@
+declare function QuickRangeDropdown(): import("react/jsx-runtime").JSX.Element | undefined;
+export default QuickRangeDropdown;

package/src/components/date-range/QuickRangeList.d.ts

@@ -0,0 +1,2 @@
+declare function QuickRangeList(): import("react/jsx-runtime").JSX.Element;
+export default QuickRangeList;

package/src/components/date-range/YearPicker.d.ts

@@ -0,0 +1,11 @@
+type YearPickerProps = {
+    onCancel: () => void;
+    minDate?: Date;
+    maxDate?: Date;
+    onSelect: (year: number) => void;
+    selectedFrom: Date;
+    selectedTo: Date;
+    selectionMode: string;
+};
+declare function YearPicker({ onCancel, minDate, maxDate, onSelect, selectedFrom, selectedTo, selectionMode }: YearPickerProps): import("react/jsx-runtime").JSX.Element;
+export default YearPicker;

package/src/components/date-range/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './DateRangePicker';
+export type { DateRangeValue, DateSelectedCallbackArg, RangeOption, SelectionMode } from './types';

package/src/components/date-range/types.d.ts

@@ -0,0 +1,65 @@
+import { Context, Provider } from 'react';
+export type DateRangeValue = [Date, Date];
+export type SelectionMode = 'day' | 'week' | 'month' | 'year';
+export interface RangeOption {
+    value: string | number;
+    label: string;
+    range: [Date, Date];
+}
+export type PopoverPosition = 'bottomStart' | 'bottomEnd' | 'topStart' | 'topEnd' | 'auto';
+export declare const defaultCustomText = "Custom";
+export type DateSelectedCallbackArg = {
+    name?: string;
+    range?: string | number;
+    value: DateRangeValue;
+    args: any;
+};
+interface PropsBase {
+    value?: DateRangeValue | (string | number) | Date;
+    ranges?: RangeOption[];
+    minDate?: Date;
+    maxDate?: Date;
+    onChange: (selection: DateSelectedCallbackArg) => void;
+    onClose?: () => void;
+    customLabel?: string;
+    showTodayButton?: boolean;
+    dateFormat?: string;
+    separator?: string;
+    args?: any;
+    locale?: any;
+    position?: PopoverPosition;
+    selectionMode?: SelectionMode;
+    firstDayOfWeek?: number;
+    range?: boolean;
+    classNames?: {
+        container?: string;
+        control?: string;
+        popover?: string;
+    };
+}
+export interface DateRangePickerProps extends PropsBase {
+    id?: string;
+    name?: string;
+    className?: string;
+    styles?: React.CSSProperties;
+    disabled?: boolean;
+    placeholder?: string;
+    iconOnly?: boolean;
+}
+export interface ContextType {
+    customRange: DateRangeValue;
+    activeView: 'quick' | 'custom';
+    selectedRange: string | number | 'custom';
+    closePicker: () => void;
+    setCustomRange: React.Dispatch<React.SetStateAction<DateRangeValue>>;
+    setActiveView: React.Dispatch<React.SetStateAction<'quick' | 'custom'>>;
+    setCustomDate: (range: DateRangeValue) => void;
+    setQuickDate: (option: RangeOption | {
+        custom: true;
+    }) => void;
+}
+export declare const DatePickerPropsContext: Context<PropsBase>;
+export declare const PropsProvider: Provider<PropsBase>;
+export declare const DatePickerStateContext: Context<ContextType>;
+export declare const StateProvider: Provider<ContextType>;
+export {};

package/src/components/date-range/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const defaultDateFormat = "MMM dd, yyyy";
+export declare const formatDisplayDate: (date: Date, dateFormat?: string) => string;
+export declare const generateCalendarDays: (baseDate: Date, firstDayOfWeek?: number) => Date[][];
+export declare const getYearOptions: (minDate?: Date, maxDate?: Date) => number[];
+export declare const isDateDisabled: (date: Date, minDate?: Date, maxDate?: Date) => boolean;
+export declare const getDayHeaders: (firstDayOfWeek?: number) => string[];