@once-ui-system/core 1.6.4 → 1.7.1

package/dist/src/components/DatePicker.d.ts

@@ -0,0 +1,32 @@
+import React from "react";
+import { Flex } from ".";
+export interface DatePickerProps extends Omit<React.ComponentProps<typeof Flex>, "onChange"> {
+    value?: Date;
+    onChange?: (date: Date) => void;
+    minDate?: Date;
+    maxDate?: Date;
+    previousMonth?: boolean;
+    nextMonth?: boolean;
+    timePicker?: boolean;
+    defaultDate?: Date;
+    defaultTime?: {
+        hours: number;
+        minutes: number;
+    };
+    size?: "s" | "m" | "l";
+    isNested?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    currentMonth?: number;
+    currentYear?: number;
+    onMonthChange?: (increment: number) => void;
+    range?: {
+        startDate?: Date;
+        endDate?: Date;
+    };
+    onHover?: (date: Date | null) => void;
+    autoFocus?: boolean;
+    isOpen?: boolean;
+}
+declare const DatePicker: React.ForwardRefExoticComponent<Omit<DatePickerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { DatePicker };

package/dist/src/components/DateRangeInput.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { Input, DateRange } from ".";
+interface DateRangeInputProps extends Omit<React.ComponentProps<typeof Input>, "onChange" | "value" | "label"> {
+    id: string;
+    startLabel: string;
+    endLabel: string;
+    value?: DateRange;
+    onChange?: (range: DateRange) => void;
+    minHeight?: number;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const DateRangeInput: React.FC<DateRangeInputProps>;
+export {};

package/dist/src/components/DateRangePicker.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import { Flex } from ".";
+export interface DateRange {
+    startDate: Date | undefined;
+    endDate: Date | undefined;
+}
+export interface DateRangePickerProps extends Omit<React.ComponentProps<typeof Flex>, "onChange"> {
+    value?: DateRange;
+    onChange?: (range: DateRange) => void;
+    minDate?: Date;
+    maxDate?: Date;
+    dual?: boolean;
+    size?: "s" | "m" | "l";
+}
+declare const DateRangePicker: React.FC<DateRangePickerProps>;
+export { DateRangePicker };

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

@@ -0,0 +1,19 @@
+import React, { ReactNode } from "react";
+import { Flex } from ".";
+interface DialogProps extends Omit<React.ComponentProps<typeof Flex>, "title"> {
+    isOpen: boolean;
+    onClose: () => void;
+    title: ReactNode | string;
+    description?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    base?: boolean;
+    stack?: boolean;
+    onHeightChange?: (height: number) => void;
+    minHeight?: number;
+}
+export declare const DialogProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+declare const Dialog: React.FC<DialogProps>;
+export { Dialog };

package/dist/src/components/Dropdown.d.ts

@@ -0,0 +1,12 @@
+import React, { ReactNode } from "react";
+import { Row } from ".";
+interface DropdownProps extends Omit<React.ComponentProps<typeof Row>, "onSelect"> {
+    selectedOption?: string;
+    children?: ReactNode;
+    onEscape?: () => void;
+    onSelect?: (event: string) => void;
+    disabled?: boolean;
+}
+declare const Dropdown: React.ForwardRefExoticComponent<Omit<DropdownProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Dropdown };
+export type { DropdownProps };

package/dist/src/components/DropdownWrapper.d.ts

@@ -0,0 +1,28 @@
+import React, { ReactNode } from "react";
+import { Placement } from "@floating-ui/react-dom";
+import { NavigationLayout } from "../hooks/useArrowNavigation";
+export interface DropdownWrapperProps {
+    fillWidth?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    placement?: Placement;
+    trigger: ReactNode;
+    dropdown: ReactNode;
+    selectedOption?: string;
+    style?: React.CSSProperties;
+    className?: string;
+    onSelect?: (value: string) => void;
+    closeAfterClick?: boolean;
+    handleArrowNavigation?: boolean;
+    isOpen?: boolean;
+    onOpenChange?: (isOpen: boolean) => void;
+    isNested?: boolean;
+    navigationLayout?: NavigationLayout;
+    columns?: number | string;
+    optionsCount?: number;
+    dropdownId?: string;
+    disableTriggerClick?: boolean;
+}
+declare const DropdownWrapper: React.ForwardRefExoticComponent<DropdownWrapperProps & React.RefAttributes<HTMLDivElement>>;
+export { DropdownWrapper };

package/dist/src/components/ElementType.d.ts

