@wakastellar/ui 3.5.0 → 4.0.0-dev.0

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

@@ -0,0 +1,121 @@
+import * as React from "react";
+export type OrderStatus = "ordered" | "processing" | "shipped" | "out_for_delivery" | "delivered";
+export interface StatusUpdate {
+    /** Unique identifier */
+    id: string;
+    /** Status at this update */
+    status: OrderStatus;
+    /** Update message */
+    message: string;
+    /** Timestamp of the update */
+    timestamp: Date;
+    /** Location if available */
+    location?: string;
+}
+export interface DeliveryAddress {
+    /** Recipient name */
+    name: string;
+    /** Street address line 1 */
+    street1: string;
+    /** Street address line 2 (optional) */
+    street2?: string;
+    /** City */
+    city: string;
+    /** State/Province/Region */
+    state: string;
+    /** Postal/ZIP code */
+    postalCode: string;
+    /** Country */
+    country: string;
+    /** Phone number (optional) */
+    phone?: string;
+    /** Address type */
+    type?: "residential" | "business";
+}
+export interface CarrierInfo {
+    /** Carrier name (e.g., "FedEx", "UPS", "USPS") */
+    name: string;
+    /** Carrier logo URL (optional) */
+    logoUrl?: string;
+    /** Service type (e.g., "Ground", "Express", "Priority") */
+    serviceType?: string;
+    /** Tracking URL */
+    trackingUrl?: string;
+}
+export interface OrderData {
+    /** Order ID */
+    orderId: string;
+    /** Tracking number */
+    trackingNumber?: string;
+    /** Current status */
+    status: OrderStatus;
+    /** Carrier information */
+    carrier?: CarrierInfo;
+    /** Order date */
+    orderDate: Date;
+    /** Estimated delivery date */
+    estimatedDelivery?: Date;
+    /** Actual delivery date */
+    deliveredAt?: Date;
+    /** Delivery address */
+    deliveryAddress: DeliveryAddress;
+    /** Status update history */
+    updates: StatusUpdate[];
+    /** Map preview URL (optional) */
+    mapPreviewUrl?: string;
+}
+export interface WakaOrderTrackerProps {
+    /** Order data to display */
+    order: OrderData;
+    /** Layout orientation */
+    orientation?: "horizontal" | "vertical";
+    /** Show map preview section */
+    showMapPreview?: boolean;
+    /** Show status history */
+    showHistory?: boolean;
+    /** Show delivery address */
+    showAddress?: boolean;
+    /** Callback when tracking number is copied */
+    onCopyTracking?: (trackingNumber: string) => void;
+    /** Callback when carrier tracking link is clicked */
+    onTrackWithCarrier?: (url: string) => void;
+    /** Callback to refresh order data */
+    onRefresh?: () => void;
+    /** Whether refresh is in progress */
+    isRefreshing?: boolean;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface UseOrderTrackerOptions {
+    /** Initial order data */
+    initialOrder?: OrderData;
+    /** Auto-refresh interval in milliseconds */
+    autoRefreshInterval?: number;
+    /** Function to fetch order updates */
+    fetchOrderUpdates?: (orderId: string) => Promise<OrderData>;
+}
+export interface UseOrderTrackerReturn {
+    /** Current order data */
+    order: OrderData | null;
+    /** Set order data */
+    setOrder: React.Dispatch<React.SetStateAction<OrderData | null>>;
+    /** Whether data is loading */
+    isLoading: boolean;
+    /** Error message if any */
+    error: string | null;
+    /** Refresh order data */
+    refresh: () => Promise<void>;
+    /** Get current step index (0-4) */
+    currentStepIndex: number;
+    /** Check if order is delivered */
+    isDelivered: boolean;
+    /** Get progress percentage (0-100) */
+    progressPercentage: number;
+    /** Get time until estimated delivery */
+    timeUntilDelivery: string | null;
+}
+export declare function useOrderTracker(options?: UseOrderTrackerOptions): UseOrderTrackerReturn;
+export declare function WakaOrderTracker({ order, orientation, showMapPreview, showHistory, showAddress, onCopyTracking, onTrackWithCarrier, onRefresh, isRefreshing, size, className, }: WakaOrderTrackerProps): import("react/jsx-runtime").JSX.Element;
+export default WakaOrderTracker;

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

@@ -0,0 +1,24 @@
+export interface WakaOutstreamVideoProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Collapse when video ends or is closed */
+    collapseOnEnd?: boolean;
+    /** Collapse animation duration (ms) */
+    collapseDuration?: number;
+    /** Start muted */
+    muted?: boolean;
+    /** Show close button */
+    showClose?: boolean;
+    /** Close after seconds (0 = manual only) */
+    closeAfter?: number;
+    /** Minimum visibility to start playing (0-1) */
+    visibilityThreshold?: number;
+    /** Custom class name */
+    className?: string;
+    /** Callback when video completes */
+    onComplete?: () => void;
+    /** Callback when closed */
+    onClose?: () => void;
+}
+export declare function WakaOutstreamVideo({ slotId, collapseOnEnd, collapseDuration, muted, showClose, closeAfter, visibilityThreshold, className, onComplete, onClose, }: WakaOutstreamVideoProps): import("react/jsx-runtime").JSX.Element;
+export default WakaOutstreamVideo;

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

