@wakastellar/ui 3.5.0 → 4.0.0-dev.0

package/dist/components/waka-session-manager/index.d.ts

@@ -0,0 +1,116 @@
+import * as React from "react";
+export type DeviceType = "desktop" | "mobile" | "tablet" | "unknown";
+export interface SessionLocation {
+    /** City name */
+    city?: string;
+    /** Country name or code */
+    country?: string;
+    /** Region/state */
+    region?: string;
+}
+export interface SessionDevice {
+    /** Device type */
+    type: DeviceType;
+    /** Browser name (e.g., "Chrome", "Safari", "Firefox") */
+    browser?: string;
+    /** Browser version */
+    browserVersion?: string;
+    /** Operating system (e.g., "Windows 11", "macOS", "iOS") */
+    os?: string;
+    /** OS version */
+    osVersion?: string;
+    /** Device name/model (e.g., "iPhone 15 Pro") */
+    name?: string;
+}
+export interface Session {
+    /** Unique session identifier */
+    id: string;
+    /** Device information */
+    device: SessionDevice;
+    /** Location information */
+    location?: SessionLocation;
+    /** IP address */
+    ipAddress?: string;
+    /** Last activity timestamp */
+    lastActive: Date;
+    /** Session creation timestamp */
+    createdAt?: Date;
+    /** Whether this is the current session */
+    isCurrent?: boolean;
+    /** Session status */
+    status?: "active" | "idle" | "expired";
+}
+export interface WakaSessionManagerProps {
+    /** List of sessions */
+    sessions: Session[];
+    /** Show IP addresses */
+    showIpAddress?: boolean;
+    /** Callback when a session is revoked */
+    onRevokeSession?: (sessionId: string) => Promise<void> | void;
+    /** Callback when all other sessions are revoked */
+    onRevokeAllOtherSessions?: () => Promise<void> | void;
+    /** Custom confirmation dialog component */
+    renderConfirmDialog?: (props: ConfirmDialogProps) => React.ReactNode;
+    /** Time format for last active display */
+    timeFormat?: "relative" | "absolute";
+    /** Show expanded session details by default */
+    defaultExpanded?: boolean;
+    /** Custom className */
+    className?: string;
+    /** Loading state */
+    isLoading?: boolean;
+    /** Title */
+    title?: string;
+    /** Description */
+    description?: string;
+}
+export interface ConfirmDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    title: string;
+    description: string;
+    isLoading?: boolean;
+    variant?: "danger" | "warning";
+}
+declare function DefaultConfirmDialog({ isOpen, onClose, onConfirm, title, description, isLoading, variant, }: ConfirmDialogProps): import("react/jsx-runtime").JSX.Element;
+interface SessionCardProps {
+    session: Session;
+    showIpAddress: boolean;
+    timeFormat: "relative" | "absolute";
+    onRevoke: (sessionId: string) => void;
+    isRevoking: boolean;
+    expanded: boolean;
+    onToggleExpand: () => void;
+}
+declare function SessionCard({ session, showIpAddress, timeFormat, onRevoke, isRevoking, expanded, onToggleExpand, }: SessionCardProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaSessionManager({ sessions, showIpAddress, onRevokeSession, onRevokeAllOtherSessions, renderConfirmDialog, timeFormat, defaultExpanded, className, isLoading, title, description, }: WakaSessionManagerProps): import("react/jsx-runtime").JSX.Element;
+export interface UseSessionManagerOptions {
+    /** Initial sessions */
+    initialSessions?: Session[];
+    /** Current session ID */
+    currentSessionId?: string;
+    /** Callback to fetch sessions */
+    fetchSessions?: () => Promise<Session[]>;
+    /** Callback to revoke a session */
+    revokeSession?: (sessionId: string) => Promise<void>;
+    /** Callback to revoke all other sessions */
+    revokeAllOtherSessions?: () => Promise<void>;
+    /** Auto-refresh interval in milliseconds */
+    autoRefreshInterval?: number;
+}
+export declare function useSessionManager({ initialSessions, currentSessionId, fetchSessions, revokeSession, revokeAllOtherSessions, autoRefreshInterval, }?: UseSessionManagerOptions): {
+    sessions: Session[];
+    isLoading: boolean;
+    error: Error;
+    refresh: () => Promise<void>;
+    onRevokeSession: (sessionId: string) => Promise<void>;
+    onRevokeAllOtherSessions: () => Promise<void>;
+    currentSession: Session;
+    otherSessions: Session[];
+    sessionsByDevice: Record<DeviceType, Session[]>;
+    totalSessions: number;
+    otherSessionsCount: number;
+};
+export { DefaultConfirmDialog as SessionConfirmDialog, SessionCard, };
+export default WakaSessionManager;

package/dist/components/waka-signature-pad/index.d.ts

@@ -0,0 +1,87 @@
+import * as React from "react";
+export interface Point {
+    x: number;
+    y: number;
+    pressure?: number;
+}
+export interface Stroke {
+    points: Point[];
+    color: string;
+    size: number;
+}
+export type SignatureExportFormat = "png" | "svg";
+export interface WakaSignaturePadProps {
+    /** Width of the signature pad */
+    width?: number;
+    /** Height of the signature pad */
+    height?: number;
+    /** Aspect ratio (e.g., 16/9, 4/3) - overrides height if set */
+    aspectRatio?: number;
+    /** Pen color */
+    penColor?: string;
+    /** Pen size in pixels */
+    penSize?: number;
+    /** Background color */
+    backgroundColor?: string;
+    /** Show guide line for signing */
+    showGuideLine?: boolean;
+    /** Guide line color */
+    guideLineColor?: string;
+    /** Placeholder text when empty */
+    placeholder?: string;
+    /** Placeholder text color */
+    placeholderColor?: string;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Initial signature data (base64 image or strokes) */
+    initialValue?: string | Stroke[];
+    /** Callback when signature changes */
+    onChange?: (isEmpty: boolean) => void;
+    /** Callback when signature is saved */
+    onSave?: (dataUrl: string, format: SignatureExportFormat) => void;
+    /** Show toolbar */
+    showToolbar?: boolean;
+    /** Available pen colors */
+    penColors?: string[];
+    /** Available pen sizes */
+    penSizes?: number[];
+    /** Custom class name */
+    className?: string;
+    /** Custom canvas class name */
+    canvasClassName?: string;
+    /** Custom toolbar class name */
+    toolbarClassName?: string;
+    /** Disabled state */
+    disabled?: boolean;
+}
+export interface UseSignaturePadOptions {
+    /** Initial pen color */
+    penColor?: string;
+    /** Initial pen size */
+    penSize?: number;
+    /** Callback when signature changes */
+    onChange?: (isEmpty: boolean) => void;
+}
+export interface UseSignaturePadReturn {
+    canvasRef: React.RefObject<HTMLCanvasElement>;
+    strokes: Stroke[];
+    currentStroke: Stroke | null;
+    isDrawing: boolean;
+    isEmpty: boolean;
+    penColor: string;
+    penSize: number;
+    setPenColor: (color: string) => void;
+    setPenSize: (size: number) => void;
+    clear: () => void;
+    undo: () => void;
+    toDataURL: (format?: SignatureExportFormat, backgroundColor?: string) => string;
+    toSVG: (backgroundColor?: string) => string;
+    fromDataURL: (dataUrl: string) => void;
+    fromStrokes: (strokes: Stroke[]) => void;
+    startDrawing: (point: Point) => void;
+    draw: (point: Point) => void;
+    stopDrawing: () => void;
+}
+export declare function useSignaturePad(options?: UseSignaturePadOptions): UseSignaturePadReturn;
+export declare const WakaSignaturePad: React.ForwardRefExoticComponent<WakaSignaturePadProps & React.RefAttributes<UseSignaturePadReturn>>;
+export default WakaSignaturePad;

package/dist/components/waka-skeleton-wave/index.d.ts

@@ -0,0 +1,79 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export type SkeletonPreset = "text" | "avatar" | "card" | "list" | "thumbnail" | "button";
+export interface WakaSkeletonWaveProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof skeletonVariants> {
+    /** Preset shape configuration */
+    preset?: SkeletonPreset;
+    /** Width of the skeleton (CSS value or number for px) */
+    width?: string | number;
+    /** Height of the skeleton (CSS value or number for px) */
+    height?: string | number;
+    /** Animation speed in seconds */
+    speed?: number;
+    /** Base color of the skeleton */
+    baseColor?: string;
+    /** Highlight/wave color */
+    highlightColor?: string;
+    /** Disable animation */
+    animated?: boolean;
+    /** Number of lines for text preset */
+    lines?: number;
+    /** Gap between lines in text preset */
+    lineGap?: number;
+    /** Random line widths for text preset */
+    randomWidths?: boolean;
+}
+declare const skeletonVariants: (props?: {
+    rounded?: "sm" | "md" | "lg" | "xl" | "none" | "full";
+} & import("class-variance-authority/types").ClassProp) => string;
+export declare const WakaSkeletonWave: React.ForwardRefExoticComponent<WakaSkeletonWaveProps & React.RefAttributes<HTMLDivElement>>;
+export interface WakaSkeletonTextProps extends Omit<WakaSkeletonWaveProps, "preset"> {
+    /** Number of text lines */
+    lines?: number;
+}
+export declare const WakaSkeletonText: React.ForwardRefExoticComponent<WakaSkeletonTextProps & React.RefAttributes<HTMLDivElement>>;
+export interface WakaSkeletonAvatarProps extends Omit<WakaSkeletonWaveProps, "preset" | "rounded"> {
+    /** Size of the avatar */
+    size?: "sm" | "md" | "lg" | "xl";
+}
+export declare const WakaSkeletonAvatar: React.ForwardRefExoticComponent<WakaSkeletonAvatarProps & React.RefAttributes<HTMLDivElement>>;
+export interface WakaSkeletonCardProps extends Omit<WakaSkeletonWaveProps, "preset"> {
+    /** Show header area */
+    showHeader?: boolean;
+    /** Show image area */
+    showImage?: boolean;
+    /** Show content lines */
+    contentLines?: number;
+}
+export declare const WakaSkeletonCard: React.ForwardRefExoticComponent<WakaSkeletonCardProps & React.RefAttributes<HTMLDivElement>>;
+export interface WakaSkeletonListProps extends Omit<WakaSkeletonWaveProps, "preset"> {
+    /** Number of list items */
+    items?: number;
+    /** Gap between items */
+    gap?: number;
+    /** Show avatar in each item */
+    showAvatar?: boolean;
+    /** Show action button area */
+    showAction?: boolean;
+}
+export declare const WakaSkeletonList: React.ForwardRefExoticComponent<WakaSkeletonListProps & React.RefAttributes<HTMLDivElement>>;
+export interface WakaSkeletonGridProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Number of items */
+    items?: number;
+    /** Number of columns */
+    columns?: number;
+    /** Gap between items */
+    gap?: number;
+    /** Item aspect ratio */
+    aspectRatio?: number;
+    /** Base color */
+    baseColor?: string;
+    /** Highlight color */
+    highlightColor?: string;
+    /** Animation speed */
+    speed?: number;
+    /** Enable animation */
+    animated?: boolean;
+}
+export declare const WakaSkeletonGrid: React.ForwardRefExoticComponent<WakaSkeletonGridProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/waka-skill-tree/index.d.ts