@@ -0,0 +1,13 @@
+import React, { ReactNode } from "react";
+interface ElementTypeProps {
+    href?: string;
+    onClick?: () => void;
+    onLinkClick?: () => void;
+    children: ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    type?: "button" | "submit" | "reset";
+    [key: string]: any;
+}
+declare const ElementType: React.ForwardRefExoticComponent<Omit<ElementTypeProps, "ref"> & React.RefAttributes<HTMLElement>>;
+export { ElementType };

package/dist/src/components/EmojiPicker.d.ts

@@ -0,0 +1,15 @@
+import { Flex } from ".";
+import { StyleProps, gridSize } from "../";
+export interface EmojiPickerProps extends Omit<React.ComponentProps<typeof Flex>, "onSelect"> {
+    onSelect: (emoji: string) => void;
+    onClose?: () => void;
+    className?: string;
+    background?: StyleProps["background"];
+    columns?: gridSize;
+    style?: React.CSSProperties;
+}
+declare const EmojiPicker: {
+    ({ onSelect, onClose, className, background, columns, style, ...flex }: EmojiPickerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { EmojiPicker };

package/dist/src/components/EmojiPickerDropdown.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { DropdownWrapper } from ".";
+import { StyleProps, gridSize } from "..";
+export interface EmojiPickerDropdownProps extends Omit<React.ComponentProps<typeof DropdownWrapper>, "dropdown"> {
+    onSelect: (emoji: string) => void;
+    background?: StyleProps["background"];
+    columns?: gridSize;
+}
+declare const EmojiPickerDropdown: React.FC<EmojiPickerDropdownProps>;
+export { EmojiPickerDropdown };

package/dist/src/components/Fade.d.ts

@@ -0,0 +1,18 @@
+import React, { ReactNode } from "react";
+import { Flex } from ".";
+import { ColorScheme, ColorWeight, SpacingToken } from "../types";
+export type BaseColor = `${ColorScheme}-${ColorWeight}` | `${ColorScheme}-alpha-${ColorWeight}` | "surface" | "overlay" | "page" | "transparent";
+interface FadeProps extends React.ComponentProps<typeof Flex> {
+    className?: string;
+    to?: "bottom" | "top" | "left" | "right";
+    base?: BaseColor;
+    blur?: number;
+    pattern?: {
+        display?: boolean;
+        size?: SpacingToken;
+    };
+    style?: React.CSSProperties;
+    children?: ReactNode;
+}
+declare const Fade: React.ForwardRefExoticComponent<Omit<FadeProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Fade };

package/dist/src/components/Feedback.d.ts

@@ -0,0 +1,15 @@
+import React, { ReactNode } from "react";
+import { Flex } from ".";
+interface FeedbackProps extends Omit<React.ComponentProps<typeof Flex>, "title"> {
+    variant?: "info" | "danger" | "warning" | "success";
+    icon?: boolean;
+    title?: string;
+    description?: string;
+    showCloseButton?: boolean;
+    onClose?: () => void;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: ReactNode;
+}
+declare const Feedback: React.ForwardRefExoticComponent<Omit<FeedbackProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Feedback };

package/dist/src/components/Flex.d.ts

@@ -0,0 +1,10 @@
+import { FlexProps, StyleProps, SpacingProps, SizeProps, CommonProps, DisplayProps, FlexBreakpointProps } from "../interfaces";
+interface SmartFlexProps extends FlexProps, StyleProps, SpacingProps, SizeProps, CommonProps, DisplayProps {
+    xl?: FlexBreakpointProps;
+    l?: FlexBreakpointProps;
+    m?: FlexBreakpointProps;
+    s?: FlexBreakpointProps;
+    xs?: FlexBreakpointProps;
+}
+declare const Flex: import("react").ForwardRefExoticComponent<SmartFlexProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Flex };

package/dist/src/components/FlipFx.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import { Flex } from ".";
+export interface FlipFxProps extends React.ComponentProps<typeof Flex> {
+    flipDirection?: "horizontal" | "vertical";
+    timing?: number;
+    flipped?: boolean;
+    onFlip?: (flipped: boolean) => void;
+    disableClickFlip?: boolean;
+    autoFlipInterval?: number;
+    front: React.ReactNode;
+    back: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const FlipFx: React.ForwardRefExoticComponent<Omit<FlipFxProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { FlipFx };

package/dist/src/components/GlitchFx.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { Flex } from ".";
+interface GlitchFxProps extends React.ComponentProps<typeof Flex> {
+    children: React.ReactNode;
+    speed?: "slow" | "medium" | "fast";
+    interval?: number;
+    trigger?: "instant" | "hover" | "custom";
+    continuous?: boolean;
+}
+declare const GlitchFx: React.ForwardRefExoticComponent<Omit<GlitchFxProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { GlitchFx };

package/dist/src/components/Grid.d.ts

@@ -0,0 +1,10 @@
+import { GridProps, StyleProps, SpacingProps, SizeProps, CommonProps, DisplayProps, GridBreakpointProps } from "../interfaces";
+interface SmartGridProps extends GridProps, StyleProps, SpacingProps, SizeProps, CommonProps, DisplayProps {
+    xl?: GridBreakpointProps;
+    l?: GridBreakpointProps;
+    m?: GridBreakpointProps;
+    s?: GridBreakpointProps;
+    xs?: GridBreakpointProps;
+}
+declare const Grid: import("react").ForwardRefExoticComponent<SmartGridProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Grid };