@@ -0,0 +1,67 @@
+export interface WakaPaginationProps {
+    /** Page courante (1-indexed) */
+    page: number;
+    /** Nombre total de pages */
+    totalPages: number;
+    /** Callback lors du changement de page */
+    onPageChange: (page: number) => void;
+    /** Nombre d'éléments par page */
+    pageSize?: number;
+    /** Options de taille de page */
+    pageSizeOptions?: number[];
+    /** Callback lors du changement de taille */
+    onPageSizeChange?: (size: number) => void;
+    /** Nombre total d'éléments (pour affichage) */
+    totalItems?: number;
+    /** Afficher la sélection de taille de page */
+    showPageSizeSelector?: boolean;
+    /** Afficher les infos sur les éléments */
+    showItemsInfo?: boolean;
+    /** Afficher les boutons premier/dernier */
+    showFirstLast?: boolean;
+    /** Nombre maximum de pages à afficher */
+    maxVisiblePages?: number;
+    /** Taille des boutons */
+    size?: "sm" | "md" | "lg";
+    /** Variante visuelle */
+    variant?: "default" | "outline" | "ghost";
+    /** Classes CSS additionnelles */
+    className?: string;
+    /** Labels personnalisés */
+    labels?: {
+        page?: string;
+        of?: string;
+        items?: string;
+        itemsPerPage?: string;
+        first?: string;
+        previous?: string;
+        next?: string;
+        last?: string;
+    };
+}
+export declare function WakaPagination({ page, totalPages, onPageChange, pageSize, pageSizeOptions, onPageSizeChange, totalItems, showPageSizeSelector, showItemsInfo, showFirstLast, maxVisiblePages, size, variant, className, labels, }: WakaPaginationProps): import("react/jsx-runtime").JSX.Element;
+export interface UsePaginationOptions {
+    /** Total d'éléments */
+    totalItems: number;
+    /** Taille de page initiale */
+    initialPageSize?: number;
+    /** Page initiale */
+    initialPage?: number;
+}
+export interface UsePaginationReturn {
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    setPage: (page: number) => void;
+    setPageSize: (size: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    firstPage: () => void;
+    lastPage: () => void;
+    canNextPage: boolean;
+    canPrevPage: boolean;
+    startIndex: number;
+    endIndex: number;
+}
+export declare function usePagination({ totalItems, initialPageSize, initialPage, }: UsePaginationOptions): UsePaginationReturn;
+export default WakaPagination;

package/dist/components/waka-password-strength/index.d.ts

@@ -0,0 +1,98 @@
+export type PasswordStrengthLevel = "weak" | "fair" | "good" | "strong" | "very-strong";
+export interface PasswordRequirement {
+    /** Unique key for the requirement */
+    key: string;
+    /** Label to display */
+    label: string;
+    /** Validation function */
+    validate: (password: string) => boolean;
+    /** Whether this requirement is required (default: true) */
+    required?: boolean;
+}
+export interface PasswordStrengthResult {
+    /** Strength level */
+    level: PasswordStrengthLevel;
+    /** Numeric score (0-100) */
+    score: number;
+    /** Array of met requirements */
+    metRequirements: string[];
+    /** Array of unmet requirements */
+    unmetRequirements: string[];
+    /** Whether all required criteria are met */
+    isValid: boolean;
+}
+export interface UsePasswordStrengthOptions {
+    /** Minimum password length */
+    minLength?: number;
+    /** Custom requirements to add to defaults */
+    customRequirements?: PasswordRequirement[];
+    /** Override default requirements entirely */
+    overrideRequirements?: PasswordRequirement[];
+    /** Require uppercase letter */
+    requireUppercase?: boolean;
+    /** Require lowercase letter */
+    requireLowercase?: boolean;
+    /** Require number */
+    requireNumber?: boolean;
+    /** Require special character */
+    requireSpecialChar?: boolean;
+}
+export interface WakaPasswordStrengthProps {
+    /** Password value to evaluate */
+    password: string;
+    /** Callback when password changes (when showInput is true) */
+    onPasswordChange?: (password: string) => void;
+    /** Minimum password length */
+    minLength?: number;
+    /** Show password input field */
+    showInput?: boolean;
+    /** Show password visibility toggle */
+    showToggle?: boolean;
+    /** Show strength bar */
+    showStrengthBar?: boolean;
+    /** Show checklist of requirements */
+    showChecklist?: boolean;
+    /** Show strength label */
+    showStrengthLabel?: boolean;
+    /** Animate strength bar transitions */
+    animated?: boolean;
+    /** Custom requirements */
+    customRequirements?: PasswordRequirement[];
+    /** Override default requirements */
+    overrideRequirements?: PasswordRequirement[];
+    /** Require uppercase letter */
+    requireUppercase?: boolean;
+    /** Require lowercase letter */
+    requireLowercase?: boolean;
+    /** Require number */
+    requireNumber?: boolean;
+    /** Require special character */
+    requireSpecialChar?: boolean;
+    /** Size variant */
+    size?: "sm" | "default" | "lg";
+    /** Input placeholder */
+    placeholder?: string;
+    /** Input label */
+    label?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Error message */
+    error?: string;
+    /** Additional class name */
+    className?: string;
+    /** Callback when strength changes */
+    onStrengthChange?: (result: PasswordStrengthResult) => void;
+}
+export declare function usePasswordStrength(password: string, options?: UsePasswordStrengthOptions): PasswordStrengthResult;
+export declare function WakaPasswordStrength({ password, onPasswordChange, minLength, showInput, showToggle, showStrengthBar, showChecklist, showStrengthLabel, animated, customRequirements, overrideRequirements, requireUppercase, requireLowercase, requireNumber, requireSpecialChar, size, placeholder, label, disabled, error, className, onStrengthChange, }: WakaPasswordStrengthProps): import("react/jsx-runtime").JSX.Element;
+export interface WakaPasswordStrengthIndicatorProps {
+    password: string;
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumber?: boolean;
+    requireSpecialChar?: boolean;
+    className?: string;
+}
+export declare function WakaPasswordStrengthIndicator({ password, minLength, requireUppercase, requireLowercase, requireNumber, requireSpecialChar, className, }: WakaPasswordStrengthIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export default WakaPasswordStrength;

package/dist/components/waka-payment-method-picker/index.d.ts

@@ -0,0 +1,88 @@
+import * as React from "react";
+export type PaymentMethodType = "credit_card" | "paypal" | "apple_pay" | "google_pay" | "bank_transfer";
+export type CardBrand = "visa" | "mastercard" | "amex" | "unknown";
+export interface SavedPaymentMethod {
+    /** Unique identifier */
+    id: string;
+    /** Payment method type */
+    type: PaymentMethodType;
+    /** Label for the payment method */
+    label?: string;
+    /** Last 4 digits (for cards/bank) */
+    last4?: string;
+    /** Card brand (for credit cards) */
+    brand?: CardBrand;
+    /** Expiry date (for cards) */
+    expiryDate?: string;
+    /** Whether this is the default payment method */
+    isDefault?: boolean;
+    /** Email (for PayPal) */
+    email?: string;
+    /** Bank name (for bank transfer) */
+    bankName?: string;
+}
+export interface PaymentOption {
+    /** Payment method type */
+    type: PaymentMethodType;
+    /** Display label */
+    label: string;
+    /** Description */
+    description?: string;
+    /** Whether this option is disabled */
+    disabled?: boolean;
+    /** Accepted card brands (for credit_card type) */
+    acceptedBrands?: CardBrand[];
+}
+export interface WakaPaymentMethodPickerProps {
+    /** Currently selected payment method ID or type */
+    value?: string;
+    /** Callback when selection changes */
+    onChange?: (value: string, method: SavedPaymentMethod | PaymentOption) => void;
+    /** Saved payment methods */
+    savedMethods?: SavedPaymentMethod[];
+    /** Available payment options */
+    options?: PaymentOption[];
+    /** Show "Add new" option */
+    showAddNew?: boolean;
+    /** Callback when "Add new" is clicked */
+    onAddNew?: (type: PaymentMethodType) => void;
+    /** Callback when a saved method is deleted */
+    onDelete?: (id: string) => void;
+    /** Allow deletion of saved methods */
+    allowDelete?: boolean;
+    /** Selection style */
+    variant?: "radio" | "card";
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Layout */
+    layout?: "list" | "grid";
+    /** Number of columns in grid layout */
+    columns?: 1 | 2 | 3;
+    /** Show card brand icons */
+    showBrandIcons?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Label for the picker */
+    label?: string;
+    /** Error message */
+    error?: string;
+    /** Required indicator */
+    required?: boolean;
+}
+export declare function WakaPaymentMethodPicker({ value, onChange, savedMethods, options, showAddNew, onAddNew, onDelete, allowDelete, variant, size, layout, columns, showBrandIcons, disabled, className, label, error, required, }: WakaPaymentMethodPickerProps): import("react/jsx-runtime").JSX.Element;
+export declare function WakaPaymentMethodPickerCards(props: Omit<WakaPaymentMethodPickerProps, "variant" | "layout">): import("react/jsx-runtime").JSX.Element;
+export declare function WakaPaymentMethodPickerRadio(props: Omit<WakaPaymentMethodPickerProps, "variant" | "layout">): import("react/jsx-runtime").JSX.Element;
+export declare function WakaPaymentMethodPickerCompact(props: Omit<WakaPaymentMethodPickerProps, "variant" | "size">): import("react/jsx-runtime").JSX.Element;
+export declare function usePaymentMethodPicker(savedMethods?: SavedPaymentMethod[], options?: PaymentOption[]): {
+    value: string;
+    onChange: React.Dispatch<React.SetStateAction<string>>;
+    selectedMethod: SavedPaymentMethod;
+    methods: SavedPaymentMethod[];
+    addMethod: (method: SavedPaymentMethod) => void;
+    removeMethod: (id: string) => void;
+    setDefault: (id: string) => void;
+    options: PaymentOption[];
+};
+export default WakaPaymentMethodPicker;

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

@@ -0,0 +1,197 @@
+import * as React from "react";
+export interface Permission {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Category/group ID */
+    categoryId: string;
+    /** Whether this permission is inherited from a parent role */
+    inherited?: boolean;
+    /** Parent permission ID (for inheritance display) */
+    inheritedFrom?: string;
+}
+export interface PermissionCategory {
+    /** Unique identifier */
+    id: string;
+    /** Category display name */
+    name: string;
+    /** Category description */
+    description?: string;
+    /** Category icon */
+    icon?: React.ReactNode;
+    /** Display order */
+    order?: number;
+}
+export interface Role {
+    /** Unique identifier */
+    id: string;
+    /** Role display name */
+    name: string;
+    /** Role description */
+    description?: string;
+    /** Role color for visual distinction */
+    color?: string;
+    /** Whether this role inherits from another role */
+    inheritsFrom?: string;
+    /** Display order */
+    order?: number;
+}
+export interface PermissionValue {
+    /** Role ID */
+    roleId: string;
+    /** Permission ID */
+    permissionId: string;
+    /** Whether the permission is granted */
+    granted: boolean;
+    /** Whether this value is inherited from a parent role */
+    inherited?: boolean;
+    /** Source of inheritance */
+    inheritedFrom?: string;
+}
+export type CompareMode = "none" | "highlight-diff" | "side-by-side";
+export interface PermissionMatrixState {
+    /** Current permission values */
+    values: Map<string, boolean>;
+    /** Inherited values (read-only) */
+    inheritedValues: Map<string, boolean>;
+    /** Search query */
+    searchQuery: string;
+    /** Collapsed category IDs */
+    collapsedCategories: Set<string>;
+    /** Selected roles for comparison */
+    compareRoles: string[];
+    /** Compare mode */
+    compareMode: CompareMode;
+    /** Active filters */
+    activeFilters: Set<string>;
+}
+export interface WakaPermissionMatrixProps {
+    /** Available roles */
+    roles: Role[];
+    /** Available permissions */
+    permissions: Permission[];
+    /** Permission categories/groups */
+    categories: PermissionCategory[];
+    /** Initial permission values */
+    initialValues?: PermissionValue[];
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Enable role comparison */
+    enableComparison?: boolean;
+    /** Enable bulk operations */
+    enableBulkOperations?: boolean;
+    /** Enable search/filter */
+    enableSearch?: boolean;
+    /** Show inherited permissions indicator */
+    showInheritance?: boolean;
+    /** Show category icons */
+    showCategoryIcons?: boolean;
+    /** Allow collapsing categories */
+    collapsibleCategories?: boolean;
+    /** Sticky header for roles */
+    stickyHeader?: boolean;
+    /** Cell size */
+    cellSize?: "sm" | "md" | "lg";
+    /** Callback when permission changes */
+    onPermissionChange?: (roleId: string, permissionId: string, granted: boolean) => void;
+    /** Callback when bulk operation is performed */
+    onBulkChange?: (changes: Array<{
+        roleId: string;
+        permissionId: string;
+        granted: boolean;
+    }>) => void;
+    /** Callback when values are saved */
+    onSave?: (values: PermissionValue[]) => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface UsePermissionMatrixOptions {
+    /** Initial roles */
+    roles: Role[];
+    /** Initial permissions */
+    permissions: Permission[];
+    /** Initial categories */
+    categories: PermissionCategory[];
+    /** Initial permission values */
+    initialValues?: PermissionValue[];
+    /** Callback when permission changes */
+    onPermissionChange?: (roleId: string, permissionId: string, granted: boolean) => void;
+}
+export interface UsePermissionMatrixReturn {
+    /** Current values map */
+    values: Map<string, boolean>;
+    /** Inherited values map */
+    inheritedValues: Map<string, boolean>;
+    /** Set permission value */
+    setPermission: (roleId: string, permissionId: string, granted: boolean) => void;
+    /** Get permission value (including inheritance) */
+    getPermission: (roleId: string, permissionId: string) => boolean;
+    /** Check if permission is inherited */
+    isInherited: (roleId: string, permissionId: string) => boolean;
+    /** Toggle permission */
+    togglePermission: (roleId: string, permissionId: string) => void;
+    /** Enable all permissions for a role */
+    enableAllForRole: (roleId: string) => void;
+    /** Disable all permissions for a role */
+    disableAllForRole: (roleId: string) => void;
+    /** Enable permission for all roles */
+    enableForAllRoles: (permissionId: string) => void;
+    /** Disable permission for all roles */
+    disableForAllRoles: (permissionId: string) => void;
+    /** Search query */
+    searchQuery: string;
+    /** Set search query */
+    setSearchQuery: (query: string) => void;
+    /** Collapsed categories */
+    collapsedCategories: Set<string>;
+    /** Toggle category collapse */
+    toggleCategory: (categoryId: string) => void;
+    /** Expand all categories */
+    expandAll: () => void;
+    /** Collapse all categories */
+    collapseAll: () => void;
+    /** Compare roles */
+    compareRoles: string[];
+    /** Set compare roles */
+    setCompareRoles: (roles: string[]) => void;
+    /** Add role to comparison */
+    addToComparison: (roleId: string) => void;
+    /** Remove role from comparison */
+    removeFromComparison: (roleId: string) => void;
+    /** Clear comparison */
+    clearComparison: () => void;
+    /** Compare mode */
+    compareMode: CompareMode;
+    /** Set compare mode */
+    setCompareMode: (mode: CompareMode) => void;
+    /** Filtered permissions based on search */
+    filteredPermissions: Permission[];
+    /** Grouped permissions by category */
+    groupedPermissions: Map<string, Permission[]>;
+    /** Export values as array */
+    exportValues: () => PermissionValue[];
+    /** Import values from array */
+    importValues: (values: PermissionValue[]) => void;
+    /** Reset to initial values */
+    reset: () => void;
+    /** Copy permissions from one role to another */
+    copyRolePermissions: (fromRoleId: string, toRoleId: string) => void;
+    /** Get role permission count */
+    getRolePermissionCount: (roleId: string) => {
+        granted: number;
+        total: number;
+    };
+    /** Get category permission count for role */
+    getCategoryPermissionCount: (roleId: string, categoryId: string) => {
+        granted: number;
+        total: number;
+    };
+    /** Check if roles have different permissions */
+    rolesDiffer: (roleId1: string, roleId2: string, permissionId: string) => boolean;
+}
+export declare function usePermissionMatrix({ roles, permissions, categories, initialValues, onPermissionChange, }: UsePermissionMatrixOptions): UsePermissionMatrixReturn;
+export declare function WakaPermissionMatrix({ roles, permissions, categories, initialValues, readOnly, enableComparison, enableBulkOperations, enableSearch, showInheritance, showCategoryIcons, collapsibleCategories, stickyHeader, cellSize, onPermissionChange, onBulkChange, onSave, className, }: WakaPermissionMatrixProps): import("react/jsx-runtime").JSX.Element;
+export default WakaPermissionMatrix;

package/dist/components/waka-phone-input/index.d.ts

@@ -0,0 +1,93 @@
+export interface Country {
+    code: string;
+    name: string;
+    dialCode: string;
+    flag: string;
+    format?: string;
+    priority?: number;
+}
+declare const COUNTRIES: Country[];
+export interface PhoneValue {
+    countryCode: string;
+    dialCode: string;
+    nationalNumber: string;
+    fullNumber: string;
+    isValid: boolean;
+}
+export interface WakaPhoneInputProps {
+    /** Current value */
+    value?: PhoneValue | string;
+    /** Callback when value changes */
+    onChange?: (value: PhoneValue) => void;
+    /** Default country code (ISO 3166-1 alpha-2) */
+    defaultCountry?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Error state */
+    error?: boolean;
+    /** Size variant */
+    size?: "sm" | "md" | "lg";
+    /** Show copy button */
+    showCopy?: boolean;
+    /** Show clear button */
+    showClear?: boolean;
+    /** Callback when copy is clicked */
+    onCopy?: (value: string) => void;
+    /** Country filter - only show these countries */
+    countries?: string[];
+    /** Popular countries to show at top */
+    preferredCountries?: string[];
+    /** Custom validation function */
+    validate?: (value: PhoneValue) => boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** ID for accessibility */
+    id?: string;
+    /** Name for form submission */
+    name?: string;
+    /** Required field */
+    required?: boolean;
+    /** Auto focus on mount */
+    autoFocus?: boolean;
+}
+declare function formatPhoneNumber(value: string, format?: string): string;
+declare function unformatPhoneNumber(value: string): string;
+declare function getCountryByCode(code: string): Country | undefined;
+declare function getCountryByDialCode(dialCode: string): Country | undefined;
+export interface UsePhoneInputOptions {
+    /** Initial country code */
+    initialCountry?: string;
+    /** Initial phone number */
+    initialValue?: string;
+    /** Custom validation function */
+    validate?: (value: PhoneValue) => boolean;
+}
+export interface UsePhoneInputReturn {
+    /** Current country */
+    country: Country;
+    /** Set country by code */
+    setCountry: (code: string) => void;
+    /** Current national number (without dial code) */
+    nationalNumber: string;
+    /** Set national number */
+    setNationalNumber: (value: string) => void;
+    /** Full phone value object */
+    value: PhoneValue;
+    /** Whether the phone number is valid */
+    isValid: boolean;
+    /** Format a phone number */
+    format: (value: string) => string;
+    /** Unformat a phone number (get only digits) */
+    unformat: (value: string) => string;
+    /** Clear the input */
+    clear: () => void;
+    /** Get full international number */
+    getFullNumber: () => string;
+}
+export declare function usePhoneInput(options?: UsePhoneInputOptions): UsePhoneInputReturn;
+export declare function WakaPhoneInput({ value, onChange, defaultCountry, placeholder, disabled, error, size, showCopy, showClear, onCopy, countries, preferredCountries, validate, className, id, name, required, autoFocus, }: WakaPhoneInputProps): import("react/jsx-runtime").JSX.Element;
+export { COUNTRIES };
+export { formatPhoneNumber, unformatPhoneNumber, getCountryByCode, getCountryByDialCode };
+export default WakaPhoneInput;