@@ -0,0 +1,78 @@
+import * as React from "react";
+export interface Skill {
+    /** Unique identifier */
+    id: string;
+    /** Skill name */
+    name: string;
+    /** Skill description */
+    description: string;
+    /** Custom icon */
+    icon?: React.ReactNode;
+    /** Whether the skill is unlocked */
+    unlocked: boolean;
+    /** Whether prerequisites are met (skill can be unlocked) */
+    available: boolean;
+    /** IDs of required prerequisite skills */
+    prerequisites?: string[];
+    /** Cost in skill points */
+    cost?: number;
+    /** Branch/category this skill belongs to */
+    branch?: string;
+    /** Position on the skill tree canvas */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Maximum level for this skill */
+    maxLevel?: number;
+    /** Current level */
+    level?: number;
+}
+export interface SkillBranch {
+    /** Unique identifier */
+    id: string;
+    /** Branch display name */
+    name: string;
+    /** Branch color (used for connections and accents) */
+    color: string;
+}
+export interface WakaSkillTreeProps {
+    /** Array of skills to display */
+    skills: Skill[];
+    /** Available skill points to spend */
+    skillPoints?: number;
+    /** Callback when a skill is unlocked */
+    onUnlock?: (skillId: string) => void;
+    /** Callback when reset button is clicked */
+    onReset?: () => void;
+    /** Skill branches/categories */
+    branches?: SkillBranch[];
+    /** Show connection lines between skills */
+    showConnections?: boolean;
+    /** Enable zoom controls */
+    zoomable?: boolean;
+    /** Enable animations */
+    animated?: boolean;
+    /** Show reset button */
+    showResetButton?: boolean;
+    /** Show category filter controls */
+    showCategoryFilters?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaSkillTree({ skills, skillPoints, onUnlock, onReset, branches, showConnections, zoomable, animated, showResetButton, showCategoryFilters, className, }: WakaSkillTreeProps): import("react/jsx-runtime").JSX.Element;
+export interface UseSkillTreeOptions {
+    initialSkills: Skill[];
+    initialPoints?: number;
+    onSkillUnlock?: (skill: Skill, remainingPoints: number) => void;
+}
+export declare function useSkillTree({ initialSkills, initialPoints, onSkillUnlock, }: UseSkillTreeOptions): {
+    skills: Skill[];
+    skillPoints: number;
+    unlockSkill: (skillId: string) => void;
+    addPoints: (points: number) => void;
+    resetSkills: () => void;
+    totalUnlocked: number;
+    totalSkills: number;
+    progress: number;
+};

package/dist/components/waka-sla-tracker/index.d.ts

@@ -0,0 +1,65 @@
+import * as React from "react";
+export type SLAPeriod = "day" | "week" | "month" | "quarter" | "year";
+export type SLATrend = "up" | "down" | "stable";
+export type SLAStatus = "healthy" | "warning" | "critical" | "breached";
+export interface SLAErrorBudget {
+    /** Error budget already used (in minutes or percentage) */
+    used: number;
+    /** Total error budget available */
+    total: number;
+}
+export interface WakaSLATrackerProps {
+    /** Current uptime percentage (e.g., 99.95) */
+    uptime: number;
+    /** SLA target percentage (e.g., 99.9) */
+    target: number;
+    /** Time period for the SLA measurement */
+    period: SLAPeriod;
+    /** Total downtime minutes in the period */
+    downtimeMinutes?: number;
+    /** Number of incidents in the period */
+    incidentCount?: number;
+    /** Error budget information */
+    errorBudget?: SLAErrorBudget;
+    /** Trend direction compared to previous period */
+    trend?: SLATrend;
+    /** Callback when period changes */
+    onPeriodChange?: (period: SLAPeriod) => void;
+    /** Visual variant */
+    variant?: "compact" | "detailed" | "card";
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function WakaSLATracker({ uptime, target, period, downtimeMinutes, incidentCount, errorBudget, trend, onPeriodChange, variant, size, className, }: WakaSLATrackerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace WakaSLATracker {
+    var displayName: string;
+}
+export interface UseSLATrackerOptions {
+    /** Initial uptime percentage */
+    initialUptime?: number;
+    /** SLA target percentage */
+    target: number;
+    /** Initial period */
+    initialPeriod?: SLAPeriod;
+    /** Callback when SLA status changes */
+    onStatusChange?: (status: SLAStatus) => void;
+    /** Callback when SLA is breached */
+    onBreach?: (uptime: number, target: number) => void;
+}
+export declare function useSLATracker({ initialUptime, target, initialPeriod, onStatusChange, onBreach, }: UseSLATrackerOptions): {
+    uptime: number;
+    target: number;
+    period: SLAPeriod;
+    status: SLAStatus;
+    trend: SLATrend;
+    downtimeMinutes: number;
+    incidentCount: number;
+    errorBudget: SLAErrorBudget;
+    setPeriod: React.Dispatch<React.SetStateAction<SLAPeriod>>;
+    setUptime: (newUptime: number) => void;
+    recordIncident: (durationMinutes: number) => void;
+    reset: () => void;
+};
+export default WakaSLATracker;

package/dist/components/waka-slider-range/index.d.ts

@@ -0,0 +1,88 @@
+export type ValueFormat = "none" | "currency" | "percentage" | "custom";
+export interface WakaSliderRangeProps {
+    /** Minimum bound of the slider */
+    min?: number;
+    /** Maximum bound of the slider */
+    max?: number;
+    /** Step increment */
+    step?: number;
+    /** Current range values [minValue, maxValue] */
+    value?: [number, number];
+    /** Default range values */
+    defaultValue?: [number, number];
+    /** Callback when values change */
+    onChange?: (value: [number, number]) => void;
+    /** Callback when dragging starts */
+    onChangeStart?: (value: [number, number]) => void;
+    /** Callback when dragging ends */
+    onChangeEnd?: (value: [number, number]) => void;
+    /** Value format type */
+    format?: ValueFormat;
+    /** Currency code for currency format */
+    currencyCode?: string;
+    /** Custom format function */
+    formatValue?: (value: number) => string;
+    /** Show value labels */
+    showLabels?: boolean;
+    /** Label position */
+    labelPosition?: "above" | "handles";
+    /** Show tooltip on drag */
+    showTooltip?: boolean;
+    /** Show tick marks */
+    showTicks?: boolean;
+    /** Custom tick values */
+    tickValues?: number[];
+    /** Tick count when tickValues not provided */
+    tickCount?: number;
+    /** Histogram data for background visualization */
+    histogram?: number[];
+    /** Histogram height in pixels */
+    histogramHeight?: number;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Color variant */
+    variant?: "default" | "primary" | "success" | "warning" | "danger";
+    /** Additional class names */
+    className?: string;
+    /** Aria label for min handle */
+    minAriaLabel?: string;
+    /** Aria label for max handle */
+    maxAriaLabel?: string;
+    /** Minimum distance between handles */
+    minDistance?: number;
+}
+export interface UseSliderRangeOptions {
+    /** Initial range values */
+    initialValue?: [number, number];
+    /** Minimum bound */
+    min?: number;
+    /** Maximum bound */
+    max?: number;
+    /** Step increment */
+    step?: number;
+    /** Minimum distance between handles */
+    minDistance?: number;
+}
+export interface UseSliderRangeReturn {
+    /** Current range values */
+    value: [number, number];
+    /** Set range values */
+    setValue: (value: [number, number]) => void;
+    /** Set minimum value */
+    setMin: (value: number) => void;
+    /** Set maximum value */
+    setMax: (value: number) => void;
+    /** Reset to initial values */
+    reset: () => void;
+    /** Min bound */
+    min: number;
+    /** Max bound */
+    max: number;
+    /** Step */
+    step: number;
+}
+export declare function useSliderRange(options?: UseSliderRangeOptions): UseSliderRangeReturn;
+export declare function WakaSliderRange({ min, max, step, value: controlledValue, defaultValue, onChange, onChangeStart, onChangeEnd, format, currencyCode, formatValue: customFormatValue, showLabels, labelPosition, showTooltip, showTicks, tickValues, tickCount, histogram, histogramHeight, disabled, size, variant, className, minAriaLabel, maxAriaLabel, minDistance, }: WakaSliderRangeProps): import("react/jsx-runtime").JSX.Element;
+export default WakaSliderRange;

package/dist/components/waka-spin-wheel/index.d.ts

@@ -0,0 +1,51 @@
+import * as React from "react";
+export interface SpinWheelSegment {
+    /** Unique identifier for the segment */
+    id: string;
+    /** Display label for the segment */
+    label: string;
+    /** Background color for the segment (hex, rgb, or CSS color) */
+    color: string;
+    /** Optional icon to display in the segment */
+    icon?: React.ReactNode;
+    /** Probability weight (higher = more likely to win) */
+    weight?: number;
+    /** Any additional data associated with this segment */
+    value?: unknown;
+}
+export interface WakaSpinWheelProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Array of wheel segments */
+    segments: SpinWheelSegment[];
+    /** Callback fired when spin starts */
+    onSpin?: () => void;
+    /** Callback fired when spin completes with the winning segment */
+    onResult?: (segment: SpinWheelSegment) => void;
+    /** Optional callback for tick sound on each segment pass */
+    onTick?: () => void;
+    /** Optional callback when wheel starts slowing down */
+    onSlowDown?: () => void;
+    /** Controlled spinning state */
+    spinning?: boolean;
+    /** Controlled result (id of winning segment) */
+    result?: string;
+    /** Duration of spin animation in milliseconds */
+    spinDuration?: number;
+    /** Number of full rotations before stopping */
+    rotations?: number;
+    /** Size of the wheel */
+    size?: number | "sm" | "md" | "lg";
+    /** Disable the spin button */
+    disabled?: boolean;
+    /** Custom content for the center button */
+    centerContent?: React.ReactNode;
+    /** Additional className for the container */
+    className?: string;
+    /** Show segment labels */
+    showLabels?: boolean;
+    /** Pointer position */
+    pointerPosition?: "top" | "right" | "bottom" | "left";
+    /** Custom pointer element */
+    customPointer?: React.ReactNode;
+}
+export declare const WakaSpinWheel: React.ForwardRefExoticComponent<WakaSpinWheelProps & React.RefAttributes<HTMLDivElement>>;
+export default WakaSpinWheel;

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

@@ -0,0 +1,46 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+/**
+ * Variantes du spinner spatial WakaSpinner
+ * Définit les différentes tailles disponibles pour l'animation
+ */
+declare const spinnerVariants: (props?: {
+    size?: "sm" | "md" | "lg" | "xl";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface WakaSpinnerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof spinnerVariants> {
+    /**
+     * Affiche les astéroïdes en arrière-plan
+     * @default true
+     */
+    showAsteroids?: boolean;
+    /**
+     * Vitesse de rotation de la fusée (en secondes)
+     * @default 2
+     */
+    speed?: number;
+    /**
+     * Couleur de la fusée (classe Tailwind ou couleur CSS)
+     * @default "text-primary"
+     */
+    rocketColor?: string;
+    /**
+     * Couleur des astéroïdes (classe Tailwind ou couleur CSS)
+     * @default "text-muted-foreground"
+     */
+    asteroidColor?: string;
+}
+/**
+ * WakaSpinner - Composant de chargement avec animation spatiale
+ *
+ * Une fusée orbite autour d'un centre avec des astéroïdes flottants optionnels.
+ * Idéal pour les écrans de chargement avec une touche ludique.
+ *
+ * @example
+ * ```tsx
+ * <WakaSpinner size="md" />
+ * <WakaSpinner size="lg" showAsteroids={true} speed={3} />
+ * <WakaSpinner rocketColor="text-blue-500" asteroidColor="text-gray-400" />
+ * ```
+ */
+export declare const WakaSpinner: React.ForwardRefExoticComponent<WakaSpinnerProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/waka-sponsored-badge/index.d.ts

@@ -0,0 +1,20 @@
+export type SponsoredBadgeVariant = "default" | "subtle" | "outline" | "dark";
+export type SponsoredBadgeSize = "sm" | "md" | "lg";
+export interface WakaSponsoredBadgeProps {
+    /** Sponsor name (optional) */
+    sponsor?: string;
+    /** Badge variant */
+    variant?: SponsoredBadgeVariant;
+    /** Badge size */
+    size?: SponsoredBadgeSize;
+    /** Show info icon */
+    showIcon?: boolean;
+    /** Custom label text */
+    label?: string;
+    /** Custom class name */
+    className?: string;
+    /** Callback when info is clicked */
+    onInfoClick?: () => void;
+}
+export declare function WakaSponsoredBadge({ sponsor, variant, size, showIcon, label, className, onInfoClick, }: WakaSponsoredBadgeProps): import("react/jsx-runtime").JSX.Element;
+export default WakaSponsoredBadge;

package/dist/components/waka-sponsored-card/index.d.ts

@@ -0,0 +1,25 @@
+export type SponsoredCardVariant = "article" | "product" | "compact" | "horizontal";
+export interface WakaSponsoredCardProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Card variant */
+    variant?: SponsoredCardVariant;
+    /** GPT ad unit path */
+    adUnitPath?: string;
+    /** Show image */
+    showImage?: boolean;
+    /** Show description */
+    showDescription?: boolean;
+    /** Show CTA button */
+    showCta?: boolean;
+    /** Image aspect ratio */
+    aspectRatio?: "video" | "square" | "portrait";
+    /** Custom class name */
+    className?: string;
+    /** Callback when clicked */
+    onClick?: () => void;
+    /** Callback when loaded */
+    onLoad?: () => void;
+}
+export declare function WakaSponsoredCard({ slotId, variant, adUnitPath, showImage, showDescription, showCta, aspectRatio, className, onClick, onLoad, }: WakaSponsoredCardProps): import("react/jsx-runtime").JSX.Element;
+export default WakaSponsoredCard;