package/dist/src/components/HoloFx.d.ts

@@ -0,0 +1,31 @@
+import React from "react";
+import { Flex } from ".";
+import { CSSProperties } from "react";
+interface MaskOptions {
+    maskPosition?: string;
+}
+interface HoloFxProps extends React.ComponentProps<typeof Flex> {
+    children: React.ReactNode;
+    reducedMotion?: boolean | "auto";
+    shine?: {
+        opacity?: number;
+        filter?: string;
+        blending?: CSSProperties["mixBlendMode"];
+        mask?: MaskOptions;
+    };
+    burn?: {
+        opacity?: number;
+        filter?: string;
+        blending?: CSSProperties["mixBlendMode"];
+        mask?: MaskOptions;
+    };
+    texture?: {
+        opacity?: number;
+        filter?: string;
+        blending?: CSSProperties["mixBlendMode"];
+        image?: string;
+        mask?: MaskOptions;
+    };
+}
+declare const HoloFx: React.FC<HoloFxProps>;
+export { HoloFx };

package/dist/src/components/Hover.d.ts

@@ -0,0 +1,13 @@
+import React, { ReactNode } from "react";
+import { Flex } from ".";
+export interface HoverProps extends React.ComponentProps<typeof Flex> {
+    trigger: ReactNode;
+    overlay: ReactNode;
+    interactive?: boolean;
+    delay?: number;
+    hideDelay?: number;
+    disabled?: boolean;
+    touch?: "disable" | "enable" | "display";
+}
+declare const Hover: React.ForwardRefExoticComponent<Omit<HoverProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Hover };

package/dist/src/components/HoverCard.d.ts

@@ -0,0 +1,4 @@
+import { AnimationProps } from ".";
+type HoverCardProps = Omit<AnimationProps, 'triggerType' | 'portal'>;
+declare const HoverCard: import("react").ForwardRefExoticComponent<Omit<HoverCardProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export { HoverCard };

package/dist/src/components/Icon.d.ts

@@ -0,0 +1,17 @@
+import React, { ReactNode } from "react";
+import { IconName } from "../icons";
+import { ColorScheme, ColorWeight } from "../types";
+import { Flex } from ".";
+interface IconProps extends React.ComponentProps<typeof Flex> {
+    name: IconName;
+    onBackground?: `${ColorScheme}-${ColorWeight}`;
+    onSolid?: `${ColorScheme}-${ColorWeight}`;
+    size?: "xs" | "s" | "m" | "l" | "xl";
+    decorative?: boolean;
+    tooltip?: ReactNode;
+    tooltipPosition?: "top" | "bottom" | "left" | "right";
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const Icon: React.ForwardRefExoticComponent<Omit<IconProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Icon };

package/dist/src/components/IconButton.d.ts

@@ -0,0 +1,22 @@
+import React, { ReactNode } from "react";
+import { IconName } from "../icons";
+interface CommonProps {
+    icon?: IconName;
+    id?: string;
+    size?: "xs" | "s" | "m" | "l" | "xl";
+    radius?: "none" | "top" | "right" | "bottom" | "left" | "top-left" | "top-right" | "bottom-right" | "bottom-left";
+    rounded?: boolean;
+    tooltip?: ReactNode;
+    tooltipPosition?: "top" | "bottom" | "left" | "right";
+    variant?: "primary" | "secondary" | "tertiary" | "danger" | "ghost";
+    loading?: boolean;
+    disabled?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    href?: string;
+    children?: ReactNode;
+}
+export type IconButtonProps = CommonProps & React.ButtonHTMLAttributes<HTMLButtonElement>;
+type AnchorProps = CommonProps & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+declare const IconButton: React.ForwardRefExoticComponent<(IconButtonProps | AnchorProps) & React.RefAttributes<HTMLButtonElement>>;
+export { IconButton };

package/dist/src/components/InfiniteScroll.d.ts

