@wealthfolio/addon-sdk 1.0.0

package/dist/types-CxtChQdm.d.mts

@@ -0,0 +1,1137 @@
+import React__default from 'react';
+
+/**
+ * Comprehensive data types for Wealthfolio addons
+ * These types mirror the main application types to ensure compatibility
+ */
+declare const ActivityType: {
+    readonly BUY: "BUY";
+    readonly SELL: "SELL";
+    readonly DIVIDEND: "DIVIDEND";
+    readonly INTEREST: "INTEREST";
+    readonly DEPOSIT: "DEPOSIT";
+    readonly WITHDRAWAL: "WITHDRAWAL";
+    readonly ADD_HOLDING: "ADD_HOLDING";
+    readonly REMOVE_HOLDING: "REMOVE_HOLDING";
+    readonly TRANSFER_IN: "TRANSFER_IN";
+    readonly TRANSFER_OUT: "TRANSFER_OUT";
+    readonly FEE: "FEE";
+    readonly TAX: "TAX";
+    readonly SPLIT: "SPLIT";
+};
+type ActivityType = (typeof ActivityType)[keyof typeof ActivityType];
+declare const DataSource: {
+    readonly YAHOO: "YAHOO";
+    readonly MANUAL: "MANUAL";
+};
+type DataSource = (typeof DataSource)[keyof typeof DataSource];
+declare const AccountType: {
+    readonly SECURITIES: "SECURITIES";
+    readonly CASH: "CASH";
+    readonly CRYPTOCURRENCY: "CRYPTOCURRENCY";
+};
+type AccountType = (typeof AccountType)[keyof typeof AccountType];
+declare const HoldingType: {
+    readonly CASH: "cash";
+    readonly SECURITY: "security";
+};
+type HoldingType = (typeof HoldingType)[keyof typeof HoldingType];
+type ImportRequiredField = 'symbol' | 'quantity' | 'price' | 'date' | 'type';
+interface Account {
+    id: string;
+    name: string;
+    accountType: AccountType;
+    group?: string;
+    balance: number;
+    currency: string;
+    isDefault: boolean;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    platformId?: string;
+}
+interface Activity {
+    id: string;
+    type: ActivityType;
+    date: Date | string;
+    quantity: number;
+    unitPrice: number;
+    currency: string;
+    fee: number;
+    isDraft: boolean;
+    comment?: string | null;
+    accountId?: string | null;
+    createdAt: Date | string;
+    symbolProfileId: string;
+    updatedAt: Date | string;
+}
+interface ActivityDetails {
+    id: string;
+    activityType: ActivityType;
+    date: Date;
+    quantity: number;
+    unitPrice: number;
+    amount: number;
+    fee: number;
+    currency: string;
+    isDraft: boolean;
+    comment?: string;
+    createdAt: Date;
+    assetId: string;
+    updatedAt: Date;
+    accountId: string;
+    accountName: string;
+    accountCurrency: string;
+    assetSymbol: string;
+    assetName?: string;
+    assetDataSource?: DataSource;
+    subRows?: ActivityDetails[];
+}
+interface ActivitySearchResponse {
+    data: ActivityDetails[];
+    meta: {
+        totalRowCount: number;
+    };
+}
+interface ActivityCreate {
+    accountId: string;
+    activityType: string;
+    activityDate: string | Date;
+    assetId?: string;
+    quantity?: number;
+    unitPrice?: number;
+    amount?: number;
+    currency?: string;
+    fee?: number;
+    isDraft: boolean;
+    comment?: string | null;
+}
+interface ActivityUpdate extends ActivityCreate {
+    id: string;
+}
+interface ActivityImport {
+    id?: string;
+    accountId: string;
+    currency?: string;
+    activityType: ActivityType;
+    date?: Date | string;
+    symbol: string;
+    amount?: number;
+    quantity?: number;
+    unitPrice?: number;
+    fee?: number;
+    accountName?: string;
+    symbolName?: string;
+    errors?: Record<string, string[]>;
+    isValid: boolean;
+    lineNumber?: number;
+    isDraft: boolean;
+    comment?: string;
+}
+interface ImportMappingData {
+    accountId: string;
+    fieldMappings: Record<string, string>;
+    activityMappings: Record<string, string[]>;
+    symbolMappings: Record<string, string>;
+    accountMappings: Record<string, string>;
+}
+interface AssetProfile {
+    id: string;
+    isin: string | null;
+    name: string | null;
+    assetType: string | null;
+    symbol: string;
+    symbolMapping: string | null;
+    assetClass: string | null;
+    assetSubClass: string | null;
+    notes: string | null;
+    countries: string | null;
+    categories: string | null;
+    classes: string | null;
+    attributes: string | null;
+    createdAt: Date;
+    currency: string;
+    dataSource: string;
+    updatedAt: Date;
+    sectors: string | null;
+    url: string | null;
+}
+interface QuoteSummary {
+    exchange: string;
+    shortName: string;
+    quoteType: string;
+    symbol: string;
+    index: string;
+    score: number;
+    typeDisplay: string;
+    longName: string;
+    sector?: string;
+    industry?: string;
+    dataSource?: boolean;
+}
+interface MarketDataProviderInfo {
+    id: string;
+    name: string;
+    logoFilename: string;
+    lastSyncedDate: string | null;
+}
+interface MarketData {
+    createdAt: Date;
+    dataSource: string;
+    date: Date;
+    id: string;
+    marketPrice: number;
+    state: 'CLOSE';
+    symbol: string;
+    symbolProfileId: string;
+}
+interface Tag {
+    id: string;
+    name: string;
+    activityId: string | null;
+}
+interface ImportValidationResult {
+    activities: ActivityImport[];
+    validationSummary: {
+        totalRows: number;
+        validCount: number;
+        invalidCount: number;
+    };
+}
+type ValidationResult = {
+    status: 'success';
+} | {
+    status: 'error';
+    errors: string[];
+};
+interface Sector {
+    name: string;
+    weight: number;
+}
+interface Country {
+    name: string;
+    weight: number;
+}
+interface Instrument {
+    id: string;
+    symbol: string;
+    name?: string | null;
+    currency: string;
+    notes?: string | null;
+    dataSource?: string | null;
+    assetClass?: string | null;
+    assetSubclass?: string | null;
+    countries?: Country[] | null;
+    sectors?: Sector[] | null;
+}
+interface MonetaryValue {
+    local: number;
+    base: number;
+}
+interface Lot {
+    id: string;
+    positionId: string;
+    acquisitionDate: string;
+    quantity: number;
+    costBasis: number;
+    acquisitionPrice: number;
+    acquisitionFees: number;
+}
+interface Position {
+    id: string;
+    accountId: string;
+    assetId: string;
+    quantity: number;
+    averageCost: number;
+    totalCostBasis: number;
+    currency: string;
+    inceptionDate: string;
+    lots: Lot[];
+}
+interface CashHolding {
+    id: string;
+    accountId: string;
+    currency: string;
+    amount: number;
+    lastUpdated: string;
+}
+interface Holding {
+    id: string;
+    holdingType: HoldingType;
+    accountId: string;
+    instrument?: Instrument | null;
+    quantity: number;
+    openDate?: string | Date | null;
+    lots?: Lot[] | null;
+    localCurrency: string;
+    baseCurrency: string;
+    fxRate?: number | null;
+    marketValue: MonetaryValue;
+    costBasis?: MonetaryValue | null;
+    price?: number | null;
+    unrealizedGain?: MonetaryValue | null;
+    unrealizedGainPct?: number | null;
+    realizedGain?: MonetaryValue | null;
+    realizedGainPct?: number | null;
+    totalGain?: MonetaryValue | null;
+    totalGainPct?: number | null;
+    dayChange?: MonetaryValue | null;
+    dayChangePct?: number | null;
+    prevCloseValue?: MonetaryValue | null;
+    weight: number;
+    asOfDate: string;
+}
+interface Asset {
+    id: string;
+    isin?: string | null;
+    name?: string | null;
+    assetType?: string | null;
+    symbol: string;
+    symbolMapping?: string | null;
+    assetClass?: string | null;
+    assetSubClass?: string | null;
+    notes?: string | null;
+    countries?: string | null;
+    categories?: string | null;
+    classes?: string | null;
+    attributes?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    currency: string;
+    dataSource: string;
+    sectors?: string | null;
+    url?: string | null;
+}
+interface Quote {
+    id: string;
+    createdAt: string;
+    dataSource: string;
+    timestamp: string;
+    symbol: string;
+    open: number;
+    high: number;
+    low: number;
+    volume: number;
+    close: number;
+    adjclose: number;
+    currency: string;
+}
+interface QuoteUpdate {
+    timestamp: string;
+    symbol: string;
+    open: number;
+    high: number;
+    low: number;
+    volume: number;
+    close: number;
+    dataSource: string;
+}
+interface Settings {
+    theme: string;
+    font: string;
+    baseCurrency: string;
+    onboardingCompleted: boolean;
+}
+interface SettingsContextType {
+    settings: Settings | null;
+    isLoading: boolean;
+    isError: boolean;
+    updateBaseCurrency: (currency: Settings['baseCurrency']) => Promise<void>;
+    accountsGrouped: boolean;
+    setAccountsGrouped: (value: boolean) => void;
+}
+interface Goal {
+    id: string;
+    title: string;
+    description?: string;
+    targetAmount: number;
+    isAchieved?: boolean;
+    allocations?: GoalAllocation[];
+}
+interface GoalAllocation {
+    id: string;
+    goalId: string;
+    accountId: string;
+    percentAllocation: number;
+}
+interface GoalProgress {
+    name: string;
+    targetValue: number;
+    currentValue: number;
+    progress: number;
+    currency: string;
+}
+interface IncomeSummary {
+    period: string;
+    byMonth: Record<string, number>;
+    byType: Record<string, number>;
+    bySymbol: Record<string, number>;
+    byCurrency: Record<string, number>;
+    totalIncome: number;
+    currency: string;
+    monthlyAverage: number;
+    yoyGrowth: number | null;
+}
+type DateRange = {
+    from: Date | undefined;
+    to: Date | undefined;
+};
+type TimePeriod = '1D' | '1W' | '1M' | '3M' | '6M' | 'YTD' | '1Y' | '5Y' | 'ALL';
+interface AccountValuation {
+    id: string;
+    accountId: string;
+    valuationDate: string;
+    accountCurrency: string;
+    baseCurrency: string;
+    fxRateToBase: number;
+    cashBalance: number;
+    investmentMarketValue: number;
+    totalValue: number;
+    costBasis: number;
+    netContribution: number;
+    calculatedAt: string;
+}
+interface AccountSummaryView {
+    accountId: string;
+    accountName: string;
+    accountType: string;
+    accountGroup: string | null;
+    accountCurrency: string;
+    totalValueAccountCurrency: number;
+    totalValueBaseCurrency: number;
+    baseCurrency: string;
+    performance: SimplePerformanceMetrics;
+}
+interface SimplePerformanceMetrics {
+    accountId: string;
+    totalValue?: number | null;
+    accountCurrency?: string | null;
+    baseCurrency?: string | null;
+    fxRateToBase?: number | null;
+    totalGainLossAmount?: number | null;
+    cumulativeReturnPercent?: number | null;
+    dayGainLossAmount?: number | null;
+    dayReturnPercentModDietz?: number | null;
+    portfolioWeight?: number | null;
+}
+interface AccountGroup {
+    groupName: string;
+    accounts: AccountSummaryView[];
+    totalValueBaseCurrency: number;
+    baseCurrency: string;
+    performance: SimplePerformanceMetrics;
+    accountCount: number;
+}
+interface ExchangeRate {
+    id: string;
+    fromCurrency: string;
+    toCurrency: string;
+    fromCurrencyName?: string;
+    toCurrencyName?: string;
+    rate: number;
+    source: string;
+    isLoading?: boolean;
+    timestamp: string;
+}
+interface ContributionLimit {
+    id: string;
+    groupName: string;
+    contributionYear: number;
+    limitAmount: number;
+    accountIds?: string | null;
+    startDate?: string | null;
+    endDate?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+type NewContributionLimit = Omit<ContributionLimit, 'id' | 'createdAt' | 'updatedAt'>;
+interface AccountDeposit {
+    amount: number;
+    currency: string;
+    convertedAmount: number;
+}
+interface DepositsCalculation {
+    total: number;
+    baseCurrency: string;
+    byAccount: Record<string, AccountDeposit>;
+}
+declare const ACTIVITY_TYPE_PREFIX_LENGTH = 12;
+interface ReturnData {
+    date: string;
+    value: number;
+}
+interface PerformanceMetrics {
+    id: string;
+    returns: ReturnData[];
+    periodStartDate?: string | null;
+    periodEndDate?: string | null;
+    currency: string;
+    cumulativeTwr: number;
+    gainLossAmount?: number | null;
+    annualizedTwr: number;
+    simpleReturn: number;
+    annualizedSimpleReturn: number;
+    cumulativeMwr: number;
+    annualizedMwr: number;
+    volatility: number;
+    maxDrawdown: number;
+}
+interface UpdateAssetProfile {
+    symbol: string;
+    name?: string;
+    sectors: string;
+    countries: string;
+    notes: string;
+    assetClass: string;
+    assetSubClass: string;
+}
+type TrackedItem = {
+    id: string;
+    type: 'account' | 'symbol';
+    name: string;
+};
+
+/**
+ * Host API interface for addon development
+ * Provides comprehensive access to Wealthfolio functionality organized by domain
+ */
+
+/**
+ * Account management APIs
+ */
+interface AccountsAPI {
+    /**
+     * Get all accounts
+     * @returns Promise resolving to array of accounts
+     */
+    getAll(): Promise<Account[]>;
+    /**
+     * Create a new account
+     * @param account New account data
+     * @returns Promise resolving to created account
+     */
+    create(account: any): Promise<Account>;
+}
+/**
+ * Portfolio and holdings APIs
+ */
+interface PortfolioAPI {
+    /**
+     * Get holdings for a specific account
+     * @param accountId Account identifier
+     * @returns Promise resolving to array of holdings
+     */
+    getHoldings(accountId: string): Promise<Holding[]>;
+    /**
+     * Get specific holding information
+     * @param accountId Account identifier
+     * @param assetId Asset identifier
+     * @returns Promise resolving to holding or null if not found
+     */
+    getHolding(accountId: string, assetId: string): Promise<Holding | null>;
+    /**
+     * Update portfolio calculations
+     * @returns Promise that resolves when update is complete
+     */
+    update(): Promise<void>;
+    /**
+     * Recalculate entire portfolio
+     * @returns Promise that resolves when recalculation is complete
+     */
+    recalculate(): Promise<void>;
+    /**
+     * Get income summary data
+     * @returns Promise resolving to array of income summaries
+     */
+    getIncomeSummary(): Promise<IncomeSummary[]>;
+    /**
+     * Get historical valuations
+     * @param accountId Optional account identifier
+     * @param startDate Optional start date
+     * @param endDate Optional end date
+     * @returns Promise resolving to array of account valuations
+     */
+    getHistoricalValuations(accountId?: string, startDate?: string, endDate?: string): Promise<AccountValuation[]>;
+    /**
+     * Get latest valuations for a set of accounts
+     * @param accountIds Array of account identifiers
+     * @returns Promise resolving to array of latest account valuations
+     */
+    getLatestValuations(accountIds: string[]): Promise<AccountValuation[]>;
+}
+/**
+ * Activity management APIs
+ */
+interface ActivitiesAPI {
+    /**
+     * Get activities, optionally filtered by account
+     * @param accountId Optional account identifier for filtering
+     * @returns Promise resolving to array of activity details
+     */
+    getAll(accountId?: string): Promise<ActivityDetails[]>;
+    /**
+     * Search activities with pagination and filters
+     * @param page Page number
+     * @param pageSize Number of items per page
+     * @param filters Filter criteria
+     * @param searchKeyword Search keyword
+     * @param sort Sort criteria
+     * @returns Promise resolving to search response
+     */
+    search(page: number, pageSize: number, filters: any, searchKeyword: string, sort: any): Promise<ActivitySearchResponse>;
+    /**
+     * Create a new activity
+     * @param activity New activity data
+     * @returns Promise resolving to created activity
+     */
+    create(activity: ActivityCreate): Promise<Activity>;
+    /**
+     * Update an existing activity
+     * @param activity Updated activity data
+     * @returns Promise resolving to updated activity
+     */
+    update(activity: ActivityUpdate): Promise<Activity>;
+    /**
+     * Save multiple activities
+     * @param activities Array of activities to save
+     * @returns Promise resolving to array of saved activities
+     */
+    saveMany(activities: ActivityUpdate[]): Promise<Activity[]>;
+    /**
+     * Import activities from parsed data
+     * @param activities Array of activities to import
+     * @returns Promise resolving to imported activities
+     */
+    import(activities: ActivityImport[]): Promise<ActivityImport[]>;
+    /**
+     * Check activities before import
+     * @param accountId Account identifier
+     * @param activities Array of activities to check
+     * @returns Promise resolving to validated activities
+     */
+    checkImport(accountId: string, activities: ActivityImport[]): Promise<ActivityImport[]>;
+    /**
+     * Get import mapping configuration for an account
+     * @param accountId Account identifier
+     * @returns Promise resolving to import mapping data
+     */
+    getImportMapping(accountId: string): Promise<ImportMappingData>;
+    /**
+     * Save import mapping configuration
+     * @param mapping Import mapping data to save
+     * @returns Promise resolving to saved mapping data
+     */
+    saveImportMapping(mapping: ImportMappingData): Promise<ImportMappingData>;
+}
+/**
+ * Market data and asset APIs
+ */
+interface MarketDataAPI {
+    /**
+     * Search for ticker symbols
+     * @param query Search query
+     * @returns Promise resolving to array of quote summaries
+     */
+    searchTicker(query: string): Promise<QuoteSummary[]>;
+    /**
+     * Synchronize historical quotes
+     * @returns Promise that resolves when sync is complete
+     */
+    syncHistory(): Promise<void>;
+    /**
+     * Synchronize market data for specific symbols
+     * @param symbols Array of symbols to sync
+     * @param refetchAll Whether to refetch all data
+     * @returns Promise that resolves when sync is complete
+     */
+    sync(symbols: string[], refetchAll: boolean): Promise<void>;
+    /**
+     * Get market data providers information
+     * @returns Promise resolving to array of provider info
+     */
+    getProviders(): Promise<MarketDataProviderInfo[]>;
+}
+/**
+ * Asset management APIs
+ */
+interface AssetsAPI {
+    /**
+     * Get asset profile information
+     * @param assetId Asset identifier
+     * @returns Promise resolving to asset profile
+     */
+    getProfile(assetId: string): Promise<Asset>;
+    /**
+     * Update asset profile information
+     * @param payload Updated asset profile data
+     * @returns Promise resolving to updated asset
+     */
+    updateProfile(payload: UpdateAssetProfile): Promise<Asset>;
+    /**
+     * Update asset data source
+     * @param symbol Asset symbol
+     * @param dataSource New data source
+     * @returns Promise resolving to updated asset
+     */
+    updateDataSource(symbol: string, dataSource: string): Promise<Asset>;
+}
+/**
+ * Quote management APIs
+ */
+interface QuotesAPI {
+    /**
+     * Update quote information
+     * @param symbol Asset symbol
+     * @param quote Updated quote data
+     * @returns Promise that resolves when update is complete
+     */
+    update(symbol: string, quote: Quote): Promise<void>;
+    /**
+     * Get quote history for a symbol
+     * @param symbol Asset symbol
+     * @returns Promise resolving to array of quotes
+     */
+    getHistory(symbol: string): Promise<Quote[]>;
+}
+/**
+ * Performance calculation APIs
+ */
+interface PerformanceAPI {
+    /**
+     * Calculate performance history
+     * @param itemType Type of item ('account' or 'symbol')
+     * @param itemId Item identifier
+     * @param startDate Start date for calculation
+     * @param endDate End date for calculation
+     * @returns Promise resolving to performance metrics
+     */
+    calculateHistory(itemType: 'account' | 'symbol', itemId: string, startDate: string, endDate: string): Promise<PerformanceMetrics>;
+    /**
+     * Calculate performance summary
+     * @param args Performance calculation arguments
+     * @returns Promise resolving to performance metrics
+     */
+    calculateSummary(args: {
+        itemType: 'account' | 'symbol';
+        itemId: string;
+        startDate?: string | null;
+        endDate?: string | null;
+    }): Promise<PerformanceMetrics>;
+    /**
+     * Calculate simple performance for multiple accounts
+     * @param accountIds Array of account identifiers
+     * @returns Promise resolving to array of simple performance metrics
+     */
+    calculateAccountsSimple(accountIds: string[]): Promise<SimplePerformanceMetrics[]>;
+}
+/**
+ * Exchange rates APIs
+ */
+interface ExchangeRatesAPI {
+    /**
+     * Get all exchange rates
+     * @returns Promise resolving to array of exchange rates
+     */
+    getAll(): Promise<ExchangeRate[]>;
+    /**
+     * Update an existing exchange rate
+     * @param updatedRate Updated exchange rate data
+     * @returns Promise resolving to updated exchange rate
+     */
+    update(updatedRate: ExchangeRate): Promise<ExchangeRate>;
+    /**
+     * Add a new exchange rate
+     * @param newRate New exchange rate data (without ID)
+     * @returns Promise resolving to created exchange rate
+     */
+    add(newRate: Omit<ExchangeRate, 'id'>): Promise<ExchangeRate>;
+}
+/**
+ * Contribution limits APIs
+ */
+interface ContributionLimitsAPI {
+    /**
+     * Get all contribution limits
+     * @returns Promise resolving to array of contribution limits
+     */
+    getAll(): Promise<ContributionLimit[]>;
+    /**
+     * Create a new contribution limit
+     * @param newLimit New contribution limit data
+     * @returns Promise resolving to created contribution limit
+     */
+    create(newLimit: NewContributionLimit): Promise<ContributionLimit>;
+    /**
+     * Update an existing contribution limit
+     * @param id Contribution limit identifier
+     * @param updatedLimit Updated contribution limit data
+     * @returns Promise resolving to updated contribution limit
+     */
+    update(id: string, updatedLimit: NewContributionLimit): Promise<ContributionLimit>;
+    /**
+     * Calculate deposits for a specific contribution limit
+     * @param limitId Contribution limit identifier
+     * @returns Promise resolving to deposits calculation
+     */
+    calculateDeposits(limitId: string): Promise<DepositsCalculation>;
+}
+/**
+ * Goals management APIs
+ */
+interface GoalsAPI {
+    /**
+     * Get all goals
+     * @returns Promise resolving to array of goals
+     */
+    getAll(): Promise<Goal[]>;
+    /**
+     * Create a new goal
+     * @param goal New goal data
+     * @returns Promise resolving to created goal
+     */
+    create(goal: any): Promise<Goal>;
+    /**
+     * Update an existing goal
+     * @param goal Updated goal data
+     * @returns Promise resolving to updated goal
+     */
+    update(goal: Goal): Promise<Goal>;
+    /**
+     * Update goal allocations
+     * @param allocations Array of goal allocations
+     * @returns Promise that resolves when update is complete
+     */
+    updateAllocations(allocations: GoalAllocation[]): Promise<void>;
+    /**
+     * Get goal allocations
+     * @returns Promise resolving to array of goal allocations
+     */
+    getAllocations(): Promise<GoalAllocation[]>;
+}
+/**
+ * Application settings APIs
+ */
+interface SettingsAPI {
+    /**
+     * Get application settings
+     * @returns Promise resolving to settings
+     */
+    get(): Promise<Settings>;
+    /**
+     * Update application settings
+     * @param settingsUpdate Updated settings data
+     * @returns Promise resolving to updated settings
+     */
+    update(settingsUpdate: Settings): Promise<Settings>;
+    /**
+     * Create database backup
+     * @returns Promise resolving to backup file information
+     */
+    backupDatabase(): Promise<{
+        filename: string;
+        data: Uint8Array;
+    }>;
+}
+/**
+ * File operations APIs
+ */
+interface FilesAPI {
+    /**
+     * Open CSV file dialog
+     * @returns Promise resolving to file path(s) or null if cancelled
+     */
+    openCsvDialog(): Promise<null | string | string[]>;
+    /**
+     * Open file save dialog
+     * @param fileContent File content to save
+     * @param fileName Default file name
+     * @returns Promise resolving to save result
+     */
+    openSaveDialog(fileContent: Uint8Array | Blob | string, fileName: string): Promise<any>;
+}
+/**
+ * Secrets management APIs
+ * Provides secure storage for addon secrets using the system keyring
+ * Each addon can only access its own secrets
+ */
+interface SecretsAPI {
+    /**
+     * Store a secret value for this addon
+     * @param key Secret key identifier
+     * @param value Secret value to store
+     * @returns Promise that resolves when secret is stored
+     */
+    set(key: string, value: string): Promise<void>;
+    /**
+     * Retrieve a secret value for this addon
+     * @param key Secret key identifier
+     * @returns Promise resolving to secret value or null if not found
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Delete a secret for this addon
+     * @param key Secret key identifier
+     * @returns Promise that resolves when secret is deleted
+     */
+    delete(key: string): Promise<void>;
+}
+/**
+ * Logger APIs
+ * Provides logging functionality with automatic addon prefix
+ * All log messages will be prefixed with the addon ID for easy identification
+ */
+interface LoggerAPI {
+    /**
+     * Log an error message
+     * @param message Error message to log
+     */
+    error(message: string): void;
+    /**
+     * Log an info message
+     * @param message Info message to log
+     */
+    info(message: string): void;
+    /**
+     * Log a warning message
+     * @param message Warning message to log
+     */
+    warn(message: string): void;
+    /**
+     * Log a trace message (for detailed debugging)
+     * @param message Trace message to log
+     */
+    trace(message: string): void;
+    /**
+     * Log a debug message
+     * @param message Debug message to log
+     */
+    debug(message: string): void;
+}
+/**
+ * Event listeners APIs
+ */
+interface EventsAPI {
+    /**
+     * Import file events
+     */
+    import: {
+        /**
+         * Listen for import file drop hover events
+         * @param handler Event handler
+         * @returns Promise resolving to unlisten function
+         */
+        onDropHover<T>(handler: EventCallback<T>): Promise<UnlistenFn>;
+        /**
+         * Listen for import file drop events
+         * @param handler Event handler
+         * @returns Promise resolving to unlisten function
+         */
+        onDrop<T>(handler: EventCallback<T>): Promise<UnlistenFn>;
+        /**
+         * Listen for import file drop cancelled events
+         * @param handler Event handler
+         * @returns Promise resolving to unlisten function
+         */
+        onDropCancelled<T>(handler: EventCallback<T>): Promise<UnlistenFn>;
+    };
+    /**
+     * Portfolio events
+     */
+    portfolio: {
+        /**
+         * Listen for portfolio update start events
+         * @param handler Event handler
+         * @returns Promise resolving to unlisten function
+         */
+        onUpdateStart<T>(handler: EventCallback<T>): Promise<UnlistenFn>;
+        /**
+         * Listen for portfolio update complete events
+         * @param handler Event handler
+         * @returns Promise resolving to unlisten function
+         */
+        onUpdateComplete<T>(handler: EventCallback<T>): Promise<UnlistenFn>;
+        /**
+         * Listen for portfolio update error events
+         * @param handler Event handler
+         * @returns Promise resolving to unlisten function
+         */
+        onUpdateError<T>(handler: EventCallback<T>): Promise<UnlistenFn>;
+    };
+    /**
+     * Market sync events
+     */
+    market: {
+        /**
+         * Listen for market sync start events
+         * @param handler Event handler
+         * @returns Promise resolving to unlisten function
+         */
+        onSyncStart<T>(handler: EventCallback<T>): Promise<UnlistenFn>;
+        /**
+         * Listen for market sync complete events
+         * @param handler Event handler
+         * @returns Promise resolving to unlisten function
+         */
+        onSyncComplete<T>(handler: EventCallback<T>): Promise<UnlistenFn>;
+    };
+}
+/**
+ * Navigation APIs
+ */
+interface NavigationAPI {
+    /**
+     * Navigate to a route in the application
+     * @param route The route path to navigate to
+     * @returns Promise that resolves when navigation is complete
+     */
+    navigate(route: string): Promise<void>;
+}
+/**
+ * Query management APIs for React Query integration
+ */
+interface QueryAPI {
+    /**
+     * Get the shared QueryClient instance from the main application
+     * @returns The shared QueryClient instance
+     */
+    getClient(): any;
+    /**
+     * Invalidate queries by key
+     * @param queryKey The query key to invalidate
+     */
+    invalidateQueries(queryKey: string | string[]): void;
+    /**
+     * Refetch queries by key
+     * @param queryKey The query key to refetch
+     */
+    refetchQueries(queryKey: string | string[]): void;
+}
+/**
+ * Comprehensive Host API interface providing access to all Wealthfolio functionality
+ * Organized by functional domains for better discoverability and maintainability
+ */
+interface HostAPI {
+    /** Account management operations */
+    accounts: AccountsAPI;
+    /** Portfolio and holdings operations */
+    portfolio: PortfolioAPI;
+    /** Activity management operations */
+    activities: ActivitiesAPI;
+    /** Market data operations */
+    market: MarketDataAPI;
+    /** Asset management operations */
+    assets: AssetsAPI;
+    /** Quote management operations */
+    quotes: QuotesAPI;
+    /** Performance calculation operations */
+    performance: PerformanceAPI;
+    /** Exchange rates operations */
+    exchangeRates: ExchangeRatesAPI;
+    /** Contribution limits operations */
+    contributionLimits: ContributionLimitsAPI;
+    /** Goals management operations */
+    goals: GoalsAPI;
+    /** Application settings operations */
+    settings: SettingsAPI;
+    /** File operations */
+    files: FilesAPI;
+    /** Secrets management */
+    secrets: SecretsAPI;
+    /** Logger operations */
+    logger: LoggerAPI;
+    /** Event listeners */
+    events: EventsAPI;
+    /** Navigation operations */
+    navigation: NavigationAPI;
+    /** React Query operations */
+    query: QueryAPI;
+}
+
+/**
+ * Core types for addon development
+ */
+/**
+ * Handle returned from sidebar item creation
+ */
+interface SidebarItemHandle {
+    /** Remove the sidebar item */
+    remove(): void;
+}
+/**
+ * Configuration for adding a sidebar item
+ */
+interface SidebarItemConfig {
+    /** Unique identifier for the sidebar item */
+    id: string;
+    /** Display text for the sidebar item */
+    label: string;
+    /** Optional icon name or React component */
+    icon?: string | React__default.ReactNode;
+    /** Optional route to navigate to when clicked */
+    route?: string;
+    /** Optional ordering priority (lower numbers appear first) */
+    order?: number;
+    /** Optional click handler (if no route provided) */
+    onClick?: () => void;
+}
+/**
+ * Configuration for adding a route
+ */
+interface RouteConfig {
+    /** Route path pattern */
+    path: string;
+    /** Lazy-loaded React component */
+    component: React__default.LazyExoticComponent<React__default.ComponentType<any>>;
+}
+/**
+ * Sidebar management interface
+ */
+interface SidebarManager {
+    /**
+     * Add an item to the application sidebar
+     * @param config Configuration for the sidebar item
+     * @returns Handle to remove the item
+     */
+    addItem(config: SidebarItemConfig): SidebarItemHandle;
+}
+/**
+ * Router management interface
+ */
+interface RouterManager {
+    /**
+     * Register a new route in the application
+     * @param route Route configuration
+     */
+    add(route: RouteConfig): void;
+}
+/**
+ * Event callback type for Tauri events
+ */
+type EventCallback<T> = (event: {
+    payload: T;
+}) => void;
+/**
+ * Unlisten function type for event listeners
+ */
+type UnlistenFn = () => void;
+/**
+ * Main addon context interface providing access to Wealthfolio APIs
+ */
+interface AddonContext {
+    /** Sidebar management */
+    sidebar: SidebarManager;
+    /** Router management */
+    router: RouterManager;
+    /** Register a callback for addon cleanup */
+    onDisable(callback: () => void): void;
+    /** Access to host application APIs */
+    api: HostAPI;
+}
+/**
+ * Addon enable function signature
+ */
+type AddonEnableFunction = (context: AddonContext) => void | {
+    disable?: () => void;
+};
+
+export { type ExchangeRate as $, type AddonContext as A, type Settings as B, type Country as C, DataSource as D, type EventCallback as E, type SettingsContextType as F, type Goal as G, type HostAPI as H, type ImportRequiredField as I, type GoalAllocation as J, type GoalProgress as K, type Lot as L, type MarketDataProviderInfo as M, type IncomeSummary as N, type DateRange as O, type Position as P, type QuoteSummary as Q, type RouteConfig as R, type SidebarItemHandle as S, type Tag as T, type UnlistenFn as U, type ValidationResult as V, type TimePeriod as W, type AccountValuation as X, type AccountSummaryView as Y, type SimplePerformanceMetrics as Z, type AccountGroup as _, type AddonEnableFunction as a, type ContributionLimit as a0, type NewContributionLimit as a1, type AccountDeposit as a2, type DepositsCalculation as a3, ACTIVITY_TYPE_PREFIX_LENGTH as a4, type ReturnData as a5, type PerformanceMetrics as a6, type UpdateAssetProfile as a7, type TrackedItem as a8, type SidebarItemConfig as b, type SidebarManager as c, type RouterManager as d, ActivityType as e, AccountType as f, HoldingType as g, type Account as h, type Activity as i, type ActivityDetails as j, type ActivitySearchResponse as k, type ActivityCreate as l, type ActivityUpdate as m, type ActivityImport as n, type ImportMappingData as o, type AssetProfile as p, type MarketData as q, type ImportValidationResult as r, type Sector as s, type Instrument as t, type MonetaryValue as u, type CashHolding as v, type Holding as w, type Asset as x, type Quote as y, type QuoteUpdate as z };