@wakastellar/ui 3.5.0 → 4.0.0-dev.0

package/dist/components/waka-two-factor-setup/index.d.ts

@@ -0,0 +1,93 @@
+import * as React from "react";
+export type TwoFactorStep = "intro" | "qr-code" | "backup-codes" | "verify" | "success";
+export interface BackupCode {
+    code: string;
+    used: boolean;
+}
+export interface AuthenticatorApp {
+    name: string;
+    icon?: React.ReactNode;
+    iosUrl: string;
+    androidUrl: string;
+}
+export interface TwoFactorSetupConfig {
+    /** QR code data URL or base64 string */
+    qrCodeUrl?: string;
+    /** Secret key for manual entry */
+    secretKey: string;
+    /** Issuer name (app name) */
+    issuer: string;
+    /** User account identifier */
+    accountName: string;
+    /** Backup codes */
+    backupCodes: BackupCode[];
+    /** Recommended authenticator apps */
+    authenticatorApps?: AuthenticatorApp[];
+}
+export interface WakaTwoFactorSetupProps {
+    /** Configuration for 2FA setup */
+    config: TwoFactorSetupConfig;
+    /** Callback when setup is completed */
+    onComplete?: () => void;
+    /** Callback when setup is cancelled */
+    onCancel?: () => void;
+    /** Callback to verify the code */
+    onVerify: (code: string) => Promise<boolean>;
+    /** Callback to regenerate backup codes */
+    onRegenerateBackupCodes?: () => Promise<BackupCode[]>;
+    /** Callback to regenerate secret */
+    onRegenerateSecret?: () => Promise<{
+        qrCodeUrl: string;
+        secretKey: string;
+    }>;
+    /** Initial step */
+    initialStep?: TwoFactorStep;
+    /** Show step indicators */
+    showStepIndicator?: boolean;
+    /** Allow skipping backup codes step */
+    allowSkipBackupCodes?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Loading state for initial setup */
+    isLoading?: boolean;
+    /** Error message */
+    error?: string | null;
+}
+export interface UseTwoFactorSetupOptions {
+    config: TwoFactorSetupConfig;
+    onVerify: (code: string) => Promise<boolean>;
+    onRegenerateBackupCodes?: () => Promise<BackupCode[]>;
+    onRegenerateSecret?: () => Promise<{
+        qrCodeUrl: string;
+        secretKey: string;
+    }>;
+    onComplete?: () => void;
+    initialStep?: TwoFactorStep;
+}
+export interface UseTwoFactorSetupReturn {
+    currentStep: TwoFactorStep;
+    setStep: (step: TwoFactorStep) => void;
+    nextStep: () => void;
+    prevStep: () => void;
+    verificationCode: string;
+    setVerificationCode: (code: string) => void;
+    isVerifying: boolean;
+    verifyError: string | null;
+    handleVerify: () => Promise<void>;
+    secretKeyCopied: boolean;
+    copySecretKey: () => void;
+    backupCodesCopied: boolean;
+    copyBackupCodes: () => void;
+    downloadBackupCodes: () => void;
+    isRegeneratingCodes: boolean;
+    regenerateBackupCodes: () => Promise<void>;
+    isRegeneratingSecret: boolean;
+    regenerateSecret: () => Promise<void>;
+    backupCodes: BackupCode[];
+    secretKey: string;
+    qrCodeUrl: string | undefined;
+    isComplete: boolean;
+}
+export declare function useTwoFactorSetup(options: UseTwoFactorSetupOptions): UseTwoFactorSetupReturn;
+export declare function WakaTwoFactorSetup({ config, onComplete, onCancel, onVerify, onRegenerateBackupCodes, onRegenerateSecret, initialStep, showStepIndicator, allowSkipBackupCodes, className, isLoading, error: externalError, }: WakaTwoFactorSetupProps): import("react/jsx-runtime").JSX.Element;
+export default WakaTwoFactorSetup;

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