@@ -0,0 +1,15 @@
+import React, { ReactNode } from "react";
+import { Row } from ".";
+export interface InfiniteScrollProps<T> extends React.ComponentProps<typeof Row> {
+    items: T[];
+    renderItem: (item: T, index: number) => ReactNode;
+    loadMore: () => Promise<boolean>;
+    loading?: boolean;
+    threshold?: number;
+    className?: string;
+}
+declare function InfiniteScroll<T>({ items, renderItem, loadMore, loading, threshold, ...flex }: InfiniteScrollProps<T>): import("react/jsx-runtime").JSX.Element;
+declare namespace InfiniteScroll {
+    var displayName: string;
+}
+export { InfiniteScroll };

package/dist/src/components/InlineCode.d.ts

@@ -0,0 +1,9 @@
+import React, { ReactNode } from "react";
+import { Flex } from ".";
+interface InlineCodeProps extends React.ComponentProps<typeof Flex> {
+    children: ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const InlineCode: React.ForwardRefExoticComponent<Omit<InlineCodeProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { InlineCode };

package/dist/src/components/Input.d.ts

@@ -0,0 +1,23 @@
+import React, { InputHTMLAttributes, ReactNode } from "react";
+interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
+    id: string;
+    label?: string;
+    placeholder?: string;
+    height?: "xs" | "s" | "m" | "l" | "xl";
+    error?: boolean;
+    errorMessage?: ReactNode;
+    description?: ReactNode;
+    radius?: "none" | "top" | "right" | "bottom" | "left" | "top-left" | "top-right" | "bottom-right" | "bottom-left";
+    className?: string;
+    style?: React.CSSProperties;
+    hasPrefix?: ReactNode;
+    hasSuffix?: ReactNode;
+    variant?: "default" | "ghost";
+    characterCount?: boolean;
+    cursor?: undefined | "interactive";
+    validate?: (value: ReactNode) => ReactNode | null;
+    loading?: boolean;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input };
+export type { InputProps };

package/dist/src/components/InteractiveDetails.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { IconButtonProps } from ".";
+interface InteractiveDetailsProps {
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    iconButtonProps?: IconButtonProps;
+    onClick: () => void;
+    className?: string;
+    id?: string;
+}
+declare const InteractiveDetails: React.FC<InteractiveDetailsProps>;
+export { InteractiveDetails };
+export type { InteractiveDetailsProps };

package/dist/src/components/Kbd.d.ts

@@ -0,0 +1,11 @@
+import React, { ReactNode } from "react";
+import { Flex } from ".";
+interface KbdProps extends React.ComponentProps<typeof Flex> {
+    label?: string;
+    children?: ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const Kbd: React.ForwardRefExoticComponent<Omit<KbdProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Kbd };
+export type { KbdProps };

package/dist/src/components/Line.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { Flex } from ".";
+interface LineProps extends React.ComponentProps<typeof Flex> {
+    vert?: boolean;
+    style?: React.CSSProperties;
+}
+declare const Line: React.ForwardRefExoticComponent<Omit<LineProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Line };

package/dist/src/components/List.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { Column } from ".";
+interface ListProps extends React.ComponentProps<typeof Column> {
+    as?: "ul" | "ol";
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const List: React.ForwardRefExoticComponent<Omit<ListProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { List };

package/dist/src/components/ListItem.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { Text } from ".";
+interface ListItemProps extends React.ComponentProps<typeof Text> {
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare const ListItem: React.ForwardRefExoticComponent<Omit<ListItemProps, "ref"> & React.RefAttributes<HTMLLIElement>>;
+export { ListItem };

package/dist/src/components/Logo.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+interface LogoProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    className?: string;
+    size?: "xs" | "s" | "m" | "l" | "xl";
+    style?: React.CSSProperties;
+    icon?: string;
+    wordmark?: string;
+    href?: string;
+    dark?: boolean;
+    light?: boolean;
+    brand?: {
+        copy?: boolean;
+        url?: string;
+    };
+}
+declare const Logo: React.FC<LogoProps>;
+export { Logo };

package/dist/src/components/LogoCloud.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { Grid, Logo } from ".";
+import type { ComponentProps } from "react";
+type LogoProps = ComponentProps<typeof Logo>;
+interface LogoCloudProps extends React.ComponentProps<typeof Grid> {
+    logos: LogoProps[];
+    className?: string;
+    style?: React.CSSProperties;
+    limit?: number;
+    rotationInterval?: number;
+}
+declare const LogoCloud: React.ForwardRefExoticComponent<Omit<LogoCloudProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { LogoCloud };

package/dist/src/components/Mask.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { Flex } from ".";
+export interface MaskProps extends Omit<React.ComponentProps<typeof Flex>, "radius" | "cursor"> {
+    cursor?: boolean;
+    x?: number;
+    y?: number;
+    radius?: number;
+    reducedMotion?: boolean | "auto";
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+}
+declare const Mask: React.ForwardRefExoticComponent<Omit<MaskProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Mask };

