@segmentify/ui 0.0.57 → 0.0.59

package/dist/src/components/atoms/sidebar.d.ts

@@ -0,0 +1,59 @@
+import * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+import { Button } from '../../../components/atoms/button';
+import { Input } from '../../../components/atoms/input';
+import { Separator } from '../../../components/atoms/separator';
+import { TooltipContent } from '../../../components/atoms/tooltip';
+declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, style, children, ...props }: React.ComponentProps<'div'> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element;
+declare function Sidebar({ side, variant, collapsible, className, children, ...props }: React.ComponentProps<'div'> & {
+    side?: 'left' | 'right';
+    variant?: 'sidebar' | 'floating' | 'inset';
+    collapsible?: 'offcanvas' | 'icon' | 'none';
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarTrigger({ className, onClick, ...props }: React.ComponentProps<typeof Button>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarRail({ className, ...props }: React.ComponentProps<'button'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarInset({ className, ...props }: React.ComponentProps<'main'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarInput({ className, ...props }: React.ComponentProps<typeof Input>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarSeparator({ className, ...props }: React.ComponentProps<typeof Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarContent({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroup({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroupLabel({ className, asChild, ...props }: React.ComponentProps<'div'> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroupAction({ className, asChild, ...props }: React.ComponentProps<'button'> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroupContent({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenu({ className, ...props }: React.ComponentProps<'ul'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: React.ComponentProps<'li'>): import("react/jsx-runtime").JSX.Element;
+declare const sidebarMenuButtonVariants: (props?: ({
+    variant?: "outline" | "default" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function SidebarMenuButton({ asChild, isActive, variant, size, tooltip, className, ...props }: React.ComponentProps<'button'> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & VariantProps<typeof sidebarMenuButtonVariants>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuAction({ className, asChild, showOnHover, ...props }: React.ComponentProps<'button'> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuBadge({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React.ComponentProps<'div'> & {
+    showIcon?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSub({ className, ...props }: React.ComponentProps<'ul'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSubItem({ className, ...props }: React.ComponentProps<'li'>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSubButton({ asChild, size, isActive, className, ...props }: React.ComponentProps<'a'> & {
+    asChild?: boolean;
+    size?: 'sm' | 'md';
+    isActive?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, };

package/dist/src/components/atoms/skeleton.d.ts

@@ -0,0 +1,3 @@
+import { type ComponentProps } from 'react';
+declare function Skeleton({ className, ...props }: ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

package/dist/src/components/atoms/slider.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+declare function Slider({ className, defaultValue, value, min, max, ...props }: React.ComponentProps<typeof SliderPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Slider };

package/dist/src/components/atoms/sonner.d.ts

@@ -0,0 +1,3 @@
+import { type ToasterProps } from 'sonner';
+declare const Toaster: ({ ...props }: ToasterProps) => import("react/jsx-runtime").JSX.Element;
+export { Toaster };

package/dist/src/components/atoms/spinner.d.ts

@@ -0,0 +1,7 @@
+import type { ClassValue } from 'clsx';
+interface SpinnerProps extends React.ComponentProps<'svg'> {
+    containerClassName?: ClassValue;
+    title?: string;
+}
+declare function Spinner({ title, containerClassName, className, ...props }: SpinnerProps): import("react/jsx-runtime").JSX.Element;
+export { Spinner };

package/dist/src/components/atoms/switch.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+declare function Switch({ className, ...props }: React.ComponentProps<typeof SwitchPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Switch };

package/dist/src/components/atoms/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+declare function Table({ className, ...props }: React.ComponentProps<'table'>): import("react/jsx-runtime").JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<'thead'>): import("react/jsx-runtime").JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<'tbody'>): import("react/jsx-runtime").JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<'tfoot'>): import("react/jsx-runtime").JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<'tr'>): import("react/jsx-runtime").JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<'th'>): import("react/jsx-runtime").JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<'td'>): import("react/jsx-runtime").JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<'caption'>): import("react/jsx-runtime").JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption };

package/dist/src/components/atoms/tabs.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+declare function Tabs({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TabsList({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.List>): import("react/jsx-runtime").JSX.Element;
+declare function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/src/components/atoms/textarea.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare function Textarea({ className, ...props }: React.ComponentProps<'textarea'>): import("react/jsx-runtime").JSX.Element;
+export { Textarea };

package/dist/src/components/atoms/tooltip.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare const TooltipContentWithPortal: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipContentWithPortal, TooltipProvider };

package/dist/src/components/molecules/async-combobox.d.ts

@@ -0,0 +1,15 @@
+export type AsyncComboboxItem = {
+    value: string;
+    label: string;
+};
+export type AsyncComboboxProps = {
+    selectedItem: AsyncComboboxItem;
+    fetchItems: (search: string, signal?: AbortSignal) => Promise<AsyncComboboxItem[]>;
+    onSelect: (item: AsyncComboboxItem) => void;
+    searchPlaceholder?: string;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+    align?: 'start' | 'center' | 'end';
+};
+export declare function AsyncCombobox({ selectedItem, fetchItems: fetchItemsProp, searchPlaceholder, placeholder, className, disabled, align, onSelect, }: AsyncComboboxProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/molecules/base-button.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { buttonVariants } from '../../../lib/design-variants';
+declare const BaseButton: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "children"> & {
+    size?: VariantProps<typeof buttonVariants>["size"];
+    variant?: VariantProps<typeof buttonVariants>["variant"];
+    label?: string;
+    isSuffix?: boolean;
+    isPrefix?: boolean;
+    isLoading?: boolean;
+    labelClassName?: string;
+    isIconOnly?: boolean;
+    icon?: React.ReactNode;
+} & React.RefAttributes<HTMLButtonElement>>;
+export { BaseButton };

package/dist/src/components/molecules/campaign-title.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface CampaignTitleProps {
+    label: React.ReactNode;
+    isEdit?: boolean;
+    campaignId?: string;
+    children?: React.ReactNode;
+}
+declare const CampaignTitle: ({ label, campaignId, isEdit, children }: CampaignTitleProps) => import("react/jsx-runtime").JSX.Element;
+export { CampaignTitle };

package/dist/src/components/molecules/checkbox-field.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Checkbox } from '../../../components/atoms/checkbox';
+interface Props extends React.ComponentProps<typeof Checkbox> {
+    label: string;
+    name: string;
+    description?: string;
+    onCheckedChange: (checked: boolean) => void;
+}
+export declare const CheckboxField: ({ label, name, description, onCheckedChange, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/combobox-field.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+export type ComboboxFieldItem = {
+    value: string;
+    label: string;
+    disabled?: boolean;
+};
+export type ComboboxFieldInputMode = 'input' | 'popup';
+type Props = {
+    items: ComboboxFieldItem[];
+    value: ComboboxFieldItem[];
+    onValueChange: (values: ComboboxFieldItem[]) => void;
+    label?: string;
+    multiple?: boolean;
+    hasClearButton?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    containerClassName?: string;
+    emptyMessage?: string;
+    hasAllOption?: boolean;
+    allOptionLabel?: string;
+    inputMode?: ComboboxFieldInputMode;
+    renderPopupTrigger?: (valueElement: React.ReactNode, selectedValues: ComboboxFieldItem[]) => React.ReactElement;
+    onInputChange?: (value: string) => void;
+};
+export declare const ComboboxField: ({ items, label, multiple, hasClearButton, disabled, placeholder, containerClassName, emptyMessage, hasAllOption, allOptionLabel, inputMode, renderPopupTrigger, onInputChange, value, onValueChange, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/creatable-action-icons.d.ts

@@ -0,0 +1,9 @@
+import { type ClassValue } from 'clsx';
+type Props = {
+    onCreate: () => void;
+    onDelete: () => void;
+    showCreate?: boolean;
+    className?: ClassValue;
+};
+export declare const CreatableActionIcons: ({ onCreate, onDelete, showCreate, className }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/date-range-picker.d.ts

@@ -0,0 +1,17 @@
+import { type ClassValue } from 'clsx';
+import { type Locale } from 'date-fns';
+import { type DateRange } from 'react-day-picker';
+type Props = {
+    start?: Date;
+    end?: Date;
+    onConfirm: (range: DateRange) => void;
+    label?: string;
+    placeholder: string;
+    triggerButtonClassName?: ClassValue;
+    className?: ClassValue;
+    confirmLabel?: string;
+    disabledCondition?: boolean | ((date: Date) => boolean);
+    dateLocale?: Locale;
+};
+export declare const DateRangePicker: ({ start, end, onConfirm, className, triggerButtonClassName, label, placeholder, confirmLabel, disabledCondition, dateLocale, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/debounced-input.d.ts

@@ -0,0 +1,19 @@
+import type { O } from 'ts-toolbelt';
+interface BaseSearchInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder: string;
+    className?: string;
+    inputClassName?: string;
+}
+type WithLabelProps = O.Merge<BaseSearchInputProps, {
+    label: string;
+    name: string;
+}>;
+type WithoutLabelProps = O.Merge<BaseSearchInputProps, {
+    label?: undefined;
+    name?: string;
+}>;
+type SearchInputProps = WithLabelProps | WithoutLabelProps;
+declare function DebouncedInput({ value, onChange, className, inputClassName, name, placeholder, label }: SearchInputProps): import("react/jsx-runtime").JSX.Element;
+export { DebouncedInput };

package/dist/src/components/molecules/detailed-image-modal.d.ts

@@ -0,0 +1,18 @@
+import { type ClassValue } from 'clsx';
+import type { Union } from 'ts-toolbelt';
+type BaseProps = {
+    banner: string;
+    campaignName: string;
+    imageClassName?: ClassValue;
+};
+type ControlledProps = BaseProps & {
+    isControlled: true;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+};
+type UncontrolledProps = BaseProps & {
+    isControlled?: false;
+};
+type DetailedImageModalProps = Union.Strict<ControlledProps | UncontrolledProps>;
+export declare const DetailedImageModal: ({ banner, campaignName, isControlled, open, setOpen, imageClassName, }: DetailedImageModalProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/form-checkbox.d.ts

@@ -0,0 +1,9 @@
+import { type Control, type FieldValues, type Path } from 'react-hook-form';
+type FormCheckboxProps<TFieldValues extends FieldValues = FieldValues> = {
+    name: Path<TFieldValues>;
+    control?: Control<TFieldValues>;
+    label: string;
+    containerClassName?: string;
+};
+export declare const FormCheckbox: <TFieldValues extends FieldValues = FieldValues>({ name, control, containerClassName, ...props }: FormCheckboxProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/form-phone-input.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import flags from 'react-phone-number-input/flags';
+import { PhoneInput } from '../../../components/atoms/phone-input';
+export type FormPhoneInputProps = {
+    label: string;
+    name: string;
+    description?: string;
+    showErrorPlaceholder?: boolean;
+    errorClassName?: string;
+    containerClassName?: string;
+    labelClassName?: string;
+    mainLanguage?: keyof typeof flags;
+} & Omit<React.ComponentProps<typeof PhoneInput>, 'defaultCountry' | 'value' | 'onChange' | 'onBlur' | 'name' | 'ref'>;
+export declare const FormPhoneInput: ({ label, name, description, showErrorPlaceholder, errorClassName, containerClassName, labelClassName, mainLanguage, ...props }: FormPhoneInputProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/molecules/input-field.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { labelVariants } from '../../../lib/design-variants';
+export interface InputFieldProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'label'> {
+    name: string;
+    value?: string | number | readonly string[];
+    label?: string;
+    labelVariant?: VariantProps<typeof labelVariants>['variant'];
+    description?: string;
+    isReadOnly?: boolean;
+    inputClassName?: string;
+    hasRequiredIndicator?: boolean;
+}
+declare const InputField: React.ForwardRefExoticComponent<InputFieldProps & React.RefAttributes<HTMLInputElement>>;
+export { InputField };

package/dist/src/components/molecules/messaging-phone.d.ts

@@ -0,0 +1,2 @@
+import { MessagingPhoneProps } from '../../../types/messaging';
+export declare const MessagingPhone: (props: MessagingPhoneProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/molecules/messaging-preview.d.ts

@@ -0,0 +1,5 @@
+import { MessagingPhoneProps } from '../../../types/messaging';
+export declare const MessagingPreview: {
+    (props: MessagingPhoneProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/components/molecules/mobile-preview-message.d.ts

@@ -0,0 +1,8 @@
+import { type PropsWithChildren } from 'react';
+import { MessageCarouselCard } from '../../../types/messaging';
+type MobilePreviewMessageProps = {
+    cards?: MessageCarouselCard[];
+    includeTime?: boolean;
+};
+export declare const MobilePreviewMessage: ({ children, cards, includeTime, }: PropsWithChildren<MobilePreviewMessageProps>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/multi-select-dropdown.d.ts

@@ -0,0 +1,18 @@
+import { SelectItemProps } from '../../../lib/types';
+interface MultiSelectDropdownProps {
+    label: string;
+    options: SelectItemProps[];
+    value: string[];
+    onChange: (value: string[]) => void;
+    toggleAllLabel?: string;
+    optionSuffix?: string;
+    translateOptions?: boolean;
+    containerClassName?: string;
+    contentClassName?: string;
+    triggerClassName?: string;
+    showSelectedItemLabels?: boolean;
+    showErrorPlaceholder?: boolean;
+    error?: string;
+}
+declare function MultiSelectDropdown({ label, options, value, onChange, toggleAllLabel, optionSuffix, translateOptions, containerClassName, contentClassName, triggerClassName, showSelectedItemLabels, showErrorPlaceholder, error, }: MultiSelectDropdownProps): import("react/jsx-runtime").JSX.Element;
+export { MultiSelectDropdown };

package/dist/src/components/molecules/preview-carousel.d.ts

@@ -0,0 +1,2 @@
+import { MessagingPhoneProps } from '../../../types/messaging';
+export declare const PreviewCarousel: ({ body, carousel }: MessagingPhoneProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/molecules/preview-rich-media.d.ts

@@ -0,0 +1,5 @@
+import { MessagingPhoneProps } from '../../../types/messaging';
+export declare const PreviewRichMedia: {
+    ({ header, body, footer, buttons }: MessagingPhoneProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/components/molecules/recommendation-card/components/recommendation-filters-button.d.ts

@@ -0,0 +1,9 @@
+import React, { ReactNode } from 'react';
+interface RecommendationFiltersButtonProps {
+    onClick: () => void;
+    icon: ReactNode;
+    label: ReactNode;
+    isInclusion?: boolean;
+}
+export declare const RecommendationFiltersButton: React.FC<RecommendationFiltersButtonProps>;
+export {};

package/dist/src/components/molecules/recommendation-card/components/selected-algorithms.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { FieldValues } from 'react-hook-form';
+import { RecommendationCardConfig, SharedAlgorithmProps } from '../types';
+interface SelectedAlgorithmsProps<TFieldValues extends FieldValues = FieldValues> extends SharedAlgorithmProps<TFieldValues> {
+    update: (index: number, value: unknown) => void;
+    swap: (index1: number, index2: number) => void;
+    remove: (index: number) => void;
+    move: (from: number, to: number) => void;
+    config?: RecommendationCardConfig;
+}
+export declare const SelectedAlgorithms: React.FC<SelectedAlgorithmsProps>;
+export {};

package/dist/src/components/molecules/recommendation-card/index.d.ts

@@ -0,0 +1,2 @@
+import { RecommendationCardProps } from './types';
+export declare const RecommendationCard: <TFieldValues extends Record<string, unknown> = Record<string, unknown>>({ ...props }: RecommendationCardProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/molecules/recommendation-card/types/index.d.ts

@@ -0,0 +1,82 @@
+import { ReactNode } from 'react';
+import { ArrayPath, Control, FieldValues, UseFieldArrayReturn } from 'react-hook-form';
+export type AlgorithmType = 'INTELLIGENT' | 'STATIC';
+export type FilterType = 'exclude' | 'include';
+export declare const STATIC_ALGORITHM_TYPE: {
+    readonly PRODUCT: "PRODUCT";
+};
+export interface IntelligentAlgorithmOption {
+    id: string;
+    icon?: ReactNode;
+    description?: ReactNode;
+    label: string;
+    value: string;
+    desktopProductCount?: number;
+    mobileProductCount?: number;
+    timeFrame?: string;
+    isTimeFrameDisabled?: boolean;
+    isOptionsDisabled?: boolean;
+    suitablePages?: string[];
+    [key: string]: unknown;
+}
+export interface StaticAlgorithmOption {
+    key: string;
+    title: string;
+    description?: string;
+    icon?: ReactNode;
+    [key: string]: unknown;
+}
+export interface EmailAlgorithmConfig {
+    isMultiSelect?: boolean;
+    uniqueItems?: boolean;
+    isIntelligentDisabled?: boolean;
+    isStaticDisabled?: boolean;
+    [key: string]: unknown;
+}
+export interface RecommendationCardConfig {
+    isRecommendation?: boolean;
+    isEmail?: boolean;
+    isWhatsapp?: boolean;
+    isSearch?: boolean;
+    isPromotion?: boolean;
+    isKeyword?: boolean;
+    showShuffleProducts?: boolean;
+    showRecommendOtherCategories?: boolean;
+    showShufflePromotions?: boolean;
+}
+export interface SharedAlgorithmProps<TFieldValues extends FieldValues = FieldValues> {
+    control: Control<TFieldValues>;
+    fields: Record<string, unknown>[];
+    intelligentAlgorithms: IntelligentAlgorithmOption[];
+    staticAlgorithms?: Record<string, StaticAlgorithmOption>;
+    emailAlgorithmConfig?: EmailAlgorithmConfig;
+}
+export interface RecommendationCardProps<TFieldValues extends FieldValues = FieldValues> {
+    control: Control<TFieldValues>;
+    fieldArray: UseFieldArrayReturn<TFieldValues, ArrayPath<TFieldValues>, 'id'>;
+    intelligentAlgorithms: IntelligentAlgorithmOption[];
+    staticAlgorithms?: Record<string, StaticAlgorithmOption>;
+    emailAlgorithmConfig?: EmailAlgorithmConfig;
+    labels?: {
+        title?: ReactNode;
+        description?: ReactNode;
+        shuffleProducts?: string;
+        recommendOtherCategories?: string;
+        shufflePromotions?: string;
+        exclusionFilters?: ReactNode;
+        inclusionFilters?: ReactNode;
+    };
+    config?: RecommendationCardConfig;
+    onFiltersToggle?: (type: FilterType, isOpen: boolean) => void;
+    renderFilters?: (type: FilterType) => ReactNode;
+    renderAlgorithmModals?: (props: SharedAlgorithmProps<TFieldValues> & {
+        append: UseFieldArrayReturn<TFieldValues, ArrayPath<TFieldValues>, 'id'>['append'];
+    }) => ReactNode;
+    renderSelectedAlgorithms?: (props: SharedAlgorithmProps<TFieldValues> & {
+        update: UseFieldArrayReturn<TFieldValues, ArrayPath<TFieldValues>, 'id'>['update'];
+        move: (from: number, to: number) => void;
+        swap: (index1: number, index2: number) => void;
+        remove: (index: number) => void;
+        config?: RecommendationCardConfig;
+    }) => ReactNode;
+}

package/dist/src/components/molecules/select-field.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { Select } from '../../../components/atoms/select';
+import type { SelectItemProps } from '../../../lib/types';
+interface SelectFieldProps extends React.ComponentProps<typeof Select> {
+    options: SelectItemProps[];
+    placeholder: string;
+    onChange: (value: string) => void;
+    value: string;
+    label?: string;
+    labelClassName?: string;
+    triggerClassName?: string;
+    containerClassName?: string;
+    isPortal?: boolean;
+    hasFormControlWrapper?: boolean;
+    selectContentClassName?: string;
+}
+export declare const SelectField: ({ options, placeholder, hasFormControlWrapper, selectContentClassName, onChange, value, label, triggerClassName, labelClassName, containerClassName, isPortal, ...props }: SelectFieldProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/select-multi-field.d.ts

@@ -0,0 +1,20 @@
+import { type ActionMeta, type InputActionMeta, type MultiValue, type SingleValue } from 'react-select';
+import { SelectItemProps } from '../../../lib/types';
+type SelectFieldProps = {
+    label?: string;
+    name: string;
+    options: SelectItemProps[];
+    value: SingleValue<SelectItemProps> | MultiValue<SelectItemProps>;
+    onChange?: (newValue: SingleValue<SelectItemProps> | MultiValue<SelectItemProps>, actionMeta: ActionMeta<SelectItemProps>) => void;
+    onInputChange?: (inputValue: string, actionMeta: InputActionMeta) => void;
+    placeholder?: string;
+    isClearable?: boolean;
+    isSearchable?: boolean;
+    isMulti?: boolean;
+    isDisabled?: boolean;
+    isCreatable?: boolean;
+    description?: string;
+    className?: string;
+};
+export declare function SelectMultiField({ label, name, options, value, onChange, onInputChange, placeholder, isClearable, isSearchable, isMulti, isDisabled, description, className, isCreatable, }: SelectFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/switch-field.d.ts

@@ -0,0 +1,7 @@
+import { Switch } from '../../../components/atoms/switch';
+interface Props extends React.ComponentProps<typeof Switch> {
+    label?: string;
+    name: string;
+}
+export declare const SwitchField: ({ label, name, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/textarea-field.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { type ClassValue } from 'clsx';
+import { Textarea } from '../../../components/atoms/textarea';
+interface Props extends React.ComponentProps<typeof Textarea> {
+    textAreaClassName?: ClassValue;
+    value: string;
+    onChange: (e: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    label?: string;
+}
+export declare const TextAreaField: ({ textAreaClassName, value, onChange, label, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/molecules/tooltip-field.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+type TooltipFieldProps = {
+    trigger: React.ReactNode;
+    content: React.ReactNode;
+    asChild?: boolean;
+    wrapTrigger?: boolean;
+    triggerClassName?: string;
+    contentClassName?: string;
+    disableContent?: boolean;
+    isPortal?: boolean;
+};
+declare const TooltipField: ({ trigger, content, asChild, wrapTrigger, triggerClassName, contentClassName, disableContent, isPortal, }: TooltipFieldProps) => string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export { TooltipField };

package/dist/src/components/organisms/data-table/actions.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+export interface ActionItem {
+    label: string;
+    icon?: ReactNode;
+    onClick: () => void;
+    variant?: 'default' | 'destructive';
+    disabled?: boolean;
+}
+export interface ActionsProps {
+    actions: ActionItem[];
+}
+export declare const Actions: ({ actions }: ActionsProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/src/components/organisms/data-table/column-visibility.d.ts

@@ -0,0 +1,6 @@
+interface ColumnVisibilityProps {
+    emptyMessage?: string;
+    allOptionLabel?: string;
+}
+export declare function ColumnVisibility({ emptyMessage, allOptionLabel, }: ColumnVisibilityProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/organisms/data-table/content.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { type Row } from '@tanstack/react-table';
+export interface RenderRowSubComponentProps<TData = unknown> {
+    row: Row<TData>;
+}
+interface ContentProps {
+    className?: string;
+    loadingContent?: ReactNode;
+    emptyContent?: ReactNode;
+    /**
+     * Render a sub-component below a row when it's expanded.
+     * The sub-component can handle its own data fetching and render sub-rows.
+     * @example ({ row }) => <SubRowAsync row={row} />
+     */
+    renderRowSubComponent?: (props: RenderRowSubComponentProps) => ReactNode;
+}
+export declare function Content({ className, loadingContent, emptyContent, renderRowSubComponent, }: ContentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/organisms/data-table/context.d.ts

@@ -0,0 +1,10 @@
+import { type Table as TanstackTable } from '@tanstack/react-table';
+export interface DataTableContextValue<TData> {
+    table: TanstackTable<TData>;
+    isLoading: boolean;
+    search: string;
+    onSearchChange: (value: string) => void;
+    totalCount?: number;
+}
+export declare const DataTableContext: import("react").Context<DataTableContextValue<unknown> | null>;
+export declare function useDataTableContext<TData>(): DataTableContextValue<TData>;