@@ -0,0 +1,98 @@
+import * as React from "react";
+export type TypewriterSpeed = "slow" | "normal" | "fast" | number;
+export interface WakaTypewriterProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /** Text strings to type (cycles through if multiple) */
+    strings: string[];
+    /** Typing speed in ms per character, or preset */
+    typeSpeed?: TypewriterSpeed;
+    /** Delete speed in ms per character, or preset */
+    deleteSpeed?: TypewriterSpeed;
+    /** Delay before starting to type in ms */
+    startDelay?: number;
+    /** Delay after finishing typing before deleting in ms */
+    pauseDelay?: number;
+    /** Delay after deleting before typing next string in ms */
+    nextDelay?: number;
+    /** Whether to loop through strings */
+    loop?: boolean;
+    /** Whether to show blinking cursor */
+    cursor?: boolean;
+    /** Custom cursor character */
+    cursorChar?: string;
+    /** Cursor blink speed in ms */
+    cursorBlinkSpeed?: number;
+    /** Characters to pause on (e.g., ".,!?") */
+    pauseOnChars?: string;
+    /** Pause duration on special characters in ms */
+    charPauseDuration?: number;
+    /** Callback when typing a string is complete */
+    onTypeComplete?: (index: number) => void;
+    /** Callback when deleting a string is complete */
+    onDeleteComplete?: (index: number) => void;
+    /** Callback when all strings have been typed (before loop) */
+    onComplete?: () => void;
+    /** Whether the typewriter is active */
+    active?: boolean;
+    /** Custom wrapper element */
+    as?: React.ElementType;
+}
+export interface UseTypewriterOptions {
+    strings: string[];
+    typeSpeed: number;
+    deleteSpeed: number;
+    startDelay: number;
+    pauseDelay: number;
+    nextDelay: number;
+    loop: boolean;
+    pauseOnChars: string;
+    charPauseDuration: number;
+    onTypeComplete?: (index: number) => void;
+    onDeleteComplete?: (index: number) => void;
+    onComplete?: () => void;
+    active: boolean;
+}
+export interface UseTypewriterReturn {
+    /** Current displayed text */
+    text: string;
+    /** Current string index */
+    currentIndex: number;
+    /** Whether currently typing (vs deleting) */
+    isTyping: boolean;
+    /** Whether typewriter is active */
+    isActive: boolean;
+    /** Restart the typewriter */
+    restart: () => void;
+    /** Pause the typewriter */
+    pause: () => void;
+    /** Resume the typewriter */
+    resume: () => void;
+    /** Skip to specific string index */
+    skipTo: (index: number) => void;
+}
+export declare function useTypewriter(options: UseTypewriterOptions): UseTypewriterReturn;
+export declare const WakaTypewriter: React.ForwardRefExoticComponent<WakaTypewriterProps & React.RefAttributes<HTMLSpanElement>>;
+export interface WakaTypewriterHeadingProps extends Omit<WakaTypewriterProps, "as"> {
+    /** Heading level (1-6) */
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+}
+export declare const WakaTypewriterHeading: React.ForwardRefExoticComponent<WakaTypewriterHeadingProps & React.RefAttributes<HTMLHeadingElement>>;
+export interface WakaTypewriterLinesProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Array of line strings */
+    lines: string[];
+    /** Delay between each line starting in ms */
+    staggerDelay?: number;
+    /** Typing speed for each line */
+    typeSpeed?: TypewriterSpeed;
+    /** Whether to show cursors */
+    cursor?: boolean;
+    /** Custom cursor character */
+    cursorChar?: string;
+    /** Only show cursor on currently typing line */
+    activeLineCursorOnly?: boolean;
+}
+export declare const WakaTypewriterLines: React.ForwardRefExoticComponent<WakaTypewriterLinesProps & React.RefAttributes<HTMLDivElement>>;
+export interface WakaTypewriterCodeProps extends Omit<WakaTypewriterProps, "as"> {
+    /** Language for potential syntax highlighting */
+    language?: string;
+}
+export declare const WakaTypewriterCode: React.ForwardRefExoticComponent<WakaTypewriterCodeProps & React.RefAttributes<HTMLElement>>;

