@wakastellar/ui 3.5.0 → 4.0.0-dev.0

package/dist/components/waka-activity-feed/index.d.ts

@@ -0,0 +1,78 @@
+import * as React from "react";
+export type ActivityType = "achievement" | "level_up" | "purchase" | "follow" | "challenge" | "milestone";
+export interface ActivityUser {
+    /** Unique user identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL */
+    avatar?: string;
+}
+export interface Activity {
+    /** Unique activity identifier */
+    id: string;
+    /** Activity type */
+    type: ActivityType;
+    /** User who performed the activity */
+    user: ActivityUser;
+    /** Activity content/description */
+    content: string;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+    /** When the activity occurred */
+    timestamp: Date;
+    /** Number of likes */
+    likes?: number;
+    /** Whether current user liked this activity */
+    liked?: boolean;
+}
+export interface GroupedActivity extends Omit<Activity, "user"> {
+    /** Primary user */
+    user: ActivityUser;
+    /** Additional users in the group */
+    groupedUsers: ActivityUser[];
+    /** Total count of users */
+    totalUsers: number;
+}
+export interface WakaActivityFeedProps {
+    /** List of activities to display */
+    activities: Activity[];
+    /** Callback when like button is clicked */
+    onLike?: (activityId: string) => void;
+    /** Callback when load more is triggered */
+    onLoadMore?: () => void;
+    /** Whether more activities can be loaded */
+    hasMore?: boolean;
+    /** Whether activities are currently loading */
+    loading?: boolean;
+    /** Show like button and count */
+    showLikes?: boolean;
+    /** Group similar activities from multiple users */
+    groupSimilar?: boolean;
+    /** Maximum number of items to display */
+    maxItems?: number;
+    /** Enable entry animations */
+    animated?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaActivityFeed({ activities, onLike, onLoadMore, hasMore, loading, showLikes, groupSimilar, maxItems, animated, className, }: WakaActivityFeedProps): import("react/jsx-runtime").JSX.Element;
+export interface UseActivityFeedOptions {
+    /** Initial activities */
+    initialActivities?: Activity[];
+    /** Maximum activities to keep in memory */
+    maxActivities?: number;
+}
+export declare function useActivityFeed({ initialActivities, maxActivities, }?: UseActivityFeedOptions): {
+    activities: Activity[];
+    loading: boolean;
+    addActivity: (activity: Activity) => void;
+    addActivities: (newActivities: Activity[]) => void;
+    removeActivity: (activityId: string) => void;
+    toggleLike: (activityId: string) => void;
+    loadMore: (fetcher: () => Promise<Activity[]>) => Promise<void>;
+    refresh: (newActivities: Activity[]) => void;
+    clear: () => void;
+    setLoading: React.Dispatch<React.SetStateAction<boolean>>;
+};
+export default WakaActivityFeed;

package/dist/components/waka-ad-banner/index.d.ts

@@ -0,0 +1,36 @@
+import * as React from "react";
+import { type AdSize } from "../waka-ad-provider";
+export interface WakaAdBannerProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Ad size preset */
+    size?: AdSize;
+    /** Custom width (when size is "custom") */
+    customWidth?: number;
+    /** Custom height (when size is "custom") */
+    customHeight?: number;
+    /** GPT ad unit path (for GPT network) */
+    adUnitPath?: string;
+    /** Targeting parameters */
+    targeting?: Record<string, string | string[]>;
+    /** Auto-refresh interval in seconds (0 = disabled) */
+    refreshInterval?: number;
+    /** Enable lazy loading */
+    lazyLoad?: boolean;
+    /** Fallback content when no ad available */
+    fallback?: React.ReactNode;
+    /** Show sponsored badge */
+    showBadge?: boolean;
+    /** Badge position */
+    badgePosition?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    /** Custom class name */
+    className?: string;
+    /** Callback when ad loads */
+    onLoad?: () => void;
+    /** Callback when ad fails */
+    onError?: (error: Error) => void;
+    /** Callback when ad is clicked */
+    onClick?: () => void;
+}
+export declare function WakaAdBanner({ slotId, size, customWidth, customHeight, adUnitPath, targeting, refreshInterval, lazyLoad, fallback, showBadge, badgePosition, className, onLoad, onError, onClick, }: WakaAdBannerProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdBanner;

package/dist/components/waka-ad-fallback/index.d.ts

@@ -0,0 +1,33 @@
+import * as React from "react";
+import { type AdSize } from "../waka-ad-provider";
+export type AdFallbackVariant = "house" | "empty" | "custom";
+export interface WakaAdFallbackProps {
+    /** Fallback variant */
+    variant?: AdFallbackVariant;
+    /** Ad size preset */
+    size?: AdSize;
+    /** Width in pixels (overrides size) */
+    width?: number;
+    /** Height in pixels (overrides size) */
+    height?: number;
+    /** Title text */
+    title?: string;
+    /** Description text */
+    description?: string;
+    /** Call to action text */
+    ctaText?: string;
+    /** Link URL */
+    ctaUrl?: string;
+    /** Image URL */
+    imageUrl?: string;
+    /** Show border */
+    showBorder?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Callback when clicked */
+    onClick?: () => void;
+    /** Custom children for variant="custom" */
+    children?: React.ReactNode;
+}
+export declare function WakaAdFallback({ variant, size, width, height, title, description, ctaText, ctaUrl, imageUrl, showBorder, className, onClick, children, }: WakaAdFallbackProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdFallback;

package/dist/components/waka-ad-inline/index.d.ts

@@ -0,0 +1,15 @@
+import { type WakaAdBannerProps } from "../waka-ad-banner";
+export interface WakaAdInlineProps extends Omit<WakaAdBannerProps, "size"> {
+    /** Ad size - defaults to responsive */
+    size?: "responsive" | "rectangle" | "leaderboard";
+    /** Alignment within container */
+    align?: "left" | "center" | "right";
+    /** Vertical margin */
+    margin?: "none" | "sm" | "md" | "lg";
+    /** Show separator lines */
+    showSeparators?: boolean;
+    /** Label above the ad */
+    label?: string;
+}
+export declare function WakaAdInline({ slotId, size, align, margin, showSeparators, label, className, ...bannerProps }: WakaAdInlineProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdInline;

package/dist/components/waka-ad-interstitial/index.d.ts

@@ -0,0 +1,26 @@
+export interface WakaAdInterstitialProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Whether the interstitial is open */
+    open: boolean;
+    /** Callback when closed */
+    onClose: () => void;
+    /** Minimum display time before close button appears (seconds) */
+    minDisplayTime?: number;
+    /** Auto-close after duration (seconds, 0 = manual close only) */
+    autoCloseAfter?: number;
+    /** GPT ad unit path */
+    adUnitPath?: string;
+    /** Show countdown timer */
+    showCountdown?: boolean;
+    /** Skip button text */
+    skipText?: string;
+    /** Custom class name */
+    className?: string;
+    /** Callback when ad loads */
+    onLoad?: () => void;
+    /** Callback when ad is clicked */
+    onClick?: () => void;
+}
+export declare function WakaAdInterstitial({ slotId, open, onClose, minDisplayTime, autoCloseAfter, adUnitPath, showCountdown, skipText, className, onLoad, onClick, }: WakaAdInterstitialProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdInterstitial;

package/dist/components/waka-ad-placeholder/index.d.ts

@@ -0,0 +1,17 @@
+import { type AdSize } from "../waka-ad-provider";
+export interface WakaAdPlaceholderProps {
+    /** Ad size preset */
+    size?: AdSize;
+    /** Width in pixels (overrides size) */
+    width?: number;
+    /** Height in pixels (overrides size) */
+    height?: number;
+    /** Show animated skeleton */
+    animated?: boolean;
+    /** Show label text */
+    showLabel?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaAdPlaceholder({ size, width, height, animated, showLabel, className, }: WakaAdPlaceholderProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdPlaceholder;

package/dist/components/waka-ad-provider/index.d.ts

@@ -0,0 +1,103 @@
+import * as React from "react";
+export type AdNetwork = "gpt" | "custom" | "adsense";
+export type AdSize = "leaderboard" | "rectangle" | "skyscraper" | "billboard" | "mobile-banner" | "custom";
+export type AdPosition = "top" | "bottom" | "sidebar" | "inline" | "interstitial" | "sticky";
+export interface AdSlot {
+    id: string;
+    network: AdNetwork;
+    size: AdSize;
+    position: AdPosition;
+    targeting?: Record<string, string | string[]>;
+    refreshInterval?: number;
+    lazyLoad?: boolean;
+    customWidth?: number;
+    customHeight?: number;
+}
+export interface AdConfig {
+    network: AdNetwork;
+    publisherId?: string;
+    gptNetworkCode?: string;
+    gptAdUnits?: Record<string, string>;
+    customAdServer?: string;
+    customApiKey?: string;
+    enableLazyLoad?: boolean;
+    lazyLoadOffset?: number;
+    enableRefresh?: boolean;
+    defaultRefreshInterval?: number;
+    enableConsent?: boolean;
+    testMode?: boolean;
+    debugMode?: boolean;
+}
+export interface AdEvent {
+    type: "impression" | "click" | "viewable" | "error" | "loaded" | "empty";
+    slotId: string;
+    timestamp: Date;
+    data?: Record<string, unknown>;
+}
+export interface CustomAd {
+    id: string;
+    imageUrl?: string;
+    videoUrl?: string;
+    targetUrl: string;
+    title?: string;
+    description?: string;
+    sponsor?: string;
+    cta?: string;
+    trackingPixels?: string[];
+    impressionUrl?: string;
+    clickUrl?: string;
+}
+interface AdContextValue {
+    config: AdConfig;
+    isReady: boolean;
+    hasConsent: boolean | null;
+    setConsent: (consent: boolean) => void;
+    registerSlot: (slot: AdSlot) => void;
+    unregisterSlot: (slotId: string) => void;
+    refreshSlot: (slotId: string) => void;
+    refreshAll: () => void;
+    getCustomAd: (slotId: string) => Promise<CustomAd | null>;
+    trackEvent: (event: AdEvent) => void;
+    slots: Map<string, AdSlot>;
+}
+export declare const AD_SIZES: Record<AdSize, {
+    width: number;
+    height: number;
+    label: string;
+}>;
+export declare function useAdContext(): AdContextValue;
+export declare function useAdVisibility(ref: React.RefObject<HTMLElement>, threshold?: number): {
+    isVisible: boolean;
+    viewableTime: number;
+};
+export declare function useAdConsent(): {
+    hasConsent: boolean;
+    setConsent: (consent: boolean) => void;
+};
+export declare function useAdSlot(slot: AdSlot): {
+    refresh: () => void;
+    isReady: boolean;
+};
+interface WakaAdProviderProps {
+    children: React.ReactNode;
+    config: AdConfig;
+    onEvent?: (event: AdEvent) => void;
+}
+export declare function WakaAdProvider({ children, config, onEvent }: WakaAdProviderProps): import("react/jsx-runtime").JSX.Element;
+declare global {
+    interface Window {
+        googletag: {
+            cmd: Array<() => void>;
+            defineSlot: (adUnitPath: string, size: [number, number], divId: string) => unknown;
+            pubads: () => {
+                enableSingleRequest: () => void;
+                enableLazyLoad: (config: Record<string, unknown>) => void;
+                refresh: () => void;
+                setTargeting: (key: string, value: string | string[]) => void;
+            };
+            enableServices: () => void;
+            display: (divId: string) => void;
+        };
+    }
+}
+export default WakaAdProvider;

package/dist/components/waka-ad-sidebar/index.d.ts

@@ -0,0 +1,18 @@
+import { type WakaAdBannerProps } from "../waka-ad-banner";
+export interface WakaAdSidebarProps extends Omit<WakaAdBannerProps, "size"> {
+    /** Enable sticky behavior */
+    sticky?: boolean;
+    /** Top offset when sticky (in pixels) */
+    stickyOffset?: number;
+    /** Bottom boundary element selector */
+    boundarySelector?: string;
+    /** Gap between multiple ads */
+    gap?: number;
+    /** Additional ads to show below */
+    additionalSlots?: Array<{
+        slotId: string;
+        adUnitPath?: string;
+    }>;
+}
+export declare function WakaAdSidebar({ slotId, sticky, stickyOffset, boundarySelector, gap, additionalSlots, className, ...bannerProps }: WakaAdSidebarProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdSidebar;

package/dist/components/waka-ad-sticky-footer/index.d.ts

@@ -0,0 +1,17 @@
+import { type WakaAdBannerProps } from "../waka-ad-banner";
+export interface WakaAdStickyFooterProps extends Omit<WakaAdBannerProps, "size"> {
+    /** Allow user to dismiss */
+    dismissable?: boolean;
+    /** Show close button after delay (seconds) */
+    showCloseAfter?: number;
+    /** Animation style */
+    animation?: "slide" | "fade" | "none";
+    /** Safe area padding (for mobile notches) */
+    safeAreaPadding?: boolean;
+    /** Background blur */
+    blur?: boolean;
+    /** Container class name */
+    containerClassName?: string;
+}
+export declare function WakaAdStickyFooter({ slotId, dismissable, showCloseAfter, animation, safeAreaPadding, blur, className, containerClassName, ...bannerProps }: WakaAdStickyFooterProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdStickyFooter;

package/dist/components/waka-address-autocomplete/index.d.ts

@@ -0,0 +1,129 @@
+import * as React from "react";
+export interface AddressParts {
+    /** Street address (e.g., "123 Main St") */
+    street: string;
+    /** City name */
+    city: string;
+    /** State/Province/Region */
+    state?: string;
+    /** Postal/ZIP code */
+    zip: string;
+    /** Country name */
+    country: string;
+    /** Full formatted address */
+    formatted: string;
+}
+export interface AddressSuggestion {
+    /** Unique identifier */
+    id: string;
+    /** Primary address text */
+    primary: string;
+    /** Secondary text (city, state, etc.) */
+    secondary: string;
+    /** Parsed address parts */
+    parts: AddressParts;
+    /** Address type */
+    type?: "home" | "business" | "other";
+    /** Distance from user (if location available) */
+    distance?: string;
+}
+export interface RecentAddress extends AddressSuggestion {
+    /** Timestamp of last use */
+    lastUsed: Date;
+}
+export interface WakaAddressAutocompleteProps {
+    /** Selected address value */
+    value?: AddressSuggestion | null;
+    /** Callback when address is selected */
+    onChange?: (address: AddressSuggestion | null) => void;
+    /** Callback for search queries (for custom/API implementations) */
+    onSearch?: (query: string) => Promise<AddressSuggestion[]>;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Enable recent addresses feature */
+    showRecentAddresses?: boolean;
+    /** Recent addresses list */
+    recentAddresses?: RecentAddress[];
+    /** Callback when address is added to recents */
+    onAddToRecent?: (address: AddressSuggestion) => void;
+    /** Enable manual entry fallback */
+    allowManualEntry?: boolean;
+    /** Callback when manual entry is requested */
+    onManualEntry?: () => void;
+    /** Debounce delay in milliseconds */
+    debounceMs?: number;
+    /** Minimum characters before searching */
+    minChars?: number;
+    /** Maximum number of suggestions to show */
+    maxSuggestions?: number;
+    /** No results message */
+    noResultsMessage?: string;
+    /** Loading message */
+    loadingMessage?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Error state */
+    error?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Input ID for accessibility */
+    id?: string;
+    /** Input name for forms */
+    name?: string;
+    /** Label text */
+    label?: string;
+    /** Required field */
+    required?: boolean;
+    /** Auto focus on mount */
+    autoFocus?: boolean;
+}
+export interface UseAddressAutocompleteOptions {
+    /** Custom search function */
+    onSearch?: (query: string) => Promise<AddressSuggestion[]>;
+    /** Debounce delay in milliseconds */
+    debounceMs?: number;
+    /** Minimum characters before searching */
+    minChars?: number;
+    /** Maximum number of suggestions */
+    maxSuggestions?: number;
+    /** Initial recent addresses */
+    initialRecentAddresses?: RecentAddress[];
+    /** Max recent addresses to store */
+    maxRecentAddresses?: number;
+    /** Storage key for recent addresses */
+    storageKey?: string;
+}
+export interface UseAddressAutocompleteReturn {
+    /** Current search query */
+    query: string;
+    /** Set search query */
+    setQuery: (query: string) => void;
+    /** Suggestions list */
+    suggestions: AddressSuggestion[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: string | null;
+    /** Recent addresses */
+    recentAddresses: RecentAddress[];
+    /** Add address to recents */
+    addToRecent: (address: AddressSuggestion) => void;
+    /** Clear recent addresses */
+    clearRecentAddresses: () => void;
+    /** Remove specific recent address */
+    removeFromRecent: (id: string) => void;
+    /** Search function */
+    search: (query: string) => Promise<void>;
+    /** Clear suggestions */
+    clearSuggestions: () => void;
+    /** Parse address string to parts */
+    parseAddress: (addressString: string) => AddressParts;
+}
+export declare function useAddressAutocomplete(options?: UseAddressAutocompleteOptions): UseAddressAutocompleteReturn;
+/**
+ * @deprecated Since v3.6 — will be removed in v4.0.
+ * Use `WakaAutocomplete` with a Mapbox/Nominatim data-source preset instead.
+ * See `docs/audit/remove-relocate.md` §2.3.
+ */
+export declare const WakaAddressAutocomplete: React.ForwardRefExoticComponent<WakaAddressAutocompleteProps & React.RefAttributes<HTMLInputElement>>;
+export default WakaAddressAutocomplete;

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

@@ -0,0 +1,55 @@
+/**
+ * @deprecated SP1.relocates — Phase 1
+ *
+ * This surface has been relocated to `@wakastellar/ui-blocks-internal` (workspace package
+ * `packages/ui-blocks-internal`). The core `@wakastellar/ui` retains the original
+ * implementation for backward compatibility during phases 1–3 of the
+ * relocation plan; the duplicate will be removed in v4.0.
+ *
+ * Migration:
+ *   - Old: import { ... } from '@wakastellar/ui'
+ *   - New: import { ... } from '@wakastellar/ui-blocks-internal'
+ *
+ * @deprecated Moved to `@wakastellar/ui-blocks-internal` in v3.6 — core copy will be removed in v4.0.
+ */
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export interface AdmincrumbItem {
+    id: string;
+    name: string;
+    type: "partner" | "network" | "customer";
+    metadata?: Record<string, any>;
+}
+export interface AdmincrumbLevel {
+    type: "partner" | "network" | "customer";
+    items: AdmincrumbItem[];
+    selected?: AdmincrumbItem;
+    isLoading?: boolean;
+    onSelect: (item: AdmincrumbItem) => void;
+    placeholder?: string;
+    emptyText?: string;
+}
+declare const admincrumbVariants: (props?: {
+    variant?: "default" | "inline" | "compact" | "minimal" | "pills";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface WakaAdmincrumbProps extends VariantProps<typeof admincrumbVariants> {
+    levels: AdmincrumbLevel[];
+    separator?: React.ReactNode;
+    className?: string;
+    onLevelChange?: (level: number, item: AdmincrumbItem) => void;
+    showIcons?: boolean;
+    showBadges?: boolean;
+    showHome?: boolean;
+    maxWidth?: string;
+    resetable?: boolean;
+    onReset?: () => void;
+}
+export declare const WakaAdmincrumb: React.ForwardRefExoticComponent<WakaAdmincrumbProps & React.RefAttributes<HTMLDivElement>>;
+export declare function useAdmincrumb(): {
+    partner: AdmincrumbItem;
+    network: AdmincrumbItem;
+    customer: AdmincrumbItem;
+    handleLevelChange: (level: number, item: AdmincrumbItem) => void;
+    reset: () => void;
+};
+export {};

package/dist/components/waka-alert-panel/index.d.ts

@@ -0,0 +1,45 @@
+export type AlertSeverity = "critical" | "warning" | "info";
+export type AlertStatus = "firing" | "acknowledged" | "resolved" | "silenced";
+export interface Alert {
+    id: string;
+    title: string;
+    description?: string;
+    severity: AlertSeverity;
+    status: AlertStatus;
+    source: string;
+    startedAt: Date;
+    endedAt?: Date;
+    acknowledgedAt?: Date;
+    acknowledgedBy?: string;
+    silencedUntil?: Date;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    fingerprint?: string;
+    runbookUrl?: string;
+}
+export interface WakaAlertPanelProps {
+    /** List of alerts */
+    alerts: Alert[];
+    /** Callback when acknowledging an alert */
+    onAcknowledge?: (alertId: string) => void;
+    /** Callback when silencing an alert */
+    onSilence?: (alertId: string, duration: number) => void;
+    /** Callback when resolving an alert */
+    onResolve?: (alertId: string) => void;
+    /** Callback when viewing alert details */
+    onViewDetails?: (alert: Alert) => void;
+    /** Callback when clicking runbook link */
+    onRunbook?: (alert: Alert) => void;
+    /** Callback when refreshing alerts */
+    onRefresh?: () => void;
+    /** Whether alerts are loading */
+    isLoading?: boolean;
+    /** Show resolved alerts */
+    showResolved?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Title */
+    title?: string;
+}
+export declare function WakaAlertPanel({ alerts, onAcknowledge, onSilence, onResolve, onViewDetails, onRunbook, onRefresh, isLoading, showResolved, className, title, }: WakaAlertPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultAlerts: Alert[];

package/dist/components/waka-alert-stack/index.d.ts

@@ -0,0 +1,58 @@
+export type AlertSeverity = "critical" | "warning" | "info";
+export interface Alert {
+    id: string;
+    title: string;
+    description?: string;
+    severity: AlertSeverity;
+    source?: string;
+    timestamp: Date;
+    acknowledged?: boolean;
+    acknowledgedBy?: string;
+    snoozedUntil?: Date;
+    count?: number;
+}
+export interface WakaAlertStackProps {
+    /** Array of alerts to display */
+    alerts: Alert[];
+    /** Callback when an alert is acknowledged */
+    onAcknowledge?: (alertId: string) => void;
+    /** Callback when an alert is snoozed */
+    onSnooze?: (alertId: string, duration: number) => void;
+    /** Callback when an alert is dismissed */
+    onDismiss?: (alertId: string) => void;
+    /** Maximum number of visible alerts in the stack */
+    maxVisible?: number;
+    /** Whether to group similar alerts */
+    groupSimilar?: boolean;
+    /** Whether to animate entry/exit */
+    animated?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface UseSoundNotificationOptions {
+    enabled?: boolean;
+    volume?: number;
+    soundUrl?: string;
+}
+export declare function useSoundNotification(options?: UseSoundNotificationOptions): {
+    playSound: () => void;
+    isMuted: boolean;
+    toggleMute: () => void;
+};
+export interface UseAlertStackOptions {
+    onNewAlert?: (alert: Alert) => void;
+    playSoundOnCritical?: boolean;
+}
+export declare function useAlertStack(initialAlerts?: Alert[], options?: UseAlertStackOptions): {
+    alerts: Alert[];
+    activeAlerts: Alert[];
+    snoozedAlerts: Alert[];
+    addAlert: (alert: Omit<Alert, "id" | "timestamp">) => Alert;
+    acknowledgeAlert: (alertId: string, acknowledgedBy?: string) => void;
+    snoozeAlert: (alertId: string, duration: number) => void;
+    dismissAlert: (alertId: string) => void;
+    clearAcknowledged: () => void;
+    clearAll: () => void;
+};
+export declare function WakaAlertStack({ alerts, onAcknowledge, onSnooze, onDismiss, maxVisible, groupSimilar, animated, className, }: WakaAlertStackProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAlertStack;