bianic-ui 0.4.16 → 0.4.17

package/dist/index.d.ts

@@ -1,160 +1,602 @@
-import React, { ComponentPropsWithoutRef } from 'react';
-
-interface ButtonProps extends ComponentPropsWithoutRef<"button"> {
-    label?: any;
-    variant?: string;
-    size?: string;
-    radius?: string;
-    left?: any;
-    right?: any;
-    shadow?: boolean;
-}
-declare const Button: ({ label, variant, size, radius, left, shadow, right, ...rest }: ButtonProps) => React.JSX.Element;
-
-declare const Dump: () => React.JSX.Element;
-
-interface TextInputProps extends ComponentPropsWithoutRef<"input"> {
-    variant: string;
-    state: string;
-    label: string;
-    important: boolean;
-    descText: string;
-    errText: string;
-    placeholder: string;
-    icon: string;
-    inputSize: string;
-}
-declare const TextInput: ({ variant, label, important, descText, errText, icon, inputSize, ...rest }: TextInputProps) => React.JSX.Element;
-
-interface RadioProps extends ComponentPropsWithoutRef<"input"> {
-    data: any;
-    label: string;
-    InputSize: string;
-}
-declare const Radio: ({ label, data, InputSize, ...rest }: RadioProps) => React.JSX.Element;
-
-interface TextAreaProps extends ComponentPropsWithoutRef<"textarea"> {
-    state: string;
-    label: string;
-    important: boolean;
-    descText: string;
-    errText: string;
-}
-declare const TextArea: ({ label, important, descText, errText, ...rest }: TextAreaProps) => React.JSX.Element;
-
-interface CheckboxProps$1 extends ComponentPropsWithoutRef<"input"> {
-    label: string;
-    inputSize: string;
-}
-declare const Checkbox: ({ label, inputSize, ...rest }: CheckboxProps$1) => React.JSX.Element;
-
-interface SelectInputProps extends ComponentPropsWithoutRef<"input"> {
-    label: string;
-    descText: string;
-    isOpen: boolean;
-    setIsOpen: any;
+import React, { ComponentPropsWithoutRef, ChangeEvent, ComponentPropsWithRef } from 'react';
+
+interface AccordionsProps extends ComponentPropsWithoutRef<'div'> {
+    title: string;
+    content: string;
+}
+declare function Accordions({ title, content }: AccordionsProps): React.JSX.Element;
+
+interface AlertProps extends ComponentPropsWithoutRef<'div'> {
+    title?: string;
+    caption: string;
+    variant: 'base' | 'info' | 'success' | 'warning' | 'danger';
+    visible: boolean;
+    setVisible: (arg0: boolean) => void;
+    visibleIcon: boolean;
+    visibleClose: boolean;
+}
+declare function Alert({ title, caption, variant, visible, setVisible, visibleIcon, visibleClose, }: AlertProps): false | React.JSX.Element;
+declare namespace Alert {
+    var defaultProps: {
+        title: null;
+    };
+}
+
+interface AvatarProps extends ComponentPropsWithoutRef<'div'> {
+    size: 'small' | 'medium' | 'large' | 'x-large' | 'xx-large';
+    variant: 'image' | 'picture' | 'initial';
+    name?: string;
+}
+declare function Avatar({ size, variant, name }: AvatarProps): React.JSX.Element | null;
+declare namespace Avatar {
+    var defaultProps: {
+        name: string;
+    };
+}
+
+interface BadgeProps extends ComponentPropsWithoutRef<'span'> {
+    type: 'standart' | 'float';
+    color?: string | undefined;
+    isInverted?: boolean;
+}
+declare function Badge({ type, children, color, isInverted, className, }: BadgeProps): React.JSX.Element;
+declare namespace Badge {
+    var defaultProps: {
+        isInverted: boolean;
+        color: undefined;
+    };
+}
+
+interface BannerProps {
+    children: React.ReactNode;
+    isCloseable?: boolean;
+    isShow: boolean;
+    setIsShow: (arg0: boolean) => void;
+    variant?: 'black' | 'info' | 'success' | 'warning' | 'danger';
+}
+declare function Banner({ children, isCloseable, variant, isShow, setIsShow, }: BannerProps): React.JSX.Element | undefined;
+declare namespace Banner {
+    var defaultProps: {
+        isCloseable: boolean;
+        variant: string;
+    };
+}
+
+interface BrandProps {
+    variant: 'brand' | 'primary' | 'secondary' | 'black&white' | 'icon' | 'icon black&white' | 'icon outlined';
+    brand: 'biaenergi' | 'flowqount' | 'analytical' | 'getaway' | 'modeler' | 'opera' | 'ecovest' | 'welldone';
+}
+declare function Brand({ variant, brand }: BrandProps): React.JSX.Element;
+
+interface BreadcrumbProps extends ComponentPropsWithoutRef<'button'> {
+    disabled: boolean;
+    isActive?: boolean;
+}
+declare function Breadcrumb({ disabled, isActive, children, onClick, ...rest }: BreadcrumbProps): React.JSX.Element;
+declare namespace Breadcrumb {
+    var defaultProps: {
+        isActive: boolean;
+    };
+}
+
+interface ButtonProps extends ComponentPropsWithoutRef<'button'> {
+    className?: string;
+    children?: React.ReactNode;
+    iconRight?: React.ReactNode;
+    iconLeft?: React.ReactNode;
+    disabled?: boolean;
+    radius?: 'default' | 'full-rounded';
+    size?: 'large' | 'medium' | 'small' | 'tiny';
+    variant?: 'default' | 'danger' | 'info' | 'link' | 'primary' | 'subtle' | 'subtle-link' | 'success' | 'warning' | 'default-outlined' | 'danger-outlined' | 'info-outlined' | 'primary-outlined' | 'success-outlined' | 'warning-outlined';
+}
+declare function Button({ children, className, disabled, radius, size, variant, iconLeft, iconRight, ...props }: ButtonProps): React.JSX.Element;
+declare namespace Button {
+    var defaultProps: {
+        children: null;
+        className: string;
+        disabled: boolean;
+        radius: string;
+        size: string;
+        variant: string;
+        iconLeft: null;
+        iconRight: null;
+    };
+}
+
+declare function Color(): React.JSX.Element;
+
+interface DividerProps extends ComponentPropsWithoutRef<'div'> {
+    orientation: 'horizontal' | 'vertical';
+    classname?: string;
+}
+declare function Divider({ orientation, classname }: DividerProps): React.JSX.Element;
+declare namespace Divider {
+    var defaultProps: {
+        classname: string;
+    };
+}
+
+interface TextInputProps extends ComponentPropsWithoutRef<'input'> {
+    descText?: string;
+    isDisabled?: boolean;
+    icon?: React.ReactNode;
+    id?: string;
+    inputSize?: 'medium' | 'small';
+    isValid?: boolean | null;
+    label?: string;
+    placeholder?: string;
+    readOnly?: boolean;
+    variant?: 'password' | 'text' | 'number' | 'date';
+    value?: string;
+    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
+}
+declare function TextInput({ descText, isDisabled, icon, id, inputSize, isValid, label, placeholder, readOnly, required, variant, value, onChange, }: TextInputProps): React.JSX.Element;
+declare namespace TextInput {
+    var defaultProps: {
+        descText: string;
+        isDisabled: boolean;
+        icon: null;
+        id: string;
+        inputSize: string;
+        isValid: null;
+        label: string;
+        placeholder: string;
+        readOnly: boolean;
+        variant: string;
+        value: string;
+        onChange: () => void;
+    };
+}
+
+interface TextInputSimulationProps {
+    size?: 'medium' | 'small';
+}
+declare function TextInputSimulation({ size }: TextInputSimulationProps): React.JSX.Element;
+declare namespace TextInputSimulation {
+    var defaultProps: {
+        size: string;
+    };
+}
+
+interface RadioProps extends ComponentPropsWithoutRef<'input'> {
+    label?: string;
+    inputSize?: 'medium' | 'small';
+    id?: string;
+    onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
+    isDisabled?: boolean;
+    isChecked?: boolean;
+}
+declare function Radio({ label, inputSize, id, onClick, isDisabled, isChecked, }: RadioProps): React.JSX.Element;
+declare namespace Radio {
+    var defaultProps: {
+        label: string;
+        inputSize: string;
+        id: string;
+        onClick: () => void;
+        isDisabled: boolean;
+        isChecked: boolean;
+    };
+}
+
+interface TextAreaProps extends ComponentPropsWithoutRef<'textarea'> {
+    descText?: string;
+    disabled?: boolean;
+    id?: string;
+    inputSize?: 'medium' | 'small';
+    label?: string;
+    placeholder?: string;
+    required?: boolean;
+    rows?: number;
+}
+declare function TextArea({ descText, disabled, id, inputSize, label, placeholder, required, rows, ...props }: TextAreaProps): React.JSX.Element;
+declare namespace TextArea {
+    var defaultProps: {
+        disabled: boolean;
+        descText: string;
+        id: string;
+        inputSize: string;
+        label: string;
+        placeholder: string;
+        required: boolean;
+        rows: number;
+    };
+}
+
+interface CheckboxProps$1 extends ComponentPropsWithoutRef<'input'> {
+    disabled?: boolean;
+    id?: string;
+    inputSize?: 'medium' | 'small';
+    isChecked?: boolean;
+    label?: string;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    value: string | number | readonly string[] | undefined;
+}
+declare function Checkbox({ disabled, id, inputSize, isChecked, label, onChange, value, }: CheckboxProps$1): React.JSX.Element;
+declare namespace Checkbox {
+    var defaultProps: {
+        disabled: boolean;
+        id: string;
+        inputSize: string;
+        isChecked: boolean;
+        label: string;
+        onChange: () => void;
+    };
+}
+
+interface CheckboxSimulationProps {
+    size?: 'medium' | 'small';
+}
+declare function CheckboxSimulation({ size }: CheckboxSimulationProps): React.JSX.Element;
+declare namespace CheckboxSimulation {
+    var defaultProps: {
+        size: string;
+    };
+}
+
+interface SelectInputProps extends ComponentPropsWithoutRef<'input'> {
+    descText?: string;
+    isDisabled?: boolean;
+    id?: string;
+    inputSize?: 'medium' | 'small';
+    label?: string;
     options: any;
-    selected: object;
-    setSelected: any;
-    inputSize: string;
+    isRequired?: boolean;
+    selected?: {
+        id: any;
+        label: any;
+    };
+    setSelected?: any;
+}
+declare function SelectInput({ descText, isDisabled, inputSize, id, label, options, isRequired, selected, setSelected, }: SelectInputProps): React.JSX.Element;
+declare namespace SelectInput {
+    var defaultProps: {
+        descText: string;
+        isDisabled: boolean;
+        id: string;
+        inputSize: string;
+        label: string;
+        isRequired: boolean;
+        selected: {};
+        setSelected: () => void;
+    };
 }
-declare const SelectInput: ({ label, descText, isOpen, setIsOpen, options, selected, setSelected, inputSize, ...rest }: SelectInputProps) => React.JSX.Element;
 
-interface LiveSearchProps extends ComponentPropsWithoutRef<"input"> {
-    label: string;
-    inputSize: string;
-    searchData: any;
-    isOpen: boolean;
-    setIsOpen: any;
-    value: any;
-    setValue: any;
-    descText: string;
+interface SelectInputSimulationProps {
+    size: 'medium' | 'small';
 }
-declare const LiveSearch: ({ isOpen, setIsOpen, value, setValue, inputSize, ...rest }: LiveSearchProps) => React.JSX.Element;
+declare function SelectInputSimulation({ size, }: SelectInputSimulationProps): React.JSX.Element;
 
-interface CheckboxProps extends ComponentPropsWithoutRef<"input"> {
-    label: string;
-    inputSize: string;
-    data: string;
+interface LiveSearchProps extends ComponentPropsWithoutRef<'input'> {
+    descText?: string;
+    disabled?: boolean;
+    id?: string;
+    inputSize?: 'medium' | 'small';
+    label?: string;
+    placeholder?: string;
+    required?: boolean;
+    options?: any;
+    setValue?: any;
+    value?: any;
+}
+declare function LiveSearch({ descText, disabled, id, inputSize, label, placeholder, required, options, setValue, value, }: LiveSearchProps): React.JSX.Element;
+declare namespace LiveSearch {
+    var defaultProps: {
+        descText: string;
+        disabled: boolean;
+        id: string;
+        inputSize: string;
+        label: string;
+        placeholder: string;
+        required: boolean;
+        options: never[];
+        setValue: () => void;
+        value: {};
+    };
+}
+
+interface CheckboxProps extends ComponentPropsWithoutRef<'input'> {
+    label?: string;
+    inputSize?: 'medium' | 'small';
+    isChecked?: boolean;
+    id?: string;
+    onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+}
+declare function Toggle({ label, inputSize, onClick, isChecked, id, disabled, }: CheckboxProps): React.JSX.Element;
+declare namespace Toggle {
+    var defaultProps: {
+        label: string;
+        inputSize: string;
+        onClick: () => void;
+        isChecked: boolean;
+        id: string;
+        disabled: boolean;
+    };
 }
-declare const Toggle: ({ label, inputSize, onClick, ...rest }: CheckboxProps) => React.JSX.Element;
 
-interface DisplayProps extends ComponentPropsWithoutRef<"h1"> {
+interface SegmentButtonItemProps extends ComponentPropsWithoutRef<'button'> {
+    active: boolean;
+    size: 'large' | 'medium' | 'small' | 'tiny';
+    children: React.ReactNode;
+    disabled: boolean;
+    onClick: () => void;
 }
-declare const Display: ({ ...rest }: DisplayProps) => React.JSX.Element;
+declare function SegmentButtonItem({ active, size, children, disabled, onClick, }: SegmentButtonItemProps): React.JSX.Element;
+
+declare function SegmentButtonGroup({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
 
-interface HeadingProps extends ComponentPropsWithoutRef<"h1"> {
-    variant: string;
-    margin: boolean;
+interface SegmentButtonSimulationProps {
+    size: 'large' | 'medium' | 'small' | 'tiny';
 }
-declare const Heading: ({ variant, margin, ...rest }: HeadingProps) => React.JSX.Element;
+declare function SegmentButtonSimulation({ size, }: SegmentButtonSimulationProps): React.JSX.Element;
 
-interface ParagraphProps extends ComponentPropsWithoutRef<"p"> {
+interface ModalProps extends ComponentPropsWithoutRef<'div'> {
+    size: 'small' | 'medium' | 'large' | 'extra large';
+    title?: string;
+    isShow: boolean;
+    setIsShow: (arg0: boolean) => void;
+}
+declare function Modal({ size, title, isShow, setIsShow, ...rest }: ModalProps): React.JSX.Element | null;
+declare namespace Modal {
+    var defaultProps: {
+        title: null;
+    };
 }
-declare const P: ({ ...rest }: ParagraphProps) => React.JSX.Element;
 
-interface TextProps extends ComponentPropsWithoutRef<"span"> {
-    variant: string;
-    action: string;
+interface PagingProps extends ComponentPropsWithoutRef<'div'> {
+    size: 'small' | 'medium';
+    position: 'start' | 'center' | 'end';
+    currentPage: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
 }
-declare const Text: ({ variant, action, ...rest }: TextProps) => React.JSX.Element;
+declare function PaginationBar({ size, position, currentPage, totalPages, onPageChange, }: PagingProps): React.JSX.Element;
 
-interface ModalProps extends ComponentPropsWithoutRef<"div"> {
-    modalSize: string;
+interface PillsProps extends ComponentPropsWithoutRef<'button'> {
     title: string;
-    isShow: boolean;
-    setIsShow: any;
-    atribut: any;
+    selected: boolean;
+    iconLeft?: React.ReactNode;
+    iconRight?: React.ReactNode;
+}
+declare function Piils({ title, iconLeft, iconRight, selected, onClick, ...props }: PillsProps): React.JSX.Element;
+declare namespace Piils {
+    var defaultProps: {
+        iconLeft: null;
+        iconRight: null;
+    };
+}
+
+interface PopoverProps {
+    children: React.ReactNode;
+    content: string;
+    delay?: number;
+    direction?: 'top' | 'right' | 'bottom' | 'left';
+    title?: string;
+    isActive: boolean;
+    setIsActive: (arg0: boolean) => void;
+}
+declare function Popover({ children, content, delay, direction, title, isActive, setIsActive, }: PopoverProps): React.JSX.Element;
+declare namespace Popover {
+    var defaultProps: {
+        delay: number;
+        direction: string;
+        title: string;
+    };
 }
-declare const ModalBody: ({ ...rest }: ModalProps) => React.JSX.Element;
 
-interface ModalContentProps extends ComponentPropsWithoutRef<"div"> {
+interface ProgressCircleProps {
+    variant: 'success' | 'failed' | 'persentage';
+    persentage: number;
 }
-declare const ModalContent: ({ ...rest }: ModalContentProps) => React.JSX.Element;
+declare function ProgressCircle({ variant, persentage, }: ProgressCircleProps): React.JSX.Element;
 
-interface ModalFooterProps extends ComponentPropsWithoutRef<"div"> {
-    position?: string;
+interface ResizeableDivProps extends ComponentPropsWithRef<'div'> {
+    position?: 'top' | 'right' | 'bottom' | 'left';
+    children: React.ReactNode;
 }
-declare const ModalFooter: ({ ...rest }: ModalFooterProps) => React.JSX.Element;
+declare function ResizeableDiv({ position, children, className, }: ResizeableDivProps): React.JSX.Element;
+declare namespace ResizeableDiv {
+    var defaultProps: {
+        position: string;
+    };
+}
+
+interface ResizeableDivSimulationProps {
+    resizerPosition?: 'top' | 'right' | 'bottom' | 'left';
+}
+declare function ResizeableDivSimulation({ resizerPosition, }: ResizeableDivSimulationProps): React.JSX.Element;
+declare namespace ResizeableDivSimulation {
+    var defaultProps: {
+        resizerPosition: string;
+    };
+}
+
+interface SliderProps {
+    disabled: boolean;
+}
+declare function Slider({ disabled }: SliderProps): React.JSX.Element;
 
-interface TableProps extends ComponentPropsWithoutRef<"table"> {
-    desc: string;
-    tableSize: string;
+declare function Spinner(): React.JSX.Element;
+
+interface TabProps extends ComponentPropsWithoutRef<'button'> {
+    children?: React.ReactNode;
+    active: boolean;
+    icon?: React.ReactNode;
+    card?: boolean;
+    mode?: 'horizontal' | 'vertical';
+    fit?: 'fit-content' | 'maximize';
+    size?: 'medium' | 'small';
+}
+declare function Tab({ children, active, icon, disabled, mode, fit, size, card, ...rest }: TabProps): React.JSX.Element;
+declare namespace Tab {
+    var defaultProps: {
+        children: null;
+        mode: string;
+        fit: string;
+        size: string;
+        icon: null;
+        card: boolean;
+    };
 }
-declare const Table: ({ desc, tableSize, className, children, ...rest }: TableProps) => React.JSX.Element;
 
-interface TableRowProps extends ComponentPropsWithoutRef<"tr"> {
-    colNum: number;
+interface TableProps extends ComponentPropsWithoutRef<'table'> {
+    tableSize?: 'medium' | 'small' | 'tiny';
+    className?: string;
+    children: React.ReactNode;
+}
+declare function Table({ tableSize, className, children }: TableProps): React.JSX.Element;
+declare namespace Table {
+    var defaultProps: {
+        tableSize: string;
+        className: string;
+    };
 }
-declare const TableRow: ({ colNum, className, children, ...rest }: TableRowProps) => React.JSX.Element;
 
-interface TableColProps extends ComponentPropsWithoutRef<"td"> {
-    variant: string;
-    alignment: string;
-    lined: boolean;
-    color: string;
+interface TableRowProps extends ComponentPropsWithoutRef<'tr'> {
+    children: React.ReactNode;
+    className?: string;
+}
+declare function TableRow({ className, children }: TableRowProps): React.JSX.Element;
+declare namespace TableRow {
+    var defaultProps: {
+        className: string;
+    };
 }
-declare const TableCol: ({ variant, lined, color, alignment, className, children, ...rest }: TableColProps) => React.JSX.Element;
 
-interface TableHeadProps extends ComponentPropsWithoutRef<"thead"> {
+interface TableColProps extends ComponentPropsWithoutRef<'td'> {
+    variant?: 'head' | 'body';
+    alignment?: 'middle' | 'right' | 'left';
+    lined?: boolean;
+    size?: 'medium' | 'small' | 'tiny';
+}
+declare function TableCol({ variant, lined, alignment, className, children, size, }: TableColProps): React.JSX.Element;
+declare namespace TableCol {
+    var defaultProps: {
+        variant: string;
+        lined: boolean;
+        alignment: string;
+        size: string;
+    };
 }
-declare const TableHead: ({ className, children, ...rest }: TableHeadProps) => React.JSX.Element;
 
-interface TableBodyProps extends ComponentPropsWithoutRef<"tbody"> {
+interface TableHeadProps extends ComponentPropsWithoutRef<'thead'> {
+    children: React.ReactNode;
+    className?: string;
+}
+declare function TableHead({ className, children }: TableHeadProps): React.JSX.Element;
+declare namespace TableHead {
+    var defaultProps: {
+        className: string;
+    };
 }
-declare const TableBody: ({ className, children, ...rest }: TableBodyProps) => React.JSX.Element;
 
-interface TagLabelProps extends ComponentPropsWithoutRef<"span"> {
-    text: string;
-    variant: string;
-    size: string;
-    color: string;
-    capitalize: boolean;
-    textColor: string;
-    closeHandler?: any;
-    right?: any;
-    left?: any;
+interface TableBodyProps extends ComponentPropsWithoutRef<'tbody'> {
+    children: React.ReactNode;
+    className?: string;
 }
-declare const TagLabel: ({ text, variant, size, color, right, left, closeHandler, capitalize, textColor, ...rest }: TagLabelProps) => React.JSX.Element;
+declare function TableBody({ className, children }: TableBodyProps): React.JSX.Element;
+declare namespace TableBody {
+    var defaultProps: {
+        className: string;
+    };
+}
+
+interface TableDemoProps {
+    tableSize?: 'medium' | 'small' | 'tiny';
+}
+declare function TableDemo({ tableSize }: TableDemoProps): React.JSX.Element;
+declare namespace TableDemo {
+    var defaultProps: {
+        tableSize: string;
+    };
+}
+
+interface TagLabelProps extends ComponentPropsWithoutRef<'div'> {
+    color: 'default' | 'blue' | 'teal' | 'green' | 'yellow' | 'red' | 'black' | 'white';
+    size?: 'medium' | 'small' | 'tiny';
+    variant?: 'label' | 'icon' | 'closeable';
+    closeHandler?: () => void;
+    isShow?: boolean;
+    children: React.ReactNode;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+}
+declare function TagLabel({ children, closeHandler, size, variant, isShow, color, leftIcon, rightIcon, }: TagLabelProps): React.JSX.Element | null;
+declare namespace TagLabel {
+    var defaultProps: {
+        variant: string;
+        size: string;
+        isShow: boolean;
+        closeHandler: () => void;
+        rightIcon: null;
+        leftIcon: null;
+    };
+}
+
+interface TooltipProps {
+    children: React.ReactNode;
+    content: React.ReactNode;
+    delay?: number;
+    direction?: 'top' | 'right' | 'bottom' | 'left';
+}
+declare function Tooltip(props: TooltipProps): React.JSX.Element;
+declare namespace Tooltip {
+    var defaultProps: {
+        delay: number;
+        direction: string;
+    } | {
+        delay?: undefined;
+        direction?: undefined;
+    };
+}
+
+interface DisplayProps extends ComponentPropsWithoutRef<'h1'> {
+    children: React.ReactNode;
+}
+declare function Display({ children }: DisplayProps): React.JSX.Element;
+
+interface HeadingProps extends ComponentPropsWithoutRef<'h1'> {
+    variant?: '1' | '2' | '3' | '4' | '5' | '6';
+    className?: string;
+    children: React.ReactNode;
+}
+declare function Heading({ variant, className, children }: HeadingProps): React.JSX.Element;
+declare namespace Heading {
+    var defaultProps: {
+        variant: string;
+        className: string;
+    };
+}
+
+interface ParagraphProps extends ComponentPropsWithoutRef<'p'> {
+    className?: string;
+    fontSize?: 'size-base' | 'size-sm' | 'size-lg' | 'size-tiny' | 'size-md';
+    children: React.ReactNode;
+}
+declare function P({ className, fontSize, children, }: ParagraphProps): React.JSX.Element;
+declare namespace P {
+    var defaultProps: {
+        className: string;
+        fontSize: string;
+    };
+}
+
+interface TextProps extends ComponentPropsWithoutRef<'span'> {
+    extended?: string;
+    children: React.ReactNode;
+    variant: 'large-text' | 'large-text-semibold' | 'medium-text' | 'medium-text-semibold' | 'caption' | 'caption-semibold' | 'normal-text' | 'normal-text-semilight' | 'normal-text-semibold' | 'normal-text-bold' | 'small-text' | 'small-text-semibold' | 'tiny-text' | 'tiny-text-bold' | 'script' | 'link';
+}
+declare function Text({ extended, variant, children }: TextProps): React.JSX.Element;
+declare namespace Text {
+    var defaultProps: {
+        extended: string;
+    };
+}
+
+declare function ScrollbarSimulation(): React.JSX.Element;
+
+declare function HiddenScrollbarSimulation(): React.JSX.Element;
 
-export { Button, Checkbox, Dump as Color, Display, Heading, LiveSearch, ModalBody, ModalContent, ModalFooter, P, Radio, SelectInput, Table, TableBody, TableCol, TableHead, TableRow, TagLabel, Text, TextArea, TextInput, Toggle };
+export { Accordions, Alert, Avatar, Badge, Banner, Brand, Breadcrumb, Button, Checkbox, CheckboxSimulation, Color, Display, Divider, Heading, HiddenScrollbarSimulation, LiveSearch, Modal, P, PaginationBar, Piils as Pills, Popover, ProgressCircle, Radio, ResizeableDiv, ResizeableDivSimulation, ScrollbarSimulation, SegmentButtonGroup, SegmentButtonItem, SegmentButtonSimulation, SelectInput, SelectInputSimulation, Slider, Spinner, Tab, Table, TableBody, TableCol, TableDemo, TableHead, TableRow, TagLabel, Text, TextArea, TextInput, TextInputSimulation, Toggle, Tooltip };