@nice2dev/templates 1.0.10

package/dist/index.d.ts

@@ -0,0 +1,1213 @@
+import { default as default_2 } from 'react';
+import { EventEmitter } from 'events';
+
+export declare type AccountId = string;
+
+/** Account types */
+export declare type AccountType = 'checking' | 'savings' | 'credit-card' | 'investment' | 'loan' | 'mortgage' | 'cash' | 'crypto';
+
+export declare function AddTorrentDialog({ isOpen, onClose, onAdd, className, }: AddTorrentDialogProps): default_2.ReactElement | null;
+
+export declare interface AddTorrentDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onAdd: (source: string, options: {
+        path?: string;
+        paused?: boolean;
+    }) => void;
+    className?: string;
+}
+
+/** Bill */
+export declare interface Bill {
+    id: BillId;
+    name: string;
+    payee: string;
+    amount: number;
+    dueDate: number;
+    frequency: 'weekly' | 'bi-weekly' | 'monthly' | 'quarterly' | 'yearly';
+    categoryId: string;
+    accountId?: AccountId;
+    autoPay: boolean;
+    reminder: boolean;
+    reminderDays: number;
+    lastPaid?: Date;
+}
+
+export declare type BillId = string;
+
+/** Budget */
+export declare interface Budget {
+    id: BudgetId;
+    name: string;
+    categoryId: string;
+    amount: number;
+    period: 'weekly' | 'monthly' | 'yearly';
+    spent: number;
+    rollover: boolean;
+}
+
+export declare type BudgetId = string;
+
+export declare function createHealthService(): HealthService;
+
+export declare function createLifeDashboardService(): LifeDashboardService;
+
+export declare function createPersonalFinanceService(): PersonalFinanceService;
+
+export declare function createTaskManagerService(): TaskManagerService;
+
+/** Dashboard widget */
+export declare interface DashboardWidget {
+    id: string;
+    type: 'kpi' | 'goals' | 'habits' | 'mood' | 'finance' | 'calendar' | 'quote';
+    title: string;
+    size: 'small' | 'medium' | 'large';
+    position: {
+        row: number;
+        col: number;
+    };
+    config?: Record<string, unknown>;
+}
+
+/** Energy levels */
+export declare type EnergyLevel = 'low' | 'medium' | 'high';
+
+/** Workout exercise */
+export declare interface Exercise {
+    id: string;
+    name: string;
+    type: ExerciseType;
+    sets?: number;
+    reps?: number;
+    weight?: number;
+    weightUnit?: 'kg' | 'lbs';
+    duration?: number;
+    distance?: number;
+    distanceUnit?: 'km' | 'mi';
+    calories?: number;
+    notes?: string;
+}
+
+/** Exercise types */
+export declare type ExerciseType = 'cardio' | 'strength' | 'flexibility' | 'balance' | 'hiit' | 'sports' | 'other';
+
+export declare function FilterBar({ className, style }: FilterBarProps): default_2.ReactElement;
+
+export declare interface FilterBarProps {
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+declare interface FinanceContextValue {
+    service: PersonalFinanceService;
+    refresh: () => void;
+}
+
+/** Finance summary */
+export declare interface FinanceSummary {
+    netWorth: number;
+    monthlyIncome: number;
+    monthlyExpenses: number;
+    savings: number;
+    savingsRate: number;
+    debts: number;
+    investments: number;
+    budgetUsed: number;
+    budgetTotal: number;
+    categories: {
+        name: string;
+        amount: number;
+        budget: number;
+    }[];
+}
+
+/** Financial account */
+export declare interface FinancialAccount {
+    id: AccountId;
+    name: string;
+    type: AccountType;
+    institution: string;
+    balance: number;
+    currency: string;
+    lastSync?: Date;
+    accountNumber?: string;
+    color: string;
+    isHidden: boolean;
+}
+
+/** Food item */
+export declare interface FoodItem {
+    id: string;
+    name: string;
+    servingSize: number;
+    servingUnit: string;
+    calories: number;
+    protein: number;
+    carbs: number;
+    fat: number;
+    fiber?: number;
+    sugar?: number;
+    sodium?: number;
+}
+
+export declare function formatBytes(bytes: number, decimals?: number): string;
+
+export declare function formatETA(seconds?: number): string;
+
+export declare function formatRatio(ratio: number): string;
+
+export declare function formatSpeed(bytesPerSecond: number): string;
+
+export declare function getStatusColor(status: TorrentStatus, theme: TorrentUITheme): string;
+
+export declare type GoalId = string;
+
+/** Goal milestone */
+export declare interface GoalMilestone {
+    id: string;
+    title: string;
+    targetDate: Date;
+    completed: boolean;
+    completedDate?: Date;
+}
+
+/** Goal status */
+export declare type GoalStatus = 'not-started' | 'in-progress' | 'completed' | 'abandoned';
+
+/** Habit */
+export declare interface Habit {
+    id: HabitId;
+    name: string;
+    description?: string;
+    frequency: HabitFrequency;
+    customDays?: number[];
+    targetPerPeriod: number;
+    streak: number;
+    longestStreak: number;
+    category: string;
+    color: string;
+    icon?: string;
+    completions: HabitCompletion[];
+    createdAt: Date;
+}
+
+/** Habit completion */
+export declare interface HabitCompletion {
+    date: Date;
+    count: number;
+    note?: string;
+}
+
+/** Habit frequency */
+export declare type HabitFrequency = 'daily' | 'weekly' | 'monthly' | 'custom';
+
+export declare type HabitId = string;
+
+declare interface HealthContextValue {
+    service: HealthService;
+    refresh: () => void;
+}
+
+/** Health goals */
+export declare interface HealthGoal {
+    id: string;
+    type: 'weight' | 'steps' | 'calories' | 'water' | 'sleep' | 'exercise';
+    target: number;
+    unit: string;
+    period: 'daily' | 'weekly';
+    current: number;
+}
+
+export declare class HealthService {
+    private workouts;
+    private meals;
+    private sleep;
+    private medicalRecords;
+    private medications;
+    private medicationLogs;
+    private vitals;
+    private goals;
+    private foodDatabase;
+    addWorkout(workout: Omit<Workout, 'id'>): Workout;
+    updateWorkout(id: WorkoutId, updates: Partial<Workout>): void;
+    deleteWorkout(id: WorkoutId): void;
+    getAllWorkouts(): Workout[];
+    getWorkoutsForPeriod(startDate: Date, endDate: Date): Workout[];
+    getWorkoutStats(days?: number): {
+        totalWorkouts: number;
+        totalDuration: number;
+        totalCalories: number;
+        avgDuration: number;
+        byType: {
+            type: ExerciseType;
+            count: number;
+        }[];
+    };
+    addMeal(meal: Omit<Meal, 'id' | 'totalCalories' | 'totalProtein' | 'totalCarbs' | 'totalFat'>): Meal;
+    private calculateMealTotals;
+    deleteMeal(id: MealId): void;
+    getAllMeals(): Meal[];
+    getMealsForDate(date: Date): Meal[];
+    getDailyNutrition(date: Date): {
+        calories: number;
+        protein: number;
+        carbs: number;
+        fat: number;
+        meals: number;
+    };
+    searchFoods(query: string): FoodItem[];
+    addCustomFood(food: Omit<FoodItem, 'id'>): FoodItem;
+    addSleepEntry(entry: Omit<SleepEntry, 'id' | 'duration'>): SleepEntry;
+    updateSleepEntry(id: SleepId, updates: Partial<SleepEntry>): void;
+    deleteSleepEntry(id: SleepId): void;
+    getAllSleepEntries(): SleepEntry[];
+    getSleepStats(days?: number): {
+        avgDuration: number;
+        avgQuality: number;
+        totalEntries: number;
+        qualityDistribution: {
+            quality: SleepQuality;
+            count: number;
+        }[];
+    };
+    addMedicalRecord(record: Omit<MedicalRecord, 'id'>): MedicalRecord;
+    updateMedicalRecord(id: MedicalRecordId, updates: Partial<MedicalRecord>): void;
+    deleteMedicalRecord(id: MedicalRecordId): void;
+    getAllMedicalRecords(): MedicalRecord[];
+    getMedicalRecordsByType(type: MedicalRecordType): MedicalRecord[];
+    getUpcomingFollowUps(days?: number): MedicalRecord[];
+    addMedication(medication: Omit<Medication, 'id'>): Medication;
+    updateMedication(id: MedicationId, updates: Partial<Medication>): void;
+    deleteMedication(id: MedicationId): void;
+    getAllMedications(): Medication[];
+    getActiveMedications(): Medication[];
+    logMedication(medicationId: MedicationId, scheduledTime: Date, taken: boolean, notes?: string): void;
+    getMedicationLogsForDate(date: Date): MedicationLog[];
+    getTodayMedicationSchedule(): {
+        medication: Medication;
+        time: string;
+        taken: boolean;
+    }[];
+    recordVitals(vitals: VitalSigns): void;
+    getVitalsHistory(): VitalSigns[];
+    getLatestVitals(): VitalSigns | undefined;
+    getWeightHistory(days?: number): {
+        date: Date;
+        weight: number;
+    }[];
+    setGoal(goal: HealthGoal): void;
+    getGoals(): HealthGoal[];
+    updateGoalProgress(goalId: string, current: number): void;
+    private generateId;
+    clear(): void;
+}
+
+/** Torrent info hash (20-byte SHA-1 as hex string) */
+declare type InfoHash = string;
+
+/** Investment holding */
+export declare interface InvestmentHolding {
+    id: InvestmentId;
+    accountId: AccountId;
+    symbol: string;
+    name: string;
+    type: 'stock' | 'etf' | 'mutual-fund' | 'bond' | 'crypto' | 'other';
+    shares: number;
+    costBasis: number;
+    currentPrice: number;
+    currentValue: number;
+    gain: number;
+    gainPercent: number;
+}
+
+export declare type InvestmentId = string;
+
+export declare type KPIId = string;
+
+/** KPI types */
+export declare type KPIType = 'number' | 'currency' | 'percentage' | 'time' | 'rating';
+
+declare interface LifeDashboardContextValue {
+    service: LifeDashboardService;
+    refresh: () => void;
+}
+
+export declare class LifeDashboardService {
+    private kpis;
+    private goals;
+    private habits;
+    private moodEntries;
+    private financeSummary;
+    addKPI(kpi: Omit<PersonalKPI, 'id'>): PersonalKPI;
+    updateKPI(id: KPIId, updates: Partial<PersonalKPI>): void;
+    recordKPIValue(id: KPIId, value: number): void;
+    getAllKPIs(): PersonalKPI[];
+    getKPIsByCategory(category: string): PersonalKPI[];
+    calculateKPIProgress(kpi: PersonalKPI): number;
+    addGoal(goal: Omit<LifeGoal, 'id'>): LifeGoal;
+    updateGoal(id: GoalId, updates: Partial<LifeGoal>): void;
+    completeGoalMilestone(goalId: GoalId, milestoneId: string): void;
+    calculateGoalProgress(goal: LifeGoal): number;
+    getAllGoals(): LifeGoal[];
+    getActiveGoals(): LifeGoal[];
+    getGoalsByCategory(category: string): LifeGoal[];
+    getUpcomingDeadlines(days?: number): LifeGoal[];
+    addHabit(habit: Omit<Habit, 'id' | 'streak' | 'longestStreak' | 'completions' | 'createdAt'>): Habit;
+    completeHabit(id: HabitId, count?: number, note?: string): void;
+    private updateStreak;
+    getAllHabits(): Habit[];
+    getHabitCompletionRate(id: HabitId, days?: number): number;
+    getTodayHabitStatus(): {
+        habit: Habit;
+        completed: boolean;
+        count: number;
+    }[];
+    addMoodEntry(entry: Omit<MoodEntry, 'id'>): MoodEntry;
+    getAllMoodEntries(): MoodEntry[];
+    getMoodEntriesForPeriod(startDate: Date, endDate: Date): MoodEntry[];
+    getAverageMood(days?: number): number;
+    getAverageSleep(days?: number): number;
+    getMoodCorrelations(): {
+        factor: string;
+        correlation: number;
+    }[];
+    private calculateCorrelation;
+    setFinanceSummary(summary: FinanceSummary): void;
+    getFinanceSummary(): FinanceSummary;
+    calculateFinanceHealth(): {
+        score: number;
+        factors: {
+            name: string;
+            score: number;
+        }[];
+    };
+    generateDailyInsights(): string[];
+    private generateId;
+    clear(): void;
+}
+
+/** Life goal */
+export declare interface LifeGoal {
+    id: GoalId;
+    title: string;
+    description?: string;
+    category: string;
+    status: GoalStatus;
+    startDate: Date;
+    targetDate: Date;
+    completedDate?: Date;
+    progress: number;
+    milestones: GoalMilestone[];
+    parentGoalId?: GoalId;
+    tags: string[];
+}
+
+/** Meal entry */
+export declare interface Meal {
+    id: MealId;
+    date: Date;
+    type: MealType;
+    foods: {
+        item: FoodItem;
+        servings: number;
+    }[];
+    totalCalories: number;
+    totalProtein: number;
+    totalCarbs: number;
+    totalFat: number;
+    notes?: string;
+    photo?: string;
+}
+
+export declare type MealId = string;
+
+/** Meal types */
+export declare type MealType = 'breakfast' | 'lunch' | 'dinner' | 'snack';
+
+/** Medical record */
+export declare interface MedicalRecord {
+    id: MedicalRecordId;
+    date: Date;
+    type: MedicalRecordType;
+    title: string;
+    provider?: string;
+    facility?: string;
+    description?: string;
+    results?: Record<string, string | number>;
+    attachments?: string[];
+    followUp?: Date;
+}
+
+export declare type MedicalRecordId = string;
+
+/** Medical record types */
+export declare type MedicalRecordType = 'appointment' | 'lab-result' | 'vaccination' | 'prescription' | 'procedure' | 'diagnosis' | 'note';
+
+/** Medication */
+export declare interface Medication {
+    id: MedicationId;
+    name: string;
+    dosage: string;
+    frequency: string;
+    times: string[];
+    startDate: Date;
+    endDate?: Date;
+    prescribedBy?: string;
+    pharmacy?: string;
+    refillDate?: Date;
+    notes?: string;
+    isActive: boolean;
+    reminders: boolean;
+}
+
+export declare type MedicationId = string;
+
+/** Medication log */
+export declare interface MedicationLog {
+    id: string;
+    medicationId: MedicationId;
+    scheduledTime: Date;
+    takenTime?: Date;
+    skipped: boolean;
+    notes?: string;
+}
+
+/** Mood/health entry */
+export declare interface MoodEntry {
+    id: MoodEntryId;
+    date: Date;
+    mood: MoodLevel;
+    energy: EnergyLevel;
+    sleep: number;
+    stress: number;
+    notes?: string;
+    activities: string[];
+    gratitude: string[];
+    healthSymptoms: string[];
+}
+
+export declare type MoodEntryId = string;
+
+/** Mood levels */
+export declare type MoodLevel = 1 | 2 | 3 | 4 | 5;
+
+/** Net worth snapshot */
+export declare interface NetWorthSnapshot {
+    date: Date;
+    assets: number;
+    liabilities: number;
+    netWorth: number;
+}
+
+export declare function NiceHealth({ service, className, style }: NiceHealthProps): default_2.ReactElement;
+
+export declare interface NiceHealthProps {
+    service: HealthService;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceLifeDashboard({ service, className, style, }: NiceLifeDashboardProps): default_2.ReactElement;
+
+export declare interface NiceLifeDashboardProps {
+    service: LifeDashboardService;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare function NicePersonalFinance({ service, className, style, }: NicePersonalFinanceProps): default_2.ReactElement;
+
+export declare interface NicePersonalFinanceProps {
+    service: PersonalFinanceService;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+export declare function NiceTaskManager({ service, className, style, }: NiceTaskManagerProps): default_2.ReactElement;
+
+export declare interface NiceTaskManagerProps {
+    service: TaskManagerService;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+declare class NiceTorrentClient extends EventEmitter {
+    private config;
+    private peerId;
+    private torrents;
+    private dht?;
+    private pex;
+    private utp;
+    private isRunning;
+    constructor(config: TorrentClientConfig);
+    private generatePeerId;
+    private setupEventHandlers;
+    /** Start the client */
+    start(): Promise<void>;
+    /** Stop the client */
+    stop(): Promise<void>;
+    /** Add torrent from magnet URI or .torrent file */
+    addTorrent(source: string | Buffer, options?: {
+        path?: string;
+        paused?: boolean;
+    }): Promise<TorrentInstance>;
+    private parseMagnetURI;
+    private parseTorrentFile;
+    /** Start downloading a torrent */
+    startTorrent(infoHash: InfoHash): Promise<void>;
+    /** Pause a torrent */
+    pauseTorrent(infoHash: InfoHash): Promise<void>;
+    /** Remove a torrent */
+    removeTorrent(infoHash: InfoHash, options?: {
+        deleteFiles?: boolean;
+    }): Promise<void>;
+    private announceToTrackers;
+    private httpAnnounce;
+    private addPeer;
+    private connectToPeer;
+    private disconnectPeer;
+    private handlePeerData;
+    /** Get torrent by info hash */
+    getTorrent(infoHash: InfoHash): TorrentInstance | undefined;
+    /** Get all torrents */
+    getAllTorrents(): TorrentInstance[];
+    /** Get client statistics */
+    getStats(): {
+        activeTorrents: number;
+        totalDownloadSpeed: number;
+        totalUploadSpeed: number;
+        dhtNodes: number;
+        globalPeers: number;
+    };
+    /** Set global download speed limit */
+    setDownloadLimit(bytesPerSecond: number): void;
+    /** Set global upload speed limit */
+    setUploadLimit(bytesPerSecond: number): void;
+    /** Generate .torrent file from directory */
+    createTorrent(sourcePath: string, options?: {
+        name?: string;
+        trackers?: string[][];
+        comment?: string;
+        isPrivate?: boolean;
+        pieceLength?: number;
+    }): Promise<Buffer>;
+}
+
+export declare function NiceTorrentUI({ client, config, className, style, }: NiceTorrentUIProps): default_2.ReactElement;
+
+export declare interface NiceTorrentUIProps {
+    client: NiceTorrentClient;
+    config?: TorrentUIConfig;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/** Peer identifier */
+declare type PeerId = string;
+
+/** Peer connection state */
+declare interface PeerState {
+    id: PeerId;
+    ip: string;
+    port: number;
+    client: string;
+    progress: number;
+    downloadSpeed: number;
+    uploadSpeed: number;
+    flags: string;
+    source: 'tracker' | 'dht' | 'pex' | 'lsd' | 'manual';
+    isEncrypted: boolean;
+    isUTP: boolean;
+}
+
+export declare class PersonalFinanceService {
+    private accounts;
+    private transactions;
+    private budgets;
+    private bills;
+    private investments;
+    private categories;
+    private netWorthHistory;
+    addAccount(account: Omit<FinancialAccount, 'id'>): FinancialAccount;
+    updateAccount(id: AccountId, updates: Partial<FinancialAccount>): void;
+    deleteAccount(id: AccountId): void;
+    getAllAccounts(): FinancialAccount[];
+    getAccountsByType(type: AccountType): FinancialAccount[];
+    calculateTotalAssets(): number;
+    calculateTotalLiabilities(): number;
+    calculateNetWorth(): number;
+    recordNetWorthSnapshot(): void;
+    getNetWorthHistory(): NetWorthSnapshot[];
+    addTransaction(transaction: Omit<Transaction, 'id'>): Transaction;
+    updateTransaction(id: TransactionId, updates: Partial<Transaction>): void;
+    deleteTransaction(id: TransactionId): void;
+    getAllTransactions(): Transaction[];
+    getTransactionsForAccount(accountId: AccountId): Transaction[];
+    getTransactionsForPeriod(startDate: Date, endDate: Date): Transaction[];
+    getTransactionsByCategory(categoryId: string): Transaction[];
+    /** Auto-categorize transaction based on description */
+    autoCategorize(description: string): string | undefined;
+    getAllCategories(): TransactionCategory[];
+    getTopLevelCategories(): TransactionCategory[];
+    getSubCategories(parentId: string): TransactionCategory[];
+    addCategory(category: TransactionCategory): void;
+    addBudget(budget: Omit<Budget, 'id' | 'spent'>): Budget;
+    updateBudget(id: BudgetId, updates: Partial<Budget>): void;
+    deleteBudget(id: BudgetId): void;
+    getAllBudgets(): Budget[];
+    getBudgetByCategory(categoryId: string): Budget | undefined;
+    resetBudgetSpending(): void;
+    calculateBudgetStatus(): {
+        total: number;
+        used: number;
+        remaining: number;
+        overBudget: Budget[];
+    };
+    addBill(bill: Omit<Bill, 'id'>): Bill;
+    updateBill(id: BillId, updates: Partial<Bill>): void;
+    deleteBill(id: BillId): void;
+    markBillPaid(id: BillId): void;
+    getAllBills(): Bill[];
+    getUpcomingBills(days?: number): Bill[];
+    calculateMonthlyBillTotal(): number;
+    addInvestment(investment: Omit<InvestmentHolding, 'id' | 'currentValue' | 'gain' | 'gainPercent'>): InvestmentHolding;
+    updateInvestmentPrice(id: InvestmentId, price: number): void;
+    deleteInvestment(id: InvestmentId): void;
+    getAllInvestments(): InvestmentHolding[];
+    getInvestmentsByAccount(accountId: AccountId): InvestmentHolding[];
+    calculateTotalInvestmentValue(): number;
+    calculateTotalGain(): number;
+    getPortfolioAllocation(): {
+        type: string;
+        value: number;
+        percentage: number;
+    }[];
+    getSpendingSummary(startDate: Date, endDate: Date): SpendingSummary[];
+    getMonthlyIncome(): number;
+    getMonthlyExpenses(): number;
+    getSavingsRate(): number;
+    private generateId;
+    clear(): void;
+    /**
+     * Export all data to JSON
+     */
+    exportData(): string;
+}
+
+/** Personal KPI */
+export declare interface PersonalKPI {
+    id: KPIId;
+    name: string;
+    description?: string;
+    type: KPIType;
+    currentValue: number;
+    targetValue: number;
+    unit?: string;
+    trend: 'up' | 'down' | 'stable';
+    category: string;
+    color?: string;
+    history: {
+        date: Date;
+        value: number;
+    }[];
+}
+
+export declare interface PriorityMatrix {
+    doFirst: PriorityMatrixQuadrant;
+    schedule: PriorityMatrixQuadrant;
+    delegate: PriorityMatrixQuadrant;
+    eliminate: PriorityMatrixQuadrant;
+}
+
+export declare interface PriorityMatrixQuadrant {
+    name: string;
+    description: string;
+    tasks: Task[];
+}
+
+export declare function ProgressBar({ progress, status, showLabel, height, className, style, }: ProgressBarProps): default_2.ReactElement;
+
+export declare interface ProgressBarProps {
+    progress: number;
+    status: TorrentStatus;
+    showLabel?: boolean;
+    height?: string;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/** Project */
+export declare interface Project {
+    id: ProjectId;
+    name: string;
+    description?: string;
+    color: string;
+    icon?: string;
+    isActive: boolean;
+    isFavorite: boolean;
+    order: number;
+    createdAt: Date;
+}
+
+export declare type ProjectId = string;
+
+/** Recurrence pattern */
+export declare type RecurrencePattern = 'daily' | 'weekdays' | 'weekly' | 'bi-weekly' | 'monthly' | 'yearly' | 'custom';
+
+/** Recurrence settings */
+export declare interface RecurrenceSettings {
+    pattern: RecurrencePattern;
+    interval: number;
+    endDate?: Date;
+    endAfterOccurrences?: number;
+    daysOfWeek?: number[];
+    dayOfMonth?: number;
+}
+
+/** Sleep entry */
+export declare interface SleepEntry {
+    id: SleepId;
+    date: Date;
+    bedtime: Date;
+    wakeTime: Date;
+    duration: number;
+    quality: SleepQuality;
+    deepSleep?: number;
+    remSleep?: number;
+    lightSleep?: number;
+    awakenings?: number;
+    notes?: string;
+    factors?: string[];
+}
+
+export declare type SleepId = string;
+
+/** Sleep quality */
+export declare type SleepQuality = 'poor' | 'fair' | 'good' | 'excellent';
+
+/** Spending summary */
+export declare interface SpendingSummary {
+    categoryId: string;
+    categoryName: string;
+    amount: number;
+    percentage: number;
+    transactions: number;
+    trend: 'up' | 'down' | 'stable';
+}
+
+export declare function StatusBadge({ status, className, style }: StatusBadgeProps): default_2.ReactElement;
+
+export declare interface StatusBadgeProps {
+    status: TorrentStatus;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/** Tag */
+export declare interface Tag {
+    id: TagId;
+    name: string;
+    color: string;
+}
+
+export declare type TagId = string;
+
+/** Task */
+export declare interface Task {
+    id: TaskId;
+    title: string;
+    description?: string;
+    status: TaskStatus;
+    priority: TaskPriority;
+    projectId?: ProjectId;
+    parentTaskId?: TaskId;
+    tags: TagId[];
+    dueDate?: Date;
+    scheduledDate?: Date;
+    completedDate?: Date;
+    estimatedMinutes?: number;
+    actualMinutes?: number;
+    recurrence?: RecurrenceSettings;
+    timeBlocks: TimeBlock[];
+    subtasks: Task[];
+    notes: string;
+    attachments: string[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+/** Filter settings */
+export declare interface TaskFilter {
+    status?: TaskStatus[];
+    priority?: TaskPriority[];
+    projectId?: ProjectId | null;
+    tags?: TagId[];
+    dueDateRange?: {
+        start?: Date;
+        end?: Date;
+    };
+    search?: string;
+}
+
+export declare type TaskId = string;
+
+declare interface TaskManagerContextValue {
+    service: TaskManagerService;
+    refresh: () => void;
+}
+
+export declare class TaskManagerService {
+    private tasks;
+    private projects;
+    private tags;
+    private timeBlocks;
+    addTask(task: Omit<Task, 'id' | 'createdAt' | 'updatedAt' | 'subtasks'>): Task;
+    updateTask(id: TaskId, updates: Partial<Omit<Task, 'id' | 'createdAt'>>): void;
+    deleteTask(id: TaskId): void;
+    getTask(id: TaskId): Task | undefined;
+    getAllTasks(): Task[];
+    /** Quick add task from text with natural language parsing */
+    quickAddTask(text: string): Task;
+    private parseQuickAdd;
+    /** Complete a task */
+    completeTask(id: TaskId): void;
+    private createRecurringTask;
+    private calculateNextRecurrence;
+    filterTasks(filter: TaskFilter): Task[];
+    sortTasks(tasks: Task[], field?: TaskSortField, direction?: TaskSortDirection): Task[];
+    getInbox(): Task[];
+    getToday(): Task[];
+    getUpcoming(days?: number): Task[];
+    getOverdue(): Task[];
+    getPriorityMatrix(): PriorityMatrix;
+    addTimeBlock(block: Omit<TimeBlock, 'id'>): TimeBlock;
+    updateTimeBlock(id: string, updates: Partial<TimeBlock>): void;
+    deleteTimeBlock(id: string): void;
+    getTimeBlocksForDate(date: Date): TimeBlock[];
+    addProject(project: Omit<Project, 'id' | 'createdAt' | 'order'>): Project;
+    updateProject(id: ProjectId, updates: Partial<Project>): void;
+    deleteProject(id: ProjectId): void;
+    getAllProjects(): Project[];
+    getProjectTasks(projectId: ProjectId): Task[];
+    getProjectProgress(projectId: ProjectId): {
+        total: number;
+        completed: number;
+        percentage: number;
+    };
+    addTag(tag: Omit<Tag, 'id'>): Tag;
+    deleteTag(id: TagId): void;
+    getAllTags(): Tag[];
+    getStatistics(): {
+        total: number;
+        completed: number;
+        overdue: number;
+        dueToday: number;
+        inProgress: number;
+        completionRate: number;
+    };
+    private generateId;
+    clear(): void;
+}
+
+/** Task priority */
+export declare type TaskPriority = 'urgent' | 'high' | 'medium' | 'low' | 'none';
+
+export declare type TaskSortDirection = 'asc' | 'desc';
+
+/** Sort options */
+export declare type TaskSortField = 'dueDate' | 'priority' | 'createdAt' | 'title' | 'status';
+
+/** Task status */
+export declare type TaskStatus = 'inbox' | 'todo' | 'in-progress' | 'waiting' | 'done' | 'cancelled';
+
+/** Time block */
+export declare interface TimeBlock {
+    id: string;
+    taskId?: TaskId;
+    title: string;
+    start: Date;
+    end: Date;
+    color?: string;
+    isBlocked: boolean;
+}
+
+declare interface TorrentClientConfig {
+    /** Client identifier */
+    peerId?: PeerId;
+    /** Download directory */
+    downloadPath: string;
+    /** Maximum download speed (bytes/sec, 0 = unlimited) */
+    maxDownloadSpeed?: number;
+    /** Maximum upload speed (bytes/sec, 0 = unlimited) */
+    maxUploadSpeed?: number;
+    /** Maximum concurrent torrents */
+    maxConcurrentTorrents?: number;
+    /** Maximum peers per torrent */
+    maxPeersPerTorrent?: number;
+    /** Maximum global connections */
+    maxGlobalConnections?: number;
+    /** Enable DHT (Distributed Hash Table) */
+    enableDHT?: boolean;
+    /** Enable PEX (Peer Exchange) */
+    enablePEX?: boolean;
+    /** Enable µTP (Micro Transport Protocol) */
+    enableUTP?: boolean;
+    /** Enable LSD (Local Service Discovery) */
+    enableLSD?: boolean;
+    /** Listen port range */
+    portRange?: [number, number];
+    /** Enable encryption */
+    enableEncryption?: boolean;
+    /** Require encryption */
+    requireEncryption?: boolean;
+    /** Seed ratio limit (0 = unlimited) */
+    seedRatioLimit?: number;
+    /** Seed time limit (seconds, 0 = unlimited) */
+    seedTimeLimit?: number;
+    /** Enable web seeds */
+    enableWebSeeds?: boolean;
+    /** Temporary directory for incomplete files */
+    tempPath?: string;
+    /** Pre-allocate files */
+    preAllocateFiles?: boolean;
+    /** Verify on completion */
+    verifyOnComplete?: boolean;
+}
+
+export declare interface TorrentColumnConfig {
+    id: string;
+    label: string;
+    width?: string;
+    sortable?: boolean;
+    visible?: boolean;
+}
+
+export declare function TorrentDetails({ infoHash, className, style, }: TorrentDetailsProps): default_2.ReactElement | null;
+
+export declare interface TorrentDetailsProps {
+    infoHash: InfoHash;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/** File within a torrent */
+declare interface TorrentFile {
+    path: string;
+    name: string;
+    size: number;
+    offset: number;
+    priority: 'skip' | 'low' | 'normal' | 'high';
+    progress: number;
+}
+
+export declare type TorrentFilter = 'all' | 'downloading' | 'seeding' | 'paused' | 'checking' | 'error' | 'completed' | 'active';
+
+/** Torrent instance */
+declare interface TorrentInstance {
+    metadata: TorrentMetadata;
+    status: TorrentStatus;
+    stats: TorrentStats;
+    peers: PeerState[];
+    trackers: TrackerState[];
+    files: TorrentFile[];
+    path: string;
+    addedAt: Date;
+    completedAt?: Date;
+    error?: string;
+}
+
+export declare function TorrentList({ onTorrentSelect, onTorrentDoubleClick, className, style, }: TorrentListProps): default_2.ReactElement;
+
+export declare interface TorrentListProps {
+    onTorrentSelect?: (hash: InfoHash) => void;
+    onTorrentDoubleClick?: (hash: InfoHash) => void;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/** Torrent file/magnet metadata */
+declare interface TorrentMetadata {
+    name: string;
+    infoHash: InfoHash;
+    size: number;
+    pieceLength: number;
+    pieceCount: number;
+    files: TorrentFile[];
+    comment?: string;
+    createdBy?: string;
+    createdAt?: Date;
+    isPrivate: boolean;
+    trackers: string[][];
+    magnetURI: string;
+}
+
+/** Torrent statistics */
+declare interface TorrentStats {
+    progress: number;
+    downloaded: number;
+    uploaded: number;
+    downloadSpeed: number;
+    uploadSpeed: number;
+    peers: number;
+    seeds: number;
+    leechers: number;
+    ratio: number;
+    eta?: number;
+    availability: number;
+    piecesComplete: number;
+    piecesTotal: number;
+    wastedBytes: number;
+    hashFailures: number;
+}
+
+/** Torrent status */
+declare type TorrentStatus = 'checking' | 'downloading' | 'seeding' | 'paused' | 'queued' | 'error';
+
+export declare interface TorrentUIConfig {
+    theme?: Partial<TorrentUITheme>;
+    locale?: string;
+    dateFormat?: string;
+    speedUnit?: 'auto' | 'B' | 'KB' | 'MB';
+    showCategories?: boolean;
+    showLabels?: boolean;
+    columns?: TorrentColumnConfig[];
+    refreshInterval?: number;
+    confirmBeforeDelete?: boolean;
+    defaultSortBy?: keyof TorrentInstance | keyof TorrentStats;
+    defaultSortOrder?: 'asc' | 'desc';
+}
+
+declare interface TorrentUIContextValue {
+    client: NiceTorrentClient | null;
+    config: TorrentUIConfig;
+    theme: TorrentUITheme;
+    torrents: TorrentInstance[];
+    selectedTorrent: InfoHash | null;
+    setSelectedTorrent: (hash: InfoHash | null) => void;
+    filter: TorrentFilter;
+    setFilter: (filter: TorrentFilter) => void;
+    searchQuery: string;
+    setSearchQuery: (query: string) => void;
+    refresh: () => void;
+}
+
+export declare function TorrentUIProvider({ client, config, children, }: TorrentUIProviderProps): default_2.ReactElement;
+
+export declare interface TorrentUIProviderProps {
+    client: NiceTorrentClient;
+    config?: TorrentUIConfig;
+    children: default_2.ReactNode;
+}
+
+export declare interface TorrentUITheme {
+    colors: {
+        background: string;
+        surface: string;
+        primary: string;
+        secondary: string;
+        success: string;
+        warning: string;
+        error: string;
+        text: string;
+        textSecondary: string;
+        border: string;
+    };
+    spacing: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+    borderRadius: string;
+    fontFamily: string;
+}
+
+/** Tracker state */
+declare interface TrackerState {
+    url: string;
+    status: 'idle' | 'working' | 'updating' | 'error';
+    peers: number;
+    seeds: number;
+    leechers: number;
+    lastAnnounce?: Date;
+    nextAnnounce?: Date;
+    errorMessage?: string;
+}
+
+/** Transaction */
+export declare interface Transaction {
+    id: TransactionId;
+    accountId: AccountId;
+    date: Date;
+    type: TransactionType;
+    amount: number;
+    description: string;
+    categoryId?: string;
+    merchant?: string;
+    notes?: string;
+    tags: string[];
+    isRecurring: boolean;
+    transferToAccountId?: AccountId;
+    cleared: boolean;
+}
+
+/** Transaction category */
+export declare interface TransactionCategory {
+    id: string;
+    name: string;
+    icon: string;
+    color: string;
+    parent?: string;
+    budget?: number;
+}
+
+export declare type TransactionId = string;
+
+/** Transaction types */
+export declare type TransactionType = 'income' | 'expense' | 'transfer';
+
+export declare function useHealth(): HealthContextValue;
+
+export declare function useLifeDashboard(): LifeDashboardContextValue;
+
+export declare function usePersonalFinance(): FinanceContextValue;
+
+export declare function useTaskManager(): TaskManagerContextValue;
+
+export declare function useTorrentUI(): TorrentUIContextValue;
+
+/** Vital signs */
+export declare interface VitalSigns {
+    date: Date;
+    weight?: number;
+    weightUnit?: 'kg' | 'lbs';
+    bloodPressureSystolic?: number;
+    bloodPressureDiastolic?: number;
+    heartRate?: number;
+    temperature?: number;
+    temperatureUnit?: 'C' | 'F';
+    bloodSugar?: number;
+    oxygenSaturation?: number;
+}
+
+/** Workout session */
+export declare interface Workout {
+    id: WorkoutId;
+    date: Date;
+    name: string;
+    type: ExerciseType;
+    duration: number;
+    exercises: Exercise[];
+    caloriesBurned: number;
+    heartRateAvg?: number;
+    heartRateMax?: number;
+    notes?: string;
+    mood?: 1 | 2 | 3 | 4 | 5;
+    intensity?: 'low' | 'moderate' | 'high';
+}
+
+export declare type WorkoutId = string;
+
+export { }