package/dist/components/waka-typing-indicator/index.d.ts

@@ -0,0 +1,64 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+export interface TypingUser {
+    /** Unique user identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL (optional) */
+    avatar?: string;
+}
+export type TypingIndicatorVariant = "dots" | "text" | "pulse";
+export interface WakaTypingIndicatorProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof typingIndicatorVariants> {
+    /** List of users currently typing */
+    users?: TypingUser[];
+    /** Variant style of the indicator */
+    variant?: TypingIndicatorVariant;
+    /** Animation speed in milliseconds (default: 300) */
+    animationSpeed?: number;
+    /** Auto-hide timeout in milliseconds (0 to disable) */
+    autoHideTimeout?: number;
+    /** Custom text to show (overrides default text generation) */
+    customText?: string;
+    /** Show avatars of typing users */
+    showAvatars?: boolean;
+    /** Maximum number of avatars to display */
+    maxAvatars?: number;
+    /** Whether the indicator is visible */
+    visible?: boolean;
+    /** Callback when visibility changes due to auto-hide */
+    onVisibilityChange?: (visible: boolean) => void;
+}
+declare const typingIndicatorVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string;
+export declare const WakaTypingIndicator: React.ForwardRefExoticComponent<WakaTypingIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+export interface UseTypingIndicatorOptions {
+    /** Timeout for considering a user as no longer typing (ms) */
+    typingTimeout?: number;
+    /** Auto-hide the indicator after this duration (ms) */
+    autoHideTimeout?: number;
+    /** Callback when typing users change */
+    onTypingChange?: (users: TypingUser[]) => void;
+}
+export interface UseTypingIndicatorReturn {
+    /** List of currently typing users */
+    typingUsers: TypingUser[];
+    /** Whether anyone is typing */
+    isTyping: boolean;
+    /** Add a user to the typing list */
+    addTypingUser: (user: TypingUser) => void;
+    /** Remove a user from the typing list */
+    removeTypingUser: (userId: string) => void;
+    /** Update typing status for a user (resets their timeout) */
+    updateTypingStatus: (user: TypingUser) => void;
+    /** Clear all typing users */
+    clearTypingUsers: () => void;
+    /** Set the complete list of typing users */
+    setTypingUsers: React.Dispatch<React.SetStateAction<TypingUser[]>>;
+}
+export declare function useTypingIndicator(options?: UseTypingIndicatorOptions): UseTypingIndicatorReturn;
+export declare const WakaTypingIndicatorDots: React.ForwardRefExoticComponent<Omit<WakaTypingIndicatorProps, "variant"> & React.RefAttributes<HTMLDivElement>>;
+export declare const WakaTypingIndicatorText: React.ForwardRefExoticComponent<Omit<WakaTypingIndicatorProps, "variant"> & React.RefAttributes<HTMLDivElement>>;
+export declare const WakaTypingIndicatorPulse: React.ForwardRefExoticComponent<Omit<WakaTypingIndicatorProps, "variant"> & React.RefAttributes<HTMLDivElement>>;
+export default WakaTypingIndicator;

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