package/dist/src/components/MasonryGrid.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+import type { CSSProperties, ReactNode } from "react";
+import { SpacingToken } from "../types";
+import { Flex } from "./Flex";
+interface MasonryBreakpointProps {
+    columns?: number;
+    hide?: boolean;
+}
+interface MasonryGridProps extends Omit<React.ComponentProps<typeof Flex>, 'l' | 'm' | 's' | 'xs'> {
+    children: ReactNode;
+    gap?: SpacingToken | "-1" | undefined;
+    columns?: number;
+    style?: CSSProperties;
+    className?: string;
+    l?: MasonryBreakpointProps;
+    m?: MasonryBreakpointProps;
+    s?: MasonryBreakpointProps;
+    xs?: MasonryBreakpointProps;
+}
+declare const MasonryGrid: React.ForwardRefExoticComponent<Omit<MasonryGridProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { MasonryGrid };

package/dist/src/components/MatrixFx.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+import { Flex } from ".";
+interface BulgeConfig {
+    type?: "ripple" | "wave";
+    duration?: number;
+    intensity?: number;
+    repeat?: boolean;
+    delay?: number;
+}
+interface MatrixFxProps extends React.ComponentProps<typeof Flex> {
+    speed?: number;
+    colors?: string[];
+    size?: number;
+    spacing?: number;
+    revealFrom?: "center" | "top" | "bottom" | "left" | "right";
+    trigger?: "hover" | "instant" | "mount" | "click" | "manual";
+    active?: boolean;
+    flicker?: boolean;
+    bulge?: BulgeConfig;
+    fps?: number;
+    reducedMotion?: boolean | "auto";
+    children?: React.ReactNode;
+}
+declare const MatrixFx: React.ForwardRefExoticComponent<Omit<MatrixFxProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { MatrixFx };
+export type { BulgeConfig };

package/dist/src/components/Media.d.ts

@@ -0,0 +1,25 @@
+import React, { CSSProperties, ReactNode } from "react";
+import { Flex } from ".";
+export interface MediaProps extends React.ComponentProps<typeof Flex> {
+    aspectRatio?: string;
+    height?: number;
+    alt?: string;
+    loading?: boolean;
+    objectFit?: CSSProperties["objectFit"];
+    enlarge?: boolean;
+    src: string;
+    unoptimized?: boolean;
+    sizes?: string | number;
+    priority?: boolean;
+    caption?: ReactNode;
+    fill?: boolean;
+    fillWidth?: boolean;
+    loop?: boolean;
+    autoplay?: boolean;
+    sound?: boolean;
+    controls?: boolean;
+    style?: CSSProperties;
+    className?: string;
+}
+declare const Media: React.FC<MediaProps>;
+export { Media };

package/dist/src/components/Modal.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export interface ModalProps {
+    children: React.ReactNode;
+    backdrop?: React.ReactNode;
+    title: React.ReactNode;
+    isOpen: boolean;
+    onClose: () => void;
+}
+declare const Modal: React.FC<ModalProps>;
+export { Modal };

package/dist/src/components/NavIcon.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { Flex } from ".";
+interface NavIconProps extends React.ComponentProps<typeof Flex> {
+    className?: string;
+    style?: React.CSSProperties;
+    onClick?: () => void;
+    isActive: boolean;
+}
+declare const NavIcon: React.ForwardRefExoticComponent<Omit<Partial<NavIconProps>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { NavIcon };

package/dist/src/components/NumberInput.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { Input } from ".";
+interface NumberInputProps extends Omit<React.ComponentProps<typeof Input>, "type" | "value" | "onChange"> {
+    value?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    padStart?: number;
+}
+declare const NumberInput: React.ForwardRefExoticComponent<Omit<NumberInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { NumberInput };

package/dist/src/components/OTPInput.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+interface OTPInputProps extends React.HTMLAttributes<HTMLDivElement> {
+    length?: number;
+    onComplete?: (code: string) => void;
+    error?: boolean;
+    errorMessage?: React.ReactNode;
+    disabled?: boolean;
+    autoFocus?: boolean;
+}
+declare const OTPInput: React.ForwardRefExoticComponent<OTPInputProps & React.RefAttributes<HTMLDivElement>>;
+export { OTPInput };
+export type { OTPInputProps };