@wakastellar/ui 3.5.2 → 4.0.0

package/dist/components/waka-chat-bubble/index.d.ts

@@ -0,0 +1,127 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export type MessageStatus = "sending" | "sent" | "delivered" | "read" | "failed";
+export type ReadReceiptStatus = "sent" | "delivered" | "read";
+export interface MessageReaction {
+    emoji: string;
+    count: number;
+    users: string[];
+    reacted: boolean;
+}
+export interface MessageAttachment {
+    id: string;
+    type: "image" | "file" | "video" | "audio";
+    url: string;
+    name: string;
+    size?: number;
+    mimeType?: string;
+    thumbnail?: string;
+    width?: number;
+    height?: number;
+}
+export interface LinkPreview {
+    url: string;
+    title: string;
+    description?: string;
+    image?: string;
+    favicon?: string;
+    siteName?: string;
+}
+export interface MessageThread {
+    count: number;
+    lastReply?: string;
+    participants: Array<{
+        id: string;
+        name: string;
+        avatar?: string;
+    }>;
+}
+export interface ChatUser {
+    id: string;
+    name: string;
+    avatar?: string;
+    initials?: string;
+}
+export interface WakaChatBubbleProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof bubbleVariants> {
+    /** The message content */
+    message: string;
+    /** Whether the message was sent by the current user */
+    isSent?: boolean;
+    /** User who sent the message */
+    sender?: ChatUser;
+    /** Show avatar */
+    showAvatar?: boolean;
+    /** Message timestamp */
+    timestamp?: Date | string;
+    /** Format for timestamp display */
+    timestampFormat?: "time" | "datetime" | "relative";
+    /** Message status */
+    status?: MessageStatus;
+    /** Read receipt status (for sent messages) */
+    readReceipt?: ReadReceiptStatus;
+    /** Reactions on the message */
+    reactions?: MessageReaction[];
+    /** Thread/reply info */
+    thread?: MessageThread;
+    /** Whether the message was edited */
+    isEdited?: boolean;
+    /** Attachments */
+    attachments?: MessageAttachment[];
+    /** Link preview */
+    linkPreview?: LinkPreview;
+    /** Enable markdown rendering */
+    markdown?: boolean;
+    /** Called when reaction is added */
+    onAddReaction?: (emoji: string) => void;
+    /** Called when existing reaction is toggled */
+    onToggleReaction?: (emoji: string) => void;
+    /** Called when reply button is clicked */
+    onReply?: () => void;
+    /** Called when edit is requested */
+    onEdit?: () => void;
+    /** Called when delete is requested */
+    onDelete?: () => void;
+    /** Called when retry is requested (for failed messages) */
+    onRetry?: () => void;
+    /** Called when thread is clicked */
+    onThreadClick?: () => void;
+    /** Called when attachment is clicked */
+    onAttachmentClick?: (attachment: MessageAttachment) => void;
+    /** Called when link preview is clicked */
+    onLinkPreviewClick?: (url: string) => void;
+    /** Show action menu */
+    showActions?: boolean;
+    /** Emoji picker content (render prop) */
+    emojiPicker?: (onSelect: (emoji: string) => void) => React.ReactNode;
+    /** Quick reaction emojis */
+    quickReactions?: string[];
+    /** Custom timestamp renderer */
+    renderTimestamp?: (timestamp: Date | string) => React.ReactNode;
+    /** Maximum width of the bubble */
+    maxWidth?: string | number;
+}
+declare const bubbleVariants: (props?: {
+    variant?: "default" | "minimal" | "elevated";
+    isSent?: boolean;
+} & import("class-variance-authority/types").ClassProp) => string;
+export declare const WakaChatBubble: React.ForwardRefExoticComponent<WakaChatBubbleProps & React.RefAttributes<HTMLDivElement>>;
+export interface WakaChatTypingIndicatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Users currently typing */
+    users?: ChatUser[];
+    /** Show avatar */
+    showAvatar?: boolean;
+}
+export declare function WakaChatTypingIndicator({ users, showAvatar, className, ...props }: WakaChatTypingIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaChatDateSeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Date to display */
+    date: Date | string;
+}
+export declare function WakaChatDateSeparator({ date, className, ...props }: WakaChatDateSeparatorProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaChatSystemMessageProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** System message text */
+    message: string;
+    /** Icon to display */
+    icon?: React.ReactNode;
+}
+export declare function WakaChatSystemMessage({ message, icon, className, ...props }: WakaChatSystemMessageProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/waka-checkout-stepper/index.d.ts

@@ -0,0 +1,154 @@
+import * as React from "react";
+import { LucideIcon } from "lucide-react";
+export type CheckoutStepId = "cart" | "shipping" | "payment" | "review" | "confirmation";
+export type CheckoutStepStatus = "pending" | "current" | "completed" | "error" | "skipped";
+export interface CheckoutStepValidation {
+    /** Whether the step is valid */
+    isValid: boolean;
+    /** Error message if invalid */
+    errorMessage?: string;
+    /** Field-level errors */
+    fieldErrors?: Record<string, string>;
+}
+export interface CheckoutStep {
+    /** Unique step identifier */
+    id: CheckoutStepId | string;
+    /** Step title */
+    title: string;
+    /** Step description */
+    description?: string;
+    /** Custom icon (optional) */
+    icon?: LucideIcon;
+    /** Step content component */
+    content?: React.ReactNode;
+    /** Whether step is optional (can be skipped) */
+    optional?: boolean;
+    /** Whether step is disabled */
+    disabled?: boolean;
+    /** Validation function for the step */
+    validate?: () => CheckoutStepValidation | Promise<CheckoutStepValidation>;
+    /** Summary data for the sidebar */
+    summary?: React.ReactNode;
+}
+export interface CheckoutStepperProps {
+    /** List of checkout steps */
+    steps: CheckoutStep[];
+    /** Current step index (0-indexed) */
+    currentStep?: number;
+    /** Callback when step changes */
+    onStepChange?: (stepIndex: number, stepId: string) => void;
+    /** Callback when checkout is completed */
+    onComplete?: () => void;
+    /** Layout orientation */
+    orientation?: "horizontal" | "vertical";
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Allow clicking on steps to navigate */
+    clickable?: boolean;
+    /** Only allow navigation to previous steps */
+    allowPreviousOnly?: boolean;
+    /** Show step content */
+    showContent?: boolean;
+    /** Show summary sidebar */
+    showSummary?: boolean;
+    /** Summary sidebar position */
+    summaryPosition?: "left" | "right";
+    /** Enable animated transitions */
+    animated?: boolean;
+    /** Animation direction */
+    animationDirection?: "slide" | "fade" | "scale";
+    /** Loading state */
+    isLoading?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Navigation labels */
+    labels?: {
+        back?: string;
+        next?: string;
+        skip?: string;
+        complete?: string;
+        processing?: string;
+    };
+}
+export interface UseCheckoutStepperOptions {
+    /** Initial step index */
+    initialStep?: number;
+    /** List of steps */
+    steps: CheckoutStep[];
+    /** Callback when step changes */
+    onStepChange?: (stepIndex: number, stepId: string) => void;
+    /** Callback when checkout completes */
+    onComplete?: () => void;
+    /** Validate before proceeding */
+    validateOnNext?: boolean;
+}
+export interface UseCheckoutStepperReturn {
+    /** Current step index */
+    currentStep: number;
+    /** Current step data */
+    currentStepData: CheckoutStep | undefined;
+    /** All steps with status */
+    stepsWithStatus: (CheckoutStep & {
+        status: CheckoutStepStatus;
+    })[];
+    /** Total number of steps */
+    totalSteps: number;
+    /** Whether on first step */
+    isFirstStep: boolean;
+    /** Whether on last step */
+    isLastStep: boolean;
+    /** Whether checkout is complete */
+    isComplete: boolean;
+    /** Whether currently validating */
+    isValidating: boolean;
+    /** Current validation error */
+    validationError: string | null;
+    /** Go to specific step */
+    goToStep: (index: number) => Promise<boolean>;
+    /** Go to next step */
+    nextStep: () => Promise<boolean>;
+    /** Go to previous step */
+    prevStep: () => void;
+    /** Skip current step (if optional) */
+    skipStep: () => void;
+    /** Complete checkout */
+    completeCheckout: () => Promise<boolean>;
+    /** Reset stepper */
+    reset: () => void;
+    /** Get step status */
+    getStepStatus: (index: number) => CheckoutStepStatus;
+    /** Skipped steps */
+    skippedSteps: Set<number>;
+    /** Mark step as completed manually */
+    markStepCompleted: (index: number) => void;
+}
+export interface CheckoutStepperContextValue extends UseCheckoutStepperReturn {
+    orientation: "horizontal" | "vertical";
+    size: "sm" | "md" | "lg";
+    clickable: boolean;
+    allowPreviousOnly: boolean;
+    animated: boolean;
+    animationDirection: "slide" | "fade" | "scale";
+    isLoading: boolean;
+}
+export declare function useCheckoutStepper({ initialStep, steps, onStepChange, onComplete, validateOnNext, }: UseCheckoutStepperOptions): UseCheckoutStepperReturn;
+export declare function useCheckoutStepperContext(): CheckoutStepperContextValue;
+export interface CheckoutNavigationProps {
+    /** Custom class name */
+    className?: string;
+    /** Custom labels */
+    labels?: {
+        back?: string;
+        next?: string;
+        skip?: string;
+        complete?: string;
+        processing?: string;
+    };
+}
+export declare function CheckoutNavigation({ className, labels, }: CheckoutNavigationProps): import("react/jsx-runtime").JSX.Element;
+export interface CheckoutProgressBarProps {
+    className?: string;
+}
+export declare function CheckoutProgressBar({ className }: CheckoutProgressBarProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaCheckoutStepper({ steps, currentStep: controlledStep, onStepChange, onComplete, orientation, size, clickable, allowPreviousOnly, showContent, showSummary, summaryPosition, animated, animationDirection, isLoading, className, labels, }: CheckoutStepperProps): import("react/jsx-runtime").JSX.Element;
+export default WakaCheckoutStepper;

package/dist/components/waka-cohort-table/index.d.ts

@@ -0,0 +1,130 @@
+import * as React from "react";
+export type CohortPeriod = "day" | "week" | "month" | "quarter" | "year";
+export type CohortMetric = "retention" | "churn" | "revenue" | "engagement" | "custom";
+export interface CohortDataPoint {
+    /** Value for this period (0-100 for percentages, or raw value) */
+    value: number;
+    /** Number of users/items at this point */
+    count?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+export interface CohortRow {
+    /** Unique identifier for the cohort */
+    id: string;
+    /** Cohort label (e.g., "Jan 2024", "Week 1") */
+    label: string;
+    /** Cohort start date */
+    date: Date;
+    /** Initial cohort size */
+    size: number;
+    /** Data points for each period */
+    data: CohortDataPoint[];
+}
+export interface CohortColorScale {
+    /** Minimum value color (e.g., for 0% retention) */
+    min: string;
+    /** Maximum value color (e.g., for 100% retention) */
+    max: string;
+    /** Optional midpoint color for gradient */
+    mid?: string;
+    /** Midpoint value (defaults to 50) */
+    midValue?: number;
+}
+export interface CohortExportOptions {
+    /** Export format */
+    format: "csv" | "json";
+    /** Include metadata in export */
+    includeMetadata?: boolean;
+    /** Custom filename */
+    filename?: string;
+}
+export interface WakaCohortTableProps {
+    /** Cohort data rows */
+    data: CohortRow[];
+    /** Period type for columns */
+    period?: CohortPeriod;
+    /** Metric being displayed */
+    metric?: CohortMetric;
+    /** Custom metric label */
+    metricLabel?: string;
+    /** Whether to show as percentage */
+    showAsPercentage?: boolean;
+    /** Number of decimal places */
+    decimalPlaces?: number;
+    /** Color scale configuration */
+    colorScale?: CohortColorScale;
+    /** Show cohort size column */
+    showCohortSize?: boolean;
+    /** Show average row */
+    showAverageRow?: boolean;
+    /** Show trend indicators */
+    showTrends?: boolean;
+    /** Enable cell hover highlighting */
+    highlightOnHover?: boolean;
+    /** Show color scale legend */
+    showLegend?: boolean;
+    /** Enable export functionality */
+    enableExport?: boolean;
+    /** Callback when cell is clicked */
+    onCellClick?: (row: CohortRow, periodIndex: number, value: CohortDataPoint) => void;
+    /** Callback when export is triggered */
+    onExport?: (options: CohortExportOptions) => void;
+    /** Custom cell renderer */
+    renderCell?: (value: CohortDataPoint, row: CohortRow, periodIndex: number) => React.ReactNode;
+    /** Custom tooltip renderer */
+    renderTooltip?: (value: CohortDataPoint, row: CohortRow, periodIndex: number) => React.ReactNode;
+    /** Custom className */
+    className?: string;
+    /** Table className */
+    tableClassName?: string;
+    /** Header cell className */
+    headerClassName?: string;
+    /** Body cell className */
+    cellClassName?: string;
+}
+export declare function WakaCohortTable({ data, period, metric, metricLabel, showAsPercentage, decimalPlaces, colorScale, showCohortSize, showAverageRow, showTrends, highlightOnHover, showLegend, enableExport, onCellClick, onExport, renderCell, renderTooltip, className, tableClassName, headerClassName, cellClassName, }: WakaCohortTableProps): import("react/jsx-runtime").JSX.Element;
+export interface UseCohortTableOptions {
+    /** Initial cohort data */
+    initialData?: CohortRow[];
+    /** Default period type */
+    defaultPeriod?: CohortPeriod;
+    /** Default metric */
+    defaultMetric?: CohortMetric;
+}
+export interface CohortStatistics {
+    /** Total number of cohorts */
+    totalCohorts: number;
+    /** Total users across all cohorts */
+    totalUsers: number;
+    /** Average initial cohort size */
+    averageCohortSize: number;
+    /** Average retention at each period */
+    averageRetentionByPeriod: number[];
+    /** Overall average retention */
+    overallAverageRetention: number;
+    /** Best performing cohort */
+    bestCohort: CohortRow | null;
+    /** Worst performing cohort */
+    worstCohort: CohortRow | null;
+}
+export declare function useCohortTable({ initialData, defaultPeriod, defaultMetric, }?: UseCohortTableOptions): {
+    data: CohortRow[];
+    period: CohortPeriod;
+    metric: CohortMetric;
+    selectedCohort: string;
+    statistics: CohortStatistics;
+    setData: React.Dispatch<React.SetStateAction<CohortRow[]>>;
+    setPeriod: React.Dispatch<React.SetStateAction<CohortPeriod>>;
+    setMetric: React.Dispatch<React.SetStateAction<CohortMetric>>;
+    setSelectedCohort: React.Dispatch<React.SetStateAction<string>>;
+    addCohort: (cohort: CohortRow) => void;
+    updateCohort: (id: string, updates: Partial<CohortRow>) => void;
+    removeCohort: (id: string) => void;
+    updateDataPoint: (cohortId: string, periodIndex: number, value: Partial<CohortDataPoint>) => void;
+    sortCohorts: (sortBy: "date" | "size" | "retention", order?: "asc" | "desc") => void;
+    filterByDateRange: (startDate: Date, endDate: Date) => CohortRow[];
+    getCohortById: (id: string) => CohortRow;
+    reset: () => void;
+};
+export default WakaCohortTable;

package/dist/components/waka-combobox/index.d.ts

@@ -0,0 +1,81 @@
+import * as React from "react";
+export interface ComboboxOption<T = string> {
+    /** Valeur unique de l'option */
+    value: T;
+    /** Libellé affiché */
+    label: string;
+    /** Description secondaire */
+    description?: string;
+    /** Icône */
+    icon?: React.ReactNode;
+    /** Désactiver l'option */
+    disabled?: boolean;
+    /** Groupe de l'option */
+    group?: string;
+}
+export interface WakaComboboxProps<T = string> {
+    /** Options disponibles */
+    options: ComboboxOption<T>[];
+    /** Valeur sélectionnée (single) ou valeurs (multiple) */
+    value?: T | T[];
+    /** Callback lors du changement */
+    onChange?: (value: T | T[] | undefined) => void;
+    /** Placeholder */
+    placeholder?: string;
+    /** Placeholder de recherche */
+    searchPlaceholder?: string;
+    /** Message si aucune option */
+    emptyMessage?: string;
+    /** Mode multiple */
+    multiple?: boolean;
+    /** Permettre la création de nouvelles options */
+    creatable?: boolean;
+    /** Callback lors de la création */
+    onCreate?: (inputValue: string) => ComboboxOption<T> | Promise<ComboboxOption<T>>;
+    /** Texte du bouton de création */
+    createLabel?: string;
+    /** Recherche asynchrone */
+    onSearch?: (query: string) => Promise<ComboboxOption<T>[]>;
+    /** Délai de debounce pour la recherche (ms) */
+    searchDebounce?: number;
+    /** Désactivé */
+    disabled?: boolean;
+    /** Erreur */
+    error?: boolean;
+    /** Chargement */
+    loading?: boolean;
+    /** Taille */
+    size?: "sm" | "md" | "lg";
+    /** Permettre de vider la sélection */
+    clearable?: boolean;
+    /** Nombre maximum de sélections (multiple) */
+    maxSelections?: number;
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** ID pour l'accessibilité */
+    id?: string;
+    /** Nom du champ */
+    name?: string;
+}
+export declare function WakaCombobox<T = string>({ options: initialOptions, value, onChange, placeholder, searchPlaceholder, emptyMessage, multiple, creatable, onCreate, createLabel, onSearch, searchDebounce, disabled, error, loading: externalLoading, size, clearable, maxSelections, className, id, name, }: WakaComboboxProps<T>): import("react/jsx-runtime").JSX.Element;
+export interface UseComboboxOptions<T = string> {
+    /** Options initiales */
+    options?: ComboboxOption<T>[];
+    /** Valeur initiale */
+    initialValue?: T | T[];
+    /** Mode multiple */
+    multiple?: boolean;
+}
+export declare function useCombobox<T = string>(options?: UseComboboxOptions<T>): {
+    value: T | T[];
+    onChange: React.Dispatch<React.SetStateAction<T | T[]>>;
+    options: ComboboxOption<T>[];
+    setOptions: React.Dispatch<React.SetStateAction<ComboboxOption<T>[]>>;
+    clear: () => void;
+    addOption: (option: ComboboxOption<T>) => void;
+    removeOption: (valueToRemove: T) => void;
+    selectAll: () => void;
+    selectNone: () => void;
+    multiple: boolean;
+};
+export default WakaCombobox;

package/dist/components/waka-command-bar/index.d.ts

@@ -0,0 +1,45 @@
+import * as React from "react";
+export interface CommandItem {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: React.ReactNode;
+    shortcut?: string[];
+    category?: string;
+    action?: () => void;
+    href?: string;
+    keywords?: string[];
+}
+export interface CommandCategory {
+    id: string;
+    label: string;
+    items: CommandItem[];
+}
+export interface WakaCommandBarProps {
+    /** Whether the command bar is open */
+    open: boolean;
+    /** Callback when open state changes */
+    onOpenChange: (open: boolean) => void;
+    /** Command items or categories */
+    items: CommandItem[] | CommandCategory[];
+    /** Placeholder text */
+    placeholder?: string;
+    /** Called when an item is selected */
+    onSelect?: (item: CommandItem) => void;
+    /** Custom empty state */
+    emptyMessage?: string;
+    /** Show recent items */
+    recentItems?: CommandItem[];
+    /** Custom footer content */
+    footer?: React.ReactNode;
+    /** Keyboard shortcut to open (default: cmd+k) */
+    shortcut?: string[];
+}
+export declare function WakaCommandBar({ open, onOpenChange, items, placeholder, onSelect, emptyMessage, recentItems, footer, shortcut, }: WakaCommandBarProps): import("react/jsx-runtime").JSX.Element;
+export declare function useCommandBar(): {
+    open: boolean;
+    onOpenChange: React.Dispatch<React.SetStateAction<boolean>>;
+    openCommandBar: () => void;
+    closeCommandBar: () => void;
+    toggleCommandBar: () => void;
+};

package/dist/components/waka-connection-matrix/index.d.ts

@@ -0,0 +1,117 @@
+import * as React from "react";
+export type ConnectionType = "http" | "grpc" | "websocket" | "database" | "queue" | "custom";
+export interface Connection {
+    /** Source service/component ID */
+    source: string;
+    /** Target service/component ID */
+    target: string;
+    /** Connection strength/frequency (0-100) */
+    weight: number;
+    /** Type of connection */
+    type: ConnectionType;
+    /** Number of requests/calls */
+    count?: number;
+    /** Average latency in ms */
+    latency?: number;
+    /** Error rate percentage */
+    errorRate?: number;
+    /** Additional metadata */
+    metadata?: Record<string, string | number>;
+}
+export interface Service {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Service category/group */
+    category?: string;
+    /** Service color for visualization */
+    color?: string;
+}
+export interface ConnectionDetails {
+    source: Service;
+    target: Service;
+    connection: Connection;
+}
+export interface ConnectionStatistics {
+    /** Total number of connections */
+    totalConnections: number;
+    /** Average connection weight */
+    averageWeight: number;
+    /** Maximum connection weight */
+    maxWeight: number;
+    /** Minimum connection weight (non-zero) */
+    minWeight: number;
+    /** Total request count */
+    totalCount: number;
+    /** Average latency */
+    averageLatency: number;
+    /** Connection density (actual/possible) */
+    density: number;
+}
+export interface WakaConnectionMatrixProps {
+    /** List of services/components */
+    services: Service[];
+    /** Connection data between services */
+    connections: Connection[];
+    /** Title for the matrix */
+    title?: string;
+    /** Show statistics panel */
+    showStatistics?: boolean;
+    /** Show filter controls */
+    showFilters?: boolean;
+    /** Color scheme for intensity */
+    colorScheme?: "blue" | "green" | "purple" | "orange" | "red";
+    /** Cell size */
+    cellSize?: "sm" | "md" | "lg";
+    /** Callback when a cell is clicked */
+    onCellClick?: (details: ConnectionDetails | null) => void;
+    /** Callback when a connection is hovered */
+    onCellHover?: (details: ConnectionDetails | null) => void;
+    /** Show connection count in cells */
+    showCounts?: boolean;
+    /** Enable sorting */
+    sortable?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export interface UseConnectionMatrixOptions {
+    /** Initial services */
+    services: Service[];
+    /** Initial connections */
+    connections: Connection[];
+    /** Initial filter types */
+    initialFilterTypes?: ConnectionType[];
+    /** Initial sort order */
+    initialSortOrder?: "name" | "connections" | "weight";
+}
+export declare function useConnectionMatrix({ services: initialServices, connections: initialConnections, initialFilterTypes, initialSortOrder, }: UseConnectionMatrixOptions): {
+    services: Service[];
+    connections: Connection[];
+    connectionMap: Map<string, Connection>;
+    statistics: ConnectionStatistics;
+    filterTypes: Set<ConnectionType>;
+    sortOrder: "name" | "weight" | "connections";
+    highlightedService: string;
+    selectedCell: {
+        source: string;
+        target: string;
+    };
+    getConnection: (sourceId: string, targetId: string) => Connection | undefined;
+    getService: (id: string) => Service | undefined;
+    toggleFilterType: (type: ConnectionType) => void;
+    setAllFilterTypes: (types: ConnectionType[]) => void;
+    setSortOrder: React.Dispatch<React.SetStateAction<"name" | "weight" | "connections">>;
+    setHighlightedService: React.Dispatch<React.SetStateAction<string>>;
+    setSelectedCell: React.Dispatch<React.SetStateAction<{
+        source: string;
+        target: string;
+    }>>;
+    updateConnections: (newConnections: Connection[]) => void;
+    updateServices: (newServices: Service[]) => void;
+    addConnection: (connection: Connection) => void;
+    removeConnection: (sourceId: string, targetId: string) => void;
+    getRelatedConnections: (serviceId: string) => Connection[];
+};
+export declare function WakaConnectionMatrix({ services, connections, title, showStatistics, showFilters, colorScheme, cellSize, onCellClick, onCellHover, showCounts, sortable, className, }: WakaConnectionMatrixProps): import("react/jsx-runtime").JSX.Element;
+export default WakaConnectionMatrix;

package/dist/components/waka-content-recommendation/index.d.ts

@@ -0,0 +1,23 @@
+export type RecommendationLayout = "grid" | "carousel" | "list";
+export interface WakaContentRecommendationProps {
+    /** Widget title */
+    title?: string;
+    /** Slot IDs for recommendations */
+    slotIds: string[];
+    /** Layout style */
+    layout?: RecommendationLayout;
+    /** Number of columns for grid layout */
+    columns?: 2 | 3 | 4;
+    /** Show navigation arrows for carousel */
+    showArrows?: boolean;
+    /** Auto-scroll carousel */
+    autoScroll?: boolean;
+    /** Auto-scroll interval (seconds) */
+    autoScrollInterval?: number;
+    /** Custom class name */
+    className?: string;
+    /** Callback when item is clicked */
+    onItemClick?: (slotId: string) => void;
+}
+export declare function WakaContentRecommendation({ title, slotIds, layout, columns, showArrows, autoScroll, autoScrollInterval, className, onItemClick, }: WakaContentRecommendationProps): import("react/jsx-runtime").JSX.Element;
+export default WakaContentRecommendation;