@@ -0,0 +1,117 @@
+import * as React from "react";
+export interface CompetitorStat {
+    /** Stat name */
+    name: string;
+    /** Stat value */
+    value: number;
+    /** Optional icon */
+    icon?: React.ReactNode;
+}
+export interface Competitor {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL */
+    avatar?: string;
+    /** Current score in the challenge */
+    score: number;
+    /** Previous score (for animations) */
+    previousScore?: number;
+    /** Additional stats to display */
+    stats?: CompetitorStat[];
+    /** Whether this is the current user */
+    isCurrentUser?: boolean;
+    /** Rank/title badge */
+    rank?: string;
+    /** Win streak */
+    winStreak?: number;
+}
+export type ChallengeType = "score" | "time" | "streak" | "collection" | "custom";
+export type ChallengeStatus = "upcoming" | "live" | "finished";
+export interface ChallengeReward {
+    /** Reward type */
+    type: "xp" | "badge" | "item" | "currency";
+    /** Reward value */
+    value: number | string;
+    /** Custom icon */
+    icon?: React.ReactNode;
+}
+export interface Challenge {
+    /** Challenge type */
+    type: ChallengeType;
+    /** Challenge name */
+    name: string;
+    /** Challenge description */
+    description?: string;
+    /** Duration in seconds (for live challenges) */
+    duration?: number;
+    /** Start time */
+    startTime?: Date;
+    /** End time */
+    endTime?: Date;
+    /** Target score/goal (if applicable) */
+    targetScore?: number;
+    /** Rewards for winner */
+    rewards: ChallengeReward[];
+}
+export interface WakaVersusCardProps {
+    /** Left competitor */
+    competitorLeft: Competitor;
+    /** Right competitor */
+    competitorRight: Competitor;
+    /** Challenge details */
+    challenge: Challenge;
+    /** Current status */
+    status: ChallengeStatus;
+    /** Winner ID (when status is 'finished') */
+    winnerId?: string;
+    /** Callback when challenge state changes */
+    onStatusChange?: (status: ChallengeStatus) => void;
+    /** Callback when a competitor's score updates */
+    onScoreUpdate?: (competitorId: string, newScore: number) => void;
+    /** Size variant */
+    size?: "sm" | "default" | "lg";
+    /** Show live pulse animation */
+    showLivePulse?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export declare function WakaVersusCard({ competitorLeft, competitorRight, challenge, status, winnerId, onStatusChange, onScoreUpdate, size, showLivePulse, className, }: WakaVersusCardProps): import("react/jsx-runtime").JSX.Element;
+export interface UseVersusCardOptions {
+    /** Initial left competitor */
+    competitorLeft: Competitor;
+    /** Initial right competitor */
+    competitorRight: Competitor;
+    /** Challenge details */
+    challenge: Challenge;
+    /** Initial status */
+    initialStatus?: ChallengeStatus;
+    /** Callback when status changes */
+    onStatusChange?: (status: ChallengeStatus) => void;
+    /** Callback when winner is determined */
+    onWinner?: (winnerId: string) => void;
+    /** Auto-determine winner when scores change */
+    autoWinner?: boolean;
+}
+export declare function useVersusCard({ competitorLeft: initialLeft, competitorRight: initialRight, challenge, initialStatus, onStatusChange, onWinner, autoWinner, }: UseVersusCardOptions): {
+    competitorLeft: Competitor;
+    competitorRight: Competitor;
+    status: ChallengeStatus;
+    winnerId: string;
+    updateScore: (competitorId: string, newScore: number) => void;
+    incrementScore: (competitorId: string, amount?: number) => void;
+    updateStatus: (newStatus: ChallengeStatus) => void;
+    declareWinner: (id: string) => void;
+    start: () => void;
+    finish: () => void;
+    reset: () => void;
+    isLive: boolean;
+    isFinished: boolean;
+    isUpcoming: boolean;
+    leftIsWinning: boolean;
+    rightIsWinning: boolean;
+    isTied: boolean;
+    scoreDifference: number;
+};
+export default WakaVersusCard;

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

@@ -0,0 +1,66 @@
+import * as React from "react";
+export interface VideoSource {
+    src: string;
+    type?: string;
+    quality?: string;
+}
+export interface WakaVideoProps {
+    /** Source(s) de la vidéo */
+    src: string | VideoSource[];
+    /** URL du poster */
+    poster?: string;
+    /** Lecture automatique */
+    autoPlay?: boolean;
+    /** Boucle */
+    loop?: boolean;
+    /** Muet */
+    muted?: boolean;
+    /** Afficher les contrôles */
+    controls?: boolean;
+    /** Précharger la vidéo */
+    preload?: "none" | "metadata" | "auto";
+    /** Largeur */
+    width?: number | string;
+    /** Hauteur */
+    height?: number | string;
+    /** Aspect ratio */
+    aspectRatio?: string;
+    /** Afficher le bouton plein écran */
+    showFullscreen?: boolean;
+    /** Afficher le sélecteur de vitesse */
+    showPlaybackSpeed?: boolean;
+    /** Afficher le sélecteur de qualité */
+    showQualitySelector?: boolean;
+    /** Vitesses de lecture disponibles */
+    playbackSpeeds?: number[];
+    /** Callback quand la vidéo est prête */
+    onReady?: () => void;
+    /** Callback lors de la lecture */
+    onPlay?: () => void;
+    /** Callback lors de la pause */
+    onPause?: () => void;
+    /** Callback quand la vidéo se termine */
+    onEnded?: () => void;
+    /** Callback lors du changement de temps */
+    onTimeUpdate?: (currentTime: number) => void;
+    /** Callback en cas d'erreur */
+    onError?: (error: Error) => void;
+    /** Classes CSS additionnelles */
+    className?: string;
+}
+export declare function WakaVideo({ src, poster, autoPlay, loop, muted, controls, preload, width, height, aspectRatio, showFullscreen, showPlaybackSpeed, showQualitySelector, playbackSpeeds, onReady, onPlay, onPause, onEnded, onTimeUpdate, onError, className, }: WakaVideoProps): import("react/jsx-runtime").JSX.Element;
+export interface UseVideoOptions {
+    autoPlay?: boolean;
+    muted?: boolean;
+}
+export declare function useVideo(options?: UseVideoOptions): {
+    isPlaying: boolean;
+    isMuted: boolean;
+    currentTime: number;
+    duration: number;
+    onPlay: () => void;
+    onPause: () => void;
+    onTimeUpdate: React.Dispatch<React.SetStateAction<number>>;
+    onReady: () => void;
+};
+export default WakaVideo;

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

@@ -0,0 +1,32 @@
+export interface WakaVideoAdProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Video width */
+    width?: number;
+    /** Video height */
+    height?: number;
+    /** Aspect ratio */
+    aspectRatio?: "16/9" | "4/3" | "1/1" | "9/16";
+    /** Autoplay when visible */
+    autoplay?: boolean;
+    /** Mute by default */
+    muted?: boolean;
+    /** Show controls */
+    showControls?: boolean;
+    /** Skip time in seconds (0 = no skip) */
+    skipAfter?: number;
+    /** Show progress bar */
+    showProgress?: boolean;
+    /** CTA overlay position */
+    ctaPosition?: "bottom" | "overlay" | "end";
+    /** Custom class name */
+    className?: string;
+    /** Callback when video completes */
+    onComplete?: () => void;
+    /** Callback when skipped */
+    onSkip?: () => void;
+    /** Callback when clicked */
+    onClick?: () => void;
+}
+export declare function WakaVideoAd({ slotId, width, height, aspectRatio, autoplay, muted, showControls, skipAfter, showProgress, ctaPosition, className, onComplete, onSkip, onClick, }: WakaVideoAdProps): import("react/jsx-runtime").JSX.Element;
+export default WakaVideoAd;

package/dist/components/waka-video-call/index.d.ts

@@ -0,0 +1,170 @@
+import * as React from "react";
+export type ConnectionQuality = "excellent" | "good" | "fair" | "poor" | "disconnected";
+export type VideoCallLayout = "grid" | "speaker" | "sidebar";
+export interface Participant {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Avatar URL */
+    avatar?: string;
+    /** Video stream (optional for demo purposes) */
+    videoStream?: MediaStream;
+    /** Audio stream (optional for demo purposes) */
+    audioStream?: MediaStream;
+    /** Is audio muted */
+    isMuted: boolean;
+    /** Is video off */
+    isVideoOff: boolean;
+    /** Is screen sharing */
+    isScreenSharing: boolean;
+    /** Has raised hand */
+    hasRaisedHand: boolean;
+    /** Is speaking */
+    isSpeaking: boolean;
+    /** Is pinned */
+    isPinned: boolean;
+    /** Is the local user */
+    isLocal?: boolean;
+    /** Connection quality */
+    connectionQuality?: ConnectionQuality;
+}
+export interface WakaVideoCallProps {
+    /** List of participants */
+    participants: Participant[];
+    /** Current user's participant ID */
+    localParticipantId: string;
+    /** Is currently recording */
+    isRecording?: boolean;
+    /** Call start time (for timer) */
+    callStartTime?: Date;
+    /** Layout mode */
+    layout?: VideoCallLayout;
+    /** Show chat panel */
+    showChat?: boolean;
+    /** Is full screen */
+    isFullscreen?: boolean;
+    /** Callbacks */
+    onToggleMute?: () => void;
+    onToggleVideo?: () => void;
+    onToggleScreenShare?: () => void;
+    onToggleChat?: () => void;
+    onEndCall?: () => void;
+    onToggleFullscreen?: () => void;
+    onTogglePictureInPicture?: () => void;
+    onRaiseHand?: () => void;
+    onChangeLayout?: (layout: VideoCallLayout) => void;
+    onPinParticipant?: (participantId: string) => void;
+    onUnpinParticipant?: (participantId: string) => void;
+    onMuteParticipant?: (participantId: string) => void;
+    onRemoveParticipant?: (participantId: string) => void;
+    /** Custom className */
+    className?: string;
+}
+export interface VideoCallState {
+    isMuted: boolean;
+    isVideoOff: boolean;
+    isScreenSharing: boolean;
+    hasRaisedHand: boolean;
+    layout: VideoCallLayout;
+    showChat: boolean;
+    isFullscreen: boolean;
+    isPictureInPicture: boolean;
+    showParticipantList: boolean;
+    showSettings: boolean;
+    pinnedParticipantId: string | null;
+    elapsedTime: number;
+}
+export interface UseVideoCallOptions {
+    initialMuted?: boolean;
+    initialVideoOff?: boolean;
+    onStateChange?: (state: VideoCallState) => void;
+}
+interface ConnectionQualityIndicatorProps {
+    quality: ConnectionQuality;
+    showLabel?: boolean;
+    size?: "sm" | "default";
+    className?: string;
+}
+declare function ConnectionQualityIndicator({ quality, showLabel, size, className, }: ConnectionQualityIndicatorProps): import("react/jsx-runtime").JSX.Element;
+interface RecordingIndicatorProps {
+    className?: string;
+}
+declare function RecordingIndicator({ className }: RecordingIndicatorProps): import("react/jsx-runtime").JSX.Element;
+interface CallTimerProps {
+    startTime?: Date;
+    className?: string;
+}
+declare function CallTimer({ startTime, className }: CallTimerProps): import("react/jsx-runtime").JSX.Element;
+interface ParticipantAvatarProps {
+    participant: Participant;
+    size?: "sm" | "default" | "lg" | "xl";
+    showStatus?: boolean;
+    className?: string;
+}
+declare function ParticipantAvatar({ participant, size, showStatus, className, }: ParticipantAvatarProps): import("react/jsx-runtime").JSX.Element;
+interface VideoTileProps {
+    participant: Participant;
+    isMain?: boolean;
+    showControls?: boolean;
+    onPin?: () => void;
+    onUnpin?: () => void;
+    onMute?: () => void;
+    onRemove?: () => void;
+    className?: string;
+}
+declare function VideoTile({ participant, isMain, showControls, onPin, onUnpin, onMute, onRemove, className, }: VideoTileProps): import("react/jsx-runtime").JSX.Element;
+interface ControlButtonProps {
+    icon: React.ElementType;
+    label: string;
+    isActive?: boolean;
+    isDestructive?: boolean;
+    onClick?: () => void;
+    disabled?: boolean;
+    className?: string;
+}
+declare function ControlButton({ icon: Icon, label, isActive, isDestructive, onClick, disabled, className, }: ControlButtonProps): import("react/jsx-runtime").JSX.Element;
+interface ParticipantsPanelProps {
+    participants: Participant[];
+    isOpen: boolean;
+    onClose: () => void;
+    className?: string;
+}
+declare function ParticipantsPanel({ participants, isOpen, onClose, className, }: ParticipantsPanelProps): import("react/jsx-runtime").JSX.Element;
+interface LayoutSelectorProps {
+    currentLayout: VideoCallLayout;
+    onLayoutChange: (layout: VideoCallLayout) => void;
+    className?: string;
+}
+declare function LayoutSelector({ currentLayout, onLayoutChange, className }: LayoutSelectorProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaVideoCall({ participants, localParticipantId, isRecording, callStartTime, layout, showChat, isFullscreen, onToggleMute, onToggleVideo, onToggleScreenShare, onToggleChat, onEndCall, onToggleFullscreen, onTogglePictureInPicture, onRaiseHand, onChangeLayout, onPinParticipant, onUnpinParticipant, onMuteParticipant, onRemoveParticipant, className, }: WakaVideoCallProps): import("react/jsx-runtime").JSX.Element;
+export declare function useVideoCall(options?: UseVideoCallOptions): {
+    callStartTime: Date;
+    isInCall: boolean;
+    startCall: () => void;
+    endCall: () => void;
+    toggleMute: () => void;
+    toggleVideo: () => void;
+    toggleScreenShare: () => void;
+    toggleRaiseHand: () => void;
+    setLayout: (layout: VideoCallLayout) => void;
+    toggleChat: () => void;
+    toggleFullscreen: () => void;
+    togglePictureInPicture: () => void;
+    toggleParticipantList: () => void;
+    pinParticipant: (participantId: string | null) => void;
+    isMuted: boolean;
+    isVideoOff: boolean;
+    isScreenSharing: boolean;
+    hasRaisedHand: boolean;
+    layout: VideoCallLayout;
+    showChat: boolean;
+    isFullscreen: boolean;
+    isPictureInPicture: boolean;
+    showParticipantList: boolean;
+    showSettings: boolean;
+    pinnedParticipantId: string | null;
+    elapsedTime: number;
+};
+export { ConnectionQualityIndicator, RecordingIndicator, CallTimer, ParticipantAvatar, VideoTile, ControlButton, ParticipantsPanel, LayoutSelector, };
+export default WakaVideoCall;

package/dist/components/waka-video-overlay/index.d.ts

@@ -0,0 +1,26 @@
+export type OverlayPosition = "bottom" | "top" | "corner";
+export type OverlayTrigger = "start" | "pause" | "time" | "manual";
+export interface WakaVideoOverlayProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Whether overlay is visible */
+    visible?: boolean;
+    /** Trigger for showing overlay */
+    trigger?: OverlayTrigger;
+    /** Time trigger (seconds from start) */
+    triggerTime?: number;
+    /** Position of overlay */
+    position?: OverlayPosition;
+    /** Allow dismissing */
+    dismissable?: boolean;
+    /** Auto-hide after seconds (0 = manual) */
+    hideAfter?: number;
+    /** Custom class name */
+    className?: string;
+    /** Callback when dismissed */
+    onDismiss?: () => void;
+    /** Callback when clicked */
+    onClick?: () => void;
+}
+export declare function WakaVideoOverlay({ slotId, visible, trigger, triggerTime, position, dismissable, hideAfter, className, onDismiss, onClick, }: WakaVideoOverlayProps): import("react/jsx-runtime").JSX.Element;
+export default WakaVideoOverlay;