import { FMPConfig, APIResponse, EarningsCalendar, EarningsConfirmed, DividendsCalendar, EconomicsCalendar, IPOCalendar, SplitsCalendar, CompanyProfile, ExecutiveCompensation, CompanyNotes, HistoricalEmployeeCount, SharesFloat, HistoricalSharesFloat, EarningsCallTranscript, CompanyTranscriptData, TreasuryRate, EconomicIndicator, ETFHoldingDates, ETFHolding, ETFHolder, ETFProfile, ETFWeighting, ETFCountryWeighting, ETFStockExposure, IncomeStatement, BalanceSheet, CashFlowStatement, KeyMetrics, FinancialRatios, EnterpriseValue, CashflowGrowth, IncomeGrowth, BalanceSheetGrowth, FinancialGrowth, EarningsHistorical, EarningsSurprises, InsiderTradingRSSResponse, InsiderTradingSearchResponse, TransactionTypesResponse, InsidersBySymbolResponse, InsiderTradeStatisticsResponse, CikMapperResponse, CikMapperBySymbolResponse, BeneficialOwnershipResponse, FailToDeliverResponse, TransactionType, Form13FResponse, InstitutionalHolderResponse, StockList, ETFList, CryptoList, ForexList, AvailableIndexesList, MarketHours, MarketPerformance, MarketSectorPerformance, MarketIndex, MutualFundHolding, Article, News, Quote, HistoricalPriceResponse, HistoricalPriceData, ScreenerParams, Screener, AvailableExchanges, AvailableSectors, AvailableIndustries, AvailableCountries, RSSFeedItem, RSSFeedAllItem, RSSFeedV3Item, RSSFeed8KItem, SECFiling, IndustryClassification, IndustryClassificationCode, SenateTradingResponse, SenateHouseTradingByNameResponse, HouseTradingResponse, MarketCap, StockSplitResponse, StockDividendResponse, StockRealTimePrice, StockRealTimePriceFull } from './types-only.js';
export { CompaniesPriceListResponse, DateRangeParams, EconomicIndicatorName, Exchange, IndividualIndustryClassificationParams, IndustryClassificationCodesParams, MarketHoliday, PaginationParams, Period, PeriodParams, QueryParams, RSSFeed8KParams, RSSFeedParams, RSSFeedV3Params, SECFilingsParams, StockDividend, StockListResponse, StockSplit, SymbolParams } from './types-only.js';
export { FMPValidation } from './utils/validation.js';

declare class FMPClient {
    private v3Client;
    private v4Client;
    private stableClient;
    private apiKey;
    constructor(config: FMPConfig);
    /**
     * Standard get method - returns raw API response
     *
     * For endpoints that return arrays, this will always return an array (possibly empty) for `data` when success is true.
     * For endpoints that return objects, data is returned as-is.
     */
    get<T>(endpoint: string, version?: 'v3' | 'v4' | 'stable', params?: Record<string, any>): Promise<APIResponse<T>>;
    /**
     * Get method for single-object endpoints - unwraps single-item arrays
     *
     * For endpoints that return single objects, this will always return an object (possibly empty) for `data` when success is true.
     */
    getSingle<T>(endpoint: string, version?: 'v3' | 'v4' | 'stable', params?: Record<string, any>): Promise<APIResponse<T>>;
    private getClientForVersion;
}

declare class CalendarEndpoints {
    private _client;
    constructor(_client: FMPClient);
    /**
     * Get earnings calendar data
     *
     * Provides upcoming earnings announcements for all publicly traded companies
     * within a specified date range. Essential for tracking earnings season,
     * market events, and investment timing decisions.
     *
     * @param params - Earnings calendar request parameters
     * @param params.from - Start date in YYYY-MM-DD format (optional, defaults to today)
     * @param params.to - End date in YYYY-MM-DD format (optional, defaults to 30 days from today)
     *
     * @returns Promise resolving to array of earnings calendar data with announcement details
     *
     * @example
     * ```typescript
     * // Get earnings calendar for next week
     * const earningsCalendar = await fmp.calendar.getEarningsCalendar({
     *   from: '2024-01-15',
     *   to: '2024-01-22'
     * });
     * earningsCalendar.data.forEach(earning => {
     *   console.log(`${earning.date}: ${earning.symbol} - Est. EPS: ${earning.estimatedEps}`);
     * });
     *
     * // Get earnings calendar for current month
     * const monthlyEarnings = await fmp.calendar.getEarningsCalendar({
     *   from: '2024-01-01',
     *   to: '2024-01-31'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#earnings-calendar-earnings|FMP Earnings Calendar Documentation}
     */
    getEarningsCalendar(params?: {
        from?: string;
        to?: string;
    }): Promise<APIResponse<EarningsCalendar[]>>;
    /**
     * Get confirmed earnings calendar data
     *
     * Provides confirmed earnings announcements with verified dates and times.
     * These are earnings announcements that have been officially confirmed
     * by companies, providing more reliable scheduling information.
     *
     * @param params - Confirmed earnings calendar request parameters
     * @param params.from - Start date in YYYY-MM-DD format (optional, defaults to today)
     * @param params.to - End date in YYYY-MM-DD format (optional, defaults to 30 days from today)
     *
     * @returns Promise resolving to array of confirmed earnings calendar data
     *
     * @example
     * ```typescript
     * // Get confirmed earnings for next week
     * const confirmedEarnings = await fmp.calendar.getEarningsConfirmed({
     *   from: '2024-01-15',
     *   to: '2024-01-22'
     * });
     * confirmedEarnings.data.forEach(earning => {
     *   console.log(`${earning.date}: ${earning.symbol} - Confirmed: ${earning.time}`);
     * });
     *
     * // Get confirmed earnings for current month
     * const monthlyConfirmed = await fmp.calendar.getEarningsConfirmed({
     *   from: '2024-01-01',
     *   to: '2024-01-31'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#earnings-confirmed-earnings|FMP Earnings Confirmed Documentation}
     */
    getEarningsConfirmed(params?: {
        from?: string;
        to?: string;
    }): Promise<APIResponse<EarningsConfirmed[]>>;
    /**
     * Get dividends calendar data
     *
     * Provides upcoming dividend payments and ex-dividend dates for all
     * publicly traded companies within a specified date range. Essential
     * for dividend investors and income-focused strategies.
     *
     * @param params - Dividends calendar request parameters
     * @param params.from - Start date in YYYY-MM-DD format (optional, defaults to today)
     * @param params.to - End date in YYYY-MM-DD format (optional, defaults to 30 days from today)
     *
     * @returns Promise resolving to array of dividends calendar data with payment details
     *
     * @example
     * ```typescript
     * // Get dividends calendar for next week
     * const dividendsCalendar = await fmp.calendar.getDividendsCalendar({
     *   from: '2024-01-15',
     *   to: '2024-01-22'
     * });
     * dividendsCalendar.data.forEach(dividend => {
     *   console.log(`${dividend.date}: ${dividend.symbol} - Amount: $${dividend.amount}`);
     * });
     *
     * // Get dividends calendar for current month
     * const monthlyDividends = await fmp.calendar.getDividendsCalendar({
     *   from: '2024-01-01',
     *   to: '2024-01-31'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#dividends-calendar-dividends|FMP Dividends Calendar Documentation}
     */
    getDividendsCalendar(params?: {
        from?: string;
        to?: string;
    }): Promise<APIResponse<DividendsCalendar[]>>;
    /**
     * Get economic calendar data
     *
     * Provides upcoming economic events, indicators, and data releases
     * that can impact financial markets. Essential for understanding
     * market-moving events and economic trends.
     *
     * @param params - Economic calendar request parameters
     * @param params.from - Start date in YYYY-MM-DD format (optional, defaults to today)
     * @param params.to - End date in YYYY-MM-DD format (optional, defaults to 30 days from today)
     *
     * @returns Promise resolving to array of economic calendar data with event details
     *
     * @example
     * ```typescript
     * // Get economic calendar for next week
     * const economicCalendar = await fmp.calendar.getEconomicsCalendar({
     *   from: '2024-01-15',
     *   to: '2024-01-22'
     * });
     * economicCalendar.data.forEach(event => {
     *   console.log(`${event.date}: ${event.event} - Country: ${event.country}`);
     * });
     *
     * // Get economic calendar for current month
     * const monthlyEconomic = await fmp.calendar.getEconomicsCalendar({
     *   from: '2024-01-01',
     *   to: '2024-01-31'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#economics-calendar-economics-data|FMP Economic Calendar Documentation}
     */
    getEconomicsCalendar(params?: {
        from?: string;
        to?: string;
    }): Promise<APIResponse<EconomicsCalendar[]>>;
    /**
     * Get IPO calendar data
     *
     * Provides upcoming initial public offerings (IPOs) and their details
     * within a specified date range. Essential for tracking new market
     * entrants and investment opportunities in newly public companies.
     *
     * @param params - IPO calendar request parameters
     * @param params.from - Start date in YYYY-MM-DD format (optional, defaults to today)
     * @param params.to - End date in YYYY-MM-DD format (optional, defaults to 30 days from today)
     *
     * @returns Promise resolving to array of IPO calendar data with offering details
     *
     * @example
     * ```typescript
     * // Get IPO calendar for next week
     * const ipoCalendar = await fmp.calendar.getIPOCalendar({
     *   from: '2024-01-15',
     *   to: '2024-01-22'
     * });
     * ipoCalendar.data.forEach(ipo => {
     *   console.log(`${ipo.date}: ${ipo.symbol} - Price: $${ipo.price}, Shares: ${ipo.shares.toLocaleString()}`);
     * });
     *
     * // Get IPO calendar for current month
     * const monthlyIPOs = await fmp.calendar.getIPOCalendar({
     *   from: '2024-01-01',
     *   to: '2024-01-31'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#ipo-calender-by-ipo-calendar|FMP IPO Calendar Documentation}
     */
    getIPOCalendar(params?: {
        from?: string;
        to?: string;
    }): Promise<APIResponse<IPOCalendar[]>>;
    /**
     * Get stock splits calendar data
     *
     * Provides upcoming stock splits for publicly traded companies within
     * a specified date range. Essential for understanding corporate actions
     * that affect share prices and trading dynamics.
     *
     * @param params - Stock splits calendar request parameters
     * @param params.from - Start date in YYYY-MM-DD format (optional, defaults to today)
     * @param params.to - End date in YYYY-MM-DD format (optional, defaults to 30 days from today)
     *
     * @returns Promise resolving to array of stock splits calendar data with split details
     *
     * @example
     * ```typescript
     * // Get stock splits calendar for next week
     * const splitsCalendar = await fmp.calendar.getSplitsCalendar({
     *   from: '2024-01-15',
     *   to: '2024-01-22'
     * });
     * splitsCalendar.data.forEach(split => {
     *   console.log(`${split.date}: ${split.symbol} - Ratio: ${split.numerator}:${split.denominator}`);
     * });
     *
     * // Get stock splits calendar for current month
     * const monthlySplits = await fmp.calendar.getSplitsCalendar({
     *   from: '2024-01-01',
     *   to: '2024-01-31'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#splits-calendar-splits|FMP Stock Splits Calendar Documentation}
     */
    getSplitsCalendar(params?: {
        from?: string;
        to?: string;
    }): Promise<APIResponse<SplitsCalendar[]>>;
}

declare class CompanyEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get comprehensive company profile and information
     *
     * Provides detailed company information including financial metrics, business description,
     * headquarters location, and key performance indicators. Essential for fundamental analysis
     * and understanding a company's business model and market position.
     *
     * @param symbol - The stock symbol to get the profile for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     *
     * @returns Promise resolving to comprehensive company profile with financial and business information
     *
     * @example
     * ```typescript
     * // Get Apple's company profile
     * const profile = await fmp.company.getCompanyProfile('AAPL');
     * console.log(`Company: ${profile.data.companyName}`);
     * console.log(`Industry: ${profile.data.industry}`);
     * console.log(`Market Cap: $${profile.data.mktCap.toLocaleString()}`);
     * console.log(`Description: ${profile.data.description.substring(0, 100)}...`);
     *
     * // Get Microsoft's profile
     * const msftProfile = await fmp.company.getCompanyProfile('MSFT');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#profile-symbol|FMP Company Profile Documentation}
     */
    getCompanyProfile(symbol: string): Promise<APIResponse<CompanyProfile>>;
    /**
     * Get executive compensation and governance information
     *
     * Provides detailed compensation data for company executives including salary, bonuses,
     * stock options, and other benefits. Essential for governance analysis and understanding
     * executive pay structures and alignment with shareholder interests.
     *
     * @param symbol - The stock symbol to get executive compensation for (e.g., 'AAPL', 'MSFT', 'TSLA')
     *
     * @returns Promise resolving to array of executive compensation data with detailed pay information
     *
     * @example
     * ```typescript
     * // Get Apple's executive compensation
     * const compensation = await fmp.company.getExecutiveCompensation('AAPL');
     * compensation.data.forEach(exec => {
     *   console.log(`${exec.name} (${exec.title}):`);
     *   console.log(`  Salary: $${exec.salary.toLocaleString()}`);
     *   console.log(`  Bonus: $${exec.bonus.toLocaleString()}`);
     *   console.log(`  Stock Options: $${exec.stockAwards.toLocaleString()}`);
     * });
     *
     * // Get Tesla's executive compensation
     * const teslaComp = await fmp.company.getExecutiveCompensation('TSLA');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#executive-compensation|FMP Executive Compensation Documentation}
     */
    getExecutiveCompensation(symbol: string): Promise<APIResponse<ExecutiveCompensation[]>>;
    /**
     * Get company notes and financial disclosures
     *
     * Provides important notes and disclosures from company financial statements.
     * These notes contain critical information about accounting policies, risks,
     * contingencies, and other material information that affects financial analysis.
     *
     * @param symbol - The stock symbol to get notes for (e.g., 'AAPL', 'MSFT', 'JPM')
     *
     * @returns Promise resolving to array of company notes with detailed disclosure information
     *
     * @example
     * ```typescript
     * // Get Apple's company notes
     * const notes = await fmp.company.getCompanyNotes('AAPL');
     * notes.data.forEach(note => {
     *   console.log(`Note ${note.noteNumber}: ${note.noteTitle}`);
     *   console.log(`  Content: ${note.noteContent.substring(0, 100)}...`);
     * });
     *
     * // Get JPMorgan's notes
     * const jpmNotes = await fmp.company.getCompanyNotes('JPM');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#company-notes|FMP Company Notes Documentation}
     */
    getCompanyNotes(symbol: string): Promise<APIResponse<CompanyNotes[]>>;
    /**
     * Get historical employee count data
     *
     * Provides historical data on company employee counts over time.
     * Useful for analyzing company growth, operational efficiency, and workforce trends.
     * Employee count is often a key indicator of company expansion or contraction.
     *
     * @param symbol - The stock symbol to get historical employee count for (e.g., 'AAPL', 'MSFT', 'AMZN')
     *
     * @returns Promise resolving to array of historical employee count data with year-by-year information
     *
     * @example
     * ```typescript
     * // Get Apple's employee count history
     * const employees = await fmp.company.getHistoricalEmployeeCount('AAPL');
     * employees.data.forEach(year => {
     *   console.log(`${year.year}: ${year.employeeCount.toLocaleString()} employees`);
     * });
     *
     * // Get Amazon's employee growth
     * const amazonEmployees = await fmp.company.getHistoricalEmployeeCount('AMZN');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#historical-employee-count|FMP Historical Employee Count Documentation}
     */
    getHistoricalEmployeeCount(symbol: string): Promise<APIResponse<HistoricalEmployeeCount[]>>;
    /**
     * Get current shares float information
     *
     * Provides the total number of shares that are publicly traded (float) for a company.
     * The float is calculated by subtracting restricted shares from total outstanding shares.
     * Important for understanding liquidity, volatility, and trading dynamics.
     *
     * @param symbol - The stock symbol to get shares float for (e.g., 'AAPL', 'TSLA', 'NVDA')
     *
     * @returns Promise resolving to shares float data with current float information
     *
     * @example
     * ```typescript
     * // Get Apple's shares float
     * const float = await fmp.company.getSharesFloat('AAPL');
     * console.log(`Float: ${float.data.sharesFloat.toLocaleString()} shares`);
     * console.log(`Outstanding: ${float.data.sharesOutstanding.toLocaleString()} shares`);
     * console.log(`Restricted: ${float.data.restrictedShares.toLocaleString()} shares`);
     *
     * // Get Tesla's float
     * const teslaFloat = await fmp.company.getSharesFloat('TSLA');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#shares-float|FMP Shares Float Documentation}
     */
    getSharesFloat(symbol: string): Promise<APIResponse<SharesFloat>>;
    /**
     * Get historical shares float data
     *
     * Provides historical data on company shares float over time.
     * Useful for analyzing changes in liquidity, share issuance, and corporate actions
     * that affect the number of publicly traded shares.
     *
     * @param symbol - The stock symbol to get historical shares float for (e.g., 'AAPL', 'TSLA', 'NVDA')
     *
     * @returns Promise resolving to array of historical shares float data with date-by-date information
     *
     * @example
     * ```typescript
     * // Get Apple's historical float
     * const historicalFloat = await fmp.company.getHistoricalSharesFloat('AAPL');
     * historicalFloat.data.forEach(entry => {
     *   console.log(`${entry.date}: ${entry.sharesFloat.toLocaleString()} shares`);
     * });
     *
     * // Get Tesla's float history
     * const teslaHistory = await fmp.company.getHistoricalSharesFloat('TSLA');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#company-historical-share-float|FMP Historical Shares Float Documentation}
     */
    getHistoricalSharesFloat(symbol: string): Promise<APIResponse<HistoricalSharesFloat[]>>;
    /**
     * Get earnings call transcript for specific quarter
     *
     * Provides the full transcript of a company's earnings conference call.
     * Contains detailed Q&A sessions, management commentary, and insights into
     * company performance, strategy, and future outlook.
     *
     * @param params - Earnings call transcript request parameters
     * @param params.symbol - The stock symbol to get transcript for (e.g., 'AAPL', 'MSFT', 'TSLA')
     * @param params.year - The year of the earnings call (e.g., 2024)
     * @param params.quarter - The quarter of the earnings call (1, 2, 3, or 4)
     *
     * @returns Promise resolving to earnings call transcript with full text content
     *
     * @example
     * ```typescript
     * // Get Apple's Q1 2024 earnings call
     * const transcript = await fmp.company.getEarningsCallTranscript({
     *   symbol: 'AAPL',
     *   year: 2024,
     *   quarter: 1
     * });
     * console.log(`Transcript: ${transcript.data[0].content.substring(0, 200)}...`);
     *
     * // Get Tesla's Q4 2023 earnings call
     * const teslaTranscript = await fmp.company.getEarningsCallTranscript({
     *   symbol: 'TSLA',
     *   year: 2023,
     *   quarter: 4
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#earnings-transcript-earnings-transcripts|FMP Earnings Call Transcript Documentation}
     */
    getEarningsCallTranscript(params: {
        symbol: string;
        year: number;
        quarter: number;
    }): Promise<APIResponse<EarningsCallTranscript>>;
    /**
     * Get available earnings call transcript dates
     *
     * Provides a list of all available earnings call transcript dates for a company.
     * Useful for discovering which quarters have transcripts available before
     * requesting the full transcript content.
     *
     * @param symbol - The stock symbol to get transcript dates for (e.g., 'AAPL', 'MSFT', 'TSLA')
     *
     * @returns Promise resolving to array of available transcript dates with quarter information
     *
     * @example
     * ```typescript
     * // Get Apple's available transcript dates
     * const transcriptDates = await fmp.company.getCompanyTranscriptData('AAPL');
     * transcriptDates.data.forEach(date => {
     *   console.log(`Q${date.quarter} ${date.year}: ${date.date}`);
     * });
     *
     * // Get Microsoft's transcript availability
     * const msftDates = await fmp.company.getCompanyTranscriptData('MSFT');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#transcript-dates-earnings-transcripts|FMP Company Transcript Data Documentation}
     */
    getCompanyTranscriptData(symbol: string): Promise<APIResponse<CompanyTranscriptData[]>>;
}

declare class EconomicEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get treasury rates data
     *
     * Provides historical treasury rates for various maturities including
     * 1-month, 3-month, 6-month, 1-year, 2-year, 3-year, 5-year, 7-year,
     * 10-year, 20-year, and 30-year treasury bonds. Essential for analyzing
     * interest rate trends, yield curves, and fixed income investments.
     *
     * @param params - Treasury rates request parameters
     * @param params.from - Start date in YYYY-MM-DD format (optional, defaults to 1 year ago)
     * @param params.to - End date in YYYY-MM-DD format (optional, defaults to today)
     *
     * @returns Promise resolving to array of treasury rates data with yield information
     *
     * @example
     * ```typescript
     * // Get treasury rates for the last year
     * const treasuryRates = await fmp.economic.getTreasuryRates({
     *   from: '2023-01-01',
     *   to: '2023-12-31'
     * });
     * treasuryRates.data.forEach(rate => {
     *   console.log(`${rate.date}: 10Y ${rate.tenY}%, 2Y ${rate.twoY}%`);
     * });
     *
     * // Get recent treasury rates
     * const recentRates = await fmp.economic.getTreasuryRates({
     *   from: '2024-01-01'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#treasury-rates|FMP Treasury Rates Documentation}
     */
    getTreasuryRates(params: {
        from?: string;
        to?: string;
    }): Promise<APIResponse<TreasuryRate[]>>;
    /**
     * Get economic indicators data
     *
     * Provides real-time and historical economic data for a wide variety of
     * economic indicators including GDP, unemployment, inflation, retail sales,
     * and many others. Essential for macroeconomic analysis and understanding
     * economic trends and cycles.
     *
     * @param params - Economic indicators request parameters
     * @param params.name - The economic indicator to retrieve
     * @param params.from - Start date in YYYY-MM-DD format (optional, defaults to 1 year ago)
     * @param params.to - End date in YYYY-MM-DD format (optional, defaults to today)
     *
     * @returns Promise resolving to array of economic indicator data with historical values
     *
     * @example
     * ```typescript
     * // Get GDP data for the last year
     * const gdpData = await fmp.economic.getEconomicIndicators({
     *   name: 'GDP',
     *   from: '2023-01-01',
     *   to: '2023-12-31'
     * });
     * gdpData.data.forEach(gdp => {
     *   console.log(`${gdp.date}: GDP $${gdp.value.toLocaleString()} billion`);
     * });
     *
     * // Get unemployment rate data
     * const unemploymentData = await fmp.economic.getEconomicIndicators({
     *   name: 'unemploymentRate',
     *   from: '2024-01-01'
     * });
     *
     * // Get inflation rate data
     * const inflationData = await fmp.economic.getEconomicIndicators({
     *   name: 'inflationRate',
     *   from: '2023-01-01',
     *   to: '2023-12-31'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#economic-indicators-economics-data|FMP Economic Indicators Documentation}
     */
    getEconomicIndicators(params: {
        name: 'GDP' | 'realGDP' | 'nominalPotentialGDP' | 'realGDPPerCapita' | 'federalFunds' | 'CPI' | 'inflationRate' | 'inflation' | 'retailSales' | 'consumerSentiment' | 'durableGoods' | 'unemploymentRate' | 'totalNonfarmPayroll' | 'initialClaims' | 'industrialProductionTotalIndex' | 'newPrivatelyOwnedHousingUnitsStartedTotalUnits' | 'totalVehicleSales' | 'retailMoneyFunds' | 'smoothedUSRecessionProbabilities' | '3MonthOr90DayRatesAndYieldsCertificatesOfDeposit' | 'commercialBankInterestRateOnCreditCardPlansAllAccounts' | '30YearFixedRateMortgageAverage' | '15YearFixedRateMortgageAverage';
        from?: string;
        to?: string;
    }): Promise<APIResponse<EconomicIndicator[]>>;
}

declare class ETFEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get available ETF holding dates
     *
     * Provides a list of dates when ETF holdings are updated and available.
     * Useful for determining when the most recent holdings data is available
     * and ensuring you're working with current portfolio information.
     *
     * @param symbol - ETF symbol to get holding dates for (e.g., 'SPY', 'VOO', 'QQQ')
     *
     * @returns Promise resolving to array of available holding dates
     *
     * @example
     * ```typescript
     * // Get holding dates for specific ETF
     * const spyDates = await fmp.etf.getHoldingDates('SPY');
     * spyDates.data.forEach(date => {
     *   console.log(`Holdings available: ${date.date}`);
     * });
     *
     * // Get VOO holding dates
     * const vooDates = await fmp.etf.getHoldingDates('VOO');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#etf-holding-dates-etf-holdings|FMP ETF Holding Dates Documentation}
     */
    getHoldingDates(symbol: string): Promise<APIResponse<ETFHoldingDates[]>>;
    /**
     * Get ETF holdings for specific date
     *
     * Provides detailed holdings information for an ETF on a specific date.
     * Includes individual stocks, their weights, shares held, and market values.
     * Essential for understanding ETF composition and portfolio analysis.
     *
     * @param params - ETF holdings request parameters
     * @param params.symbol - The ETF symbol to get holdings for (e.g., 'SPY', 'VOO', 'QQQ')
     * @param params.date - The date to get holdings for in YYYY-MM-DD format
     *
     * @returns Promise resolving to array of ETF holdings with detailed stock information
     *
     * @example
     * ```typescript
     * // Get SPY holdings for specific date
     * const holdings = await fmp.etf.getHoldings({ symbol: 'SPY', date: '2024-01-15' });
     * holdings.data.forEach(holding => {
     *   console.log(`${holding.asset}: ${holding.weight}% (${holding.sharesNumber} shares)`);
     * });
     *
     * // Get VOO holdings
     * const vooHoldings = await fmp.etf.getHoldings({ symbol: 'VOO', date: '2024-01-15' });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#etf-holdings-etf-holdings|FMP ETF Holdings Documentation}
     */
    getHoldings(params: {
        symbol: string;
        date: string;
    }): Promise<APIResponse<ETFHolding[]>>;
    /**
     * Get ETF holdings and components
     *
     * Provides all stocks held by a specific ETF including assets, share numbers,
     * and weight percentages. Essential for understanding ETF composition and
     * finding which ETFs hold specific stocks.
     *
     * @param symbol - The ETF symbol to get holdings for (e.g., 'SPY', 'VOO', 'QQQ')
     *
     * @returns Promise resolving to array of ETF holdings with stock details
     *
     * @example
     * ```typescript
     * // Get SPY holdings
     * const spyHoldings = await fmp.etf.getHolder('SPY');
     * spyHoldings.data.forEach(holding => {
     *   console.log(`${holding.asset}: ${holding.weight}% (${holding.sharesNumber} shares)`);
     * });
     *
     * // Get VOO holdings
     * const vooHoldings = await fmp.etf.getHolder('VOO');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#etf-holder-etf-holdings|FMP ETF Holder Documentation}
     */
    getHolder(symbol: string): Promise<APIResponse<ETFHolder[]>>;
    /**
     * Get ETF profile and information
     *
     * Provides comprehensive information about an ETF including ticker symbol,
     * name, expense ratio, assets under management, and other key metrics.
     * Essential for ETF comparison and due diligence.
     *
     * @param symbol - ETF symbol to get profile for (e.g., 'SPY', 'VOO', 'QQQ')
     *
     * @returns Promise resolving to ETF profile with detailed information
     *
     * @example
     * ```typescript
     * // Get SPY profile
     * const spyProfile = await fmp.etf.getProfile('SPY');
     * console.log(`SPY AUM: $${spyProfile.data.aum.toLocaleString()}`);
     * console.log(`Expense Ratio: ${spyProfile.data.expenseRatio}%`);
     *
     * // Get VOO profile
     * const vooProfile = await fmp.etf.getProfile('VOO');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#information|FMP ETF Information Documentation}
     */
    getProfile(symbol: string): Promise<APIResponse<ETFProfile>>;
    /**
     * Get ETF sector weighting and exposure
     *
     * Provides a breakdown of an ETF's sector allocation showing the percentage
     * of assets invested in each sector. Essential for understanding sector
     * exposure and diversification analysis.
     *
     * @param symbol - The ETF symbol to get sector weighting for (e.g., 'SPY', 'VOO', 'QQQ')
     *
     * @returns Promise resolving to array of sector weightings with percentage allocations
     *
     * @example
     * ```typescript
     * // Get SPY sector weightings
     * const sectorWeightings = await fmp.etf.getSectorWeighting('SPY');
     * sectorWeightings.data.forEach(sector => {
     *   console.log(`${sector.sector}: ${sector.weight}%`);
     * });
     *
     * // Get QQQ sector exposure (tech-heavy)
     * const qqqSectors = await fmp.etf.getSectorWeighting('QQQ');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#sector-weighting|FMP ETF Sector Weighting Documentation}
     */
    getSectorWeighting(symbol: string): Promise<APIResponse<ETFWeighting[]>>;
    /**
     * Get ETF country weighting and exposure
     *
     * Provides a breakdown of an ETF's geographic allocation showing the percentage
     * of assets invested in each country. Essential for understanding international
     * exposure and geographic diversification.
     *
     * @param symbol - The ETF symbol to get country weighting for (e.g., 'SPY', 'VOO', 'EFA')
     *
     * @returns Promise resolving to array of country weightings with percentage allocations
     *
     * @example
     * ```typescript
     * // Get SPY country weightings
     * const countryWeightings = await fmp.etf.getCountryWeighting('SPY');
     * countryWeightings.data.forEach(country => {
     *   console.log(`${country.country}: ${country.weight}%`);
     * });
     *
     * // Get international ETF exposure
     * const efaCountries = await fmp.etf.getCountryWeighting('EFA');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#country-weighting|FMP ETF Country Weighting Documentation}
     */
    getCountryWeighting(symbol: string): Promise<APIResponse<ETFCountryWeighting[]>>;
    /**
     * Get ETF stock exposure and holdings
     *
     * Provides detailed exposure information for a specific stock across all ETFs
     * that hold it. Includes market value, share numbers, and weight percentages.
     * Useful for finding which ETFs have exposure to specific stocks.
     *
     * @param symbol - The stock symbol to get ETF exposure for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     *
     * @returns Promise resolving to array of ETF exposures with detailed holding information
     *
     * @example
     * ```typescript
     * // Find ETFs that hold Apple
     * const appleExposure = await fmp.etf.getStockExposure('AAPL');
     * appleExposure.data.forEach(etf => {
     *   console.log(`${etf.etfSymbol}: ${etf.weight}% (${etf.sharesNumber} shares)`);
     * });
     *
     * // Find ETFs that hold Microsoft
     * const msftExposure = await fmp.etf.getStockExposure('MSFT');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#etf-sector-exposure-etf-holdings|FMP ETF Stock Exposure Documentation}
     */
    getStockExposure(symbol: string): Promise<APIResponse<ETFStockExposure[]>>;
}

declare class FinancialEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get income statement data
     *
     * Provides comprehensive income statement data including revenue, expenses,
     * net income, and earnings per share. Essential for analyzing company
     * profitability, revenue trends, and financial performance over time.
     *
     * @param params - Income statement request parameters
     * @param params.symbol - The stock symbol to get income statement for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.period - The reporting period: 'annual' or 'quarter' (default: 'annual')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of income statement data with financial metrics
     *
     * @example
     * ```typescript
     * // Get annual income statements for Apple
     * const incomeStatements = await fmp.financial.getIncomeStatement({ symbol: 'AAPL' });
     * incomeStatements.data.forEach(statement => {
     *   console.log(`${statement.date}: Revenue $${statement.revenue.toLocaleString()}, Net Income $${statement.netIncome.toLocaleString()}`);
     * });
     *
     * // Get quarterly income statements for Microsoft
     * const quarterlyIncome = await fmp.financial.getIncomeStatement({ symbol: 'MSFT', period: 'quarter', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#income-statement|FMP Income Statement Documentation}
     */
    getIncomeStatement(params: {
        symbol: string;
        period?: 'annual' | 'quarter';
        limit?: number;
    }): Promise<APIResponse<IncomeStatement[]>>;
    /**
     * Get balance sheet data
     *
     * Provides comprehensive balance sheet data including assets, liabilities,
     * and shareholder equity. Essential for analyzing company financial position,
     * liquidity, and capital structure.
     *
     * @param params - Balance sheet request parameters
     * @param params.symbol - The stock symbol to get balance sheet for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.period - The reporting period: 'annual' or 'quarter' (default: 'annual')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of balance sheet data with financial position metrics
     *
     * @example
     * ```typescript
     * // Get annual balance sheets for Apple
     * const balanceSheets = await fmp.financial.getBalanceSheet({ symbol: 'AAPL' });
     * balanceSheets.data.forEach(sheet => {
     *   console.log(`${sheet.date}: Assets $${sheet.totalAssets.toLocaleString()}, Equity $${sheet.totalStockholdersEquity.toLocaleString()}`);
     * });
     *
     * // Get quarterly balance sheets for Microsoft
     * const quarterlyBalance = await fmp.financial.getBalanceSheet({ symbol: 'MSFT', period: 'quarter', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#balance-sheet-statement|FMP Balance Sheet Documentation}
     */
    getBalanceSheet(params: {
        symbol: string;
        period?: 'annual' | 'quarter';
        limit?: number;
    }): Promise<APIResponse<BalanceSheet[]>>;
    /**
     * Get cash flow statement data
     *
     * Provides comprehensive cash flow data including operating, investing,
     * and financing cash flows. Essential for analyzing company cash generation,
     * capital allocation, and financial sustainability.
     *
     * @param params - Cash flow statement request parameters
     * @param params.symbol - The stock symbol to get cash flow statement for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.period - The reporting period: 'annual' or 'quarter' (default: 'annual')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of cash flow statement data with cash flow metrics
     *
     * @example
     * ```typescript
     * // Get annual cash flow statements for Apple
     * const cashFlows = await fmp.financial.getCashFlowStatement({ symbol: 'AAPL' });
     * cashFlows.data.forEach(flow => {
     *   console.log(`${flow.date}: Operating CF $${flow.operatingCashFlow.toLocaleString()}, Free CF $${flow.freeCashFlow.toLocaleString()}`);
     * });
     *
     * // Get quarterly cash flow statements for Microsoft
     * const quarterlyCashFlow = await fmp.financial.getCashFlowStatement({ symbol: 'MSFT', period: 'quarter', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#cashflow-statement|FMP Cash Flow Statement Documentation}
     */
    getCashFlowStatement(params: {
        symbol: string;
        period?: 'annual' | 'quarter';
        limit?: number;
    }): Promise<APIResponse<CashFlowStatement[]>>;
    /**
     * Get key financial metrics
     *
     * Provides essential financial metrics including revenue, net income,
     * P/E ratio, and other key performance indicators. Essential for
     * fundamental analysis and company valuation.
     *
     * @param params - Key metrics request parameters
     * @param params.symbol - The stock symbol to get key metrics for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.period - The reporting period: 'annual' or 'quarter' (default: 'annual')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of key metrics data with financial indicators
     *
     * @example
     * ```typescript
     * // Get key metrics for Apple
     * const keyMetrics = await fmp.financial.getKeyMetrics({ symbol: 'AAPL' });
     * keyMetrics.data.forEach(metric => {
     *   console.log(`${metric.date}: P/E ${metric.peRatio}, ROE ${metric.roe}%`);
     * });
     *
     * // Get quarterly key metrics for Microsoft
     * const quarterlyMetrics = await fmp.financial.getKeyMetrics({ symbol: 'MSFT', period: 'quarter', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#key-metrics|FMP Key Metrics Documentation}
     */
    getKeyMetrics(params: {
        symbol: string;
        period?: 'annual' | 'quarter';
        limit?: number;
    }): Promise<APIResponse<KeyMetrics[]>>;
    /**
     * Get financial ratios
     *
     * Provides comprehensive financial ratios including P/B ratio, ROE,
     * debt-to-equity, and other important ratios. Essential for analyzing
     * company financial health and comparing with peers.
     *
     * @param params - Financial ratios request parameters
     * @param params.symbol - The stock symbol to get financial ratios for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.period - The reporting period: 'annual' or 'quarter' (default: 'annual')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of financial ratios data with ratio metrics
     *
     * @example
     * ```typescript
     * // Get financial ratios for Apple
     * const ratios = await fmp.financial.getFinancialRatios({ symbol: 'AAPL' });
     * ratios.data.forEach(ratio => {
     *   console.log(`${ratio.date}: P/B ${ratio.priceToBookRatio}, Debt/Equity ${ratio.debtToEquity}`);
     * });
     *
     * // Get quarterly ratios for Microsoft
     * const quarterlyRatios = await fmp.financial.getFinancialRatios({ symbol: 'MSFT', period: 'quarter', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#metrics-ratios|FMP Financial Ratios Documentation}
     */
    getFinancialRatios(params: {
        symbol: string;
        period?: 'annual' | 'quarter';
        limit?: number;
    }): Promise<APIResponse<FinancialRatios[]>>;
    /**
     * Get enterprise value data
     *
     * Provides enterprise value metrics including total enterprise value,
     * market cap, and debt information. Essential for company valuation
     * and comparing companies with different capital structures.
     *
     * @param params - Enterprise value request parameters
     * @param params.symbol - The stock symbol to get enterprise value for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.period - The reporting period: 'annual' or 'quarter' (default: 'annual')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of enterprise value data with valuation metrics
     *
     * @example
     * ```typescript
     * // Get enterprise value for Apple
     * const enterpriseValue = await fmp.financial.getEnterpriseValue({ symbol: 'AAPL' });
     * enterpriseValue.data.forEach(ev => {
     *   console.log(`${ev.date}: EV $${ev.enterpriseValue.toLocaleString()}, Market Cap $${ev.marketCapitalization.toLocaleString()}`);
     * });
     *
     * // Get quarterly enterprise value for Microsoft
     * const quarterlyEV = await fmp.financial.getEnterpriseValue({ symbol: 'MSFT', period: 'quarter', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#enterprise-values|FMP Enterprise Value Documentation}
     */
    getEnterpriseValue(params: {
        symbol: string;
        period?: 'annual' | 'quarter';
        limit?: number;
    }): Promise<APIResponse<EnterpriseValue[]>>;
    /**
     * Get cash flow growth data
     *
     * Provides cash flow growth rates showing how quickly a company's
     * cash flows are growing over time. Essential for analyzing cash
     * generation trends and financial sustainability.
     *
     * @param params - Cash flow growth request parameters
     * @param params.symbol - The stock symbol to get cash flow growth for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.period - The reporting period: 'annual' or 'quarter' (default: 'annual')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of cash flow growth data with growth metrics
     *
     * @example
     * ```typescript
     * // Get cash flow growth for Apple
     * const cashFlowGrowth = await fmp.financial.getCashflowGrowth({ symbol: 'AAPL' });
     * cashFlowGrowth.data.forEach(growth => {
     *   console.log(`${growth.date}: Operating CF Growth ${growth.operatingCashFlowGrowth}%`);
     * });
     *
     * // Get quarterly cash flow growth for Microsoft
     * const quarterlyGrowth = await fmp.financial.getCashflowGrowth({ symbol: 'MSFT', period: 'quarter', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#cashflow-statement-growth|FMP Cash Flow Growth Documentation}
     */
    getCashflowGrowth(params: {
        symbol: string;
        period?: 'annual' | 'quarter';
        limit?: number;
    }): Promise<APIResponse<CashflowGrowth[]>>;
    /**
     * Get income growth data
     *
     * Provides income growth rates showing how quickly a company's
     * revenue and net income are growing over time. Essential for
     * analyzing profitability trends and business momentum.
     *
     * @param params - Income growth request parameters
     * @param params.symbol - The stock symbol to get income growth for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.period - The reporting period: 'annual' or 'quarter' (default: 'annual')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of income growth data with growth metrics
     *
     * @example
     * ```typescript
     * // Get income growth for Apple
     * const incomeGrowth = await fmp.financial.getIncomeGrowth({ symbol: 'AAPL' });
     * incomeGrowth.data.forEach(growth => {
     *   console.log(`${growth.date}: Revenue Growth ${growth.revenueGrowth}%, Net Income Growth ${growth.netIncomeGrowth}%`);
     * });
     *
     * // Get quarterly income growth for Microsoft
     * const quarterlyGrowth = await fmp.financial.getIncomeGrowth({ symbol: 'MSFT', period: 'quarter', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#income-statement-growth|FMP Income Growth Documentation}
     */
    getIncomeGrowth(params: {
        symbol: string;
        period?: 'annual' | 'quarter';
        limit?: number;
    }): Promise<APIResponse<IncomeGrowth[]>>;
    /**
     * Get balance sheet growth data
     *
     * Provides balance sheet growth rates showing how quickly a company's
     * assets, liabilities, and equity are growing over time. Essential for
     * analyzing capital structure trends and financial position changes.
     *
     * @param params - Balance sheet growth request parameters
     * @param params.symbol - The stock symbol to get balance sheet growth for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.period - The reporting period: 'annual' or 'quarter' (default: 'annual')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of balance sheet growth data with growth metrics
     *
     * @example
     * ```typescript
     * // Get balance sheet growth for Apple
     * const balanceSheetGrowth = await fmp.financial.getBalanceSheetGrowth({ symbol: 'AAPL' });
     * balanceSheetGrowth.data.forEach(growth => {
     *   console.log(`${growth.date}: Assets Growth ${growth.totalAssetsGrowth}%, Equity Growth ${growth.totalStockholdersEquityGrowth}%`);
     * });
     *
     * // Get quarterly balance sheet growth for Microsoft
     * const quarterlyGrowth = await fmp.financial.getBalanceSheetGrowth({ symbol: 'MSFT', period: 'quarter', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#balance-sheet-statement-growth|FMP Balance Sheet Growth Documentation}
     */
    getBalanceSheetGrowth(params: {
        symbol: string;
        period?: 'annual' | 'quarter';
        limit?: number;
    }): Promise<APIResponse<BalanceSheetGrowth[]>>;
    /**
     * Get financial growth data
     *
     * Provides comprehensive financial growth rates across all key
     * financial metrics. Essential for analyzing overall financial
     * performance trends and business momentum.
     *
     * @param params - Financial growth request parameters
     * @param params.symbol - The stock symbol to get financial growth for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.period - The reporting period: 'annual' or 'quarter' (default: 'annual')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of financial growth data with comprehensive growth metrics
     *
     * @example
     * ```typescript
     * // Get financial growth for Apple
     * const financialGrowth = await fmp.financial.getFinancialGrowth({ symbol: 'AAPL' });
     * financialGrowth.data.forEach(growth => {
     *   console.log(`${growth.date}: Revenue Growth ${growth.revenueGrowth}%, EPS Growth ${growth.epsGrowth}%`);
     * });
     *
     * // Get quarterly financial growth for Microsoft
     * const quarterlyGrowth = await fmp.financial.getFinancialGrowth({ symbol: 'MSFT', period: 'quarter', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#financial-statement-growth|FMP Financial Growth Documentation}
     */
    getFinancialGrowth(params: {
        symbol: string;
        period?: 'annual' | 'quarter';
        limit?: number;
    }): Promise<APIResponse<FinancialGrowth[]>>;
    /**
     * Get historical earnings data
     *
     * Provides historical and upcoming earnings announcements including
     * dates, estimated EPS, and actual EPS. Essential for analyzing
     * earnings trends and tracking company performance.
     *
     * @param params - Earnings historical request parameters
     * @param params.symbol - The stock symbol to get earnings history for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params.limit - Number of periods to retrieve (default: 5)
     *
     * @returns Promise resolving to array of historical earnings data with announcement details
     *
     * @example
     * ```typescript
     * // Get earnings history for Apple
     * const earningsHistory = await fmp.financial.getEarningsHistorical({ symbol: 'AAPL', limit: 10 });
     * earningsHistory.data.forEach(earning => {
     *   console.log(`${earning.date}: Est. ${earning.estimatedEps}, Actual ${earning.actualEps}`);
     * });
     *
     * // Get earnings history for Microsoft
     * const msftEarnings = await fmp.financial.getEarningsHistorical({ symbol: 'MSFT', limit: 8 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#earnings-company|FMP Earnings Historical Documentation}
     */
    getEarningsHistorical(params: {
        symbol: string;
        limit?: number;
    }): Promise<APIResponse<EarningsHistorical[]>>;
    /**
     * Get earnings surprises data
     *
     * Provides earnings announcements that exceeded or fell short of
     * analyst estimates. Essential for analyzing earnings quality and
     * market reactions to earnings releases.
     *
     * @param symbol - The stock symbol to get earnings surprises for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     *
     * @returns Promise resolving to array of earnings surprises data with surprise details
     *
     * @example
     * ```typescript
     * // Get earnings surprises for Apple
     * const earningsSurprises = await fmp.financial.getEarningsSurprises('AAPL');
     * earningsSurprises.data.forEach(surprise => {
     *   console.log(`${surprise.date}: Est. ${surprise.estimatedEps}, Actual ${surprise.actualEps}, Surprise ${surprise.surprisePercentage}%`);
     * });
     *
     * // Get earnings surprises for Microsoft
     * const msftSurprises = await fmp.financial.getEarningsSurprises('MSFT');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#earnings-surprises-earnings|FMP Earnings Surprises Documentation}
     */
    getEarningsSurprises(symbol: string): Promise<APIResponse<EarningsSurprises[]>>;
}

declare class InsiderEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get insider trading RSS feed data
     *
     * Provides real-time RSS feed of insider trading activities across all
     * publicly traded companies. Essential for monitoring insider trading
     * patterns, corporate governance, and potential market-moving events.
     *
     * @param params - RSS feed request parameters
     * @param params.page - Page number for pagination (default: 0)
     * @param params.limit - Limit number of results (default: 100)
     *
     * @returns Promise resolving to array of insider trading RSS feed data
     *
     * @example
     * ```typescript
     * // Get first page of insider trading RSS feed
     * const rssFeed = await fmp.insider.getInsiderTradingRSS({ page: 0 });
     * rssFeed.data.forEach(trade => {
     *   console.log(`${trade.date}: ${trade.symbol} - ${trade.insiderName} ${trade.transactionType}`);
     * });
     *
     * // Get second page of RSS feed
     * const nextPage = await fmp.insider.getInsiderTradingRSS({ page: 1 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#latest-insider-trade|FMP Insider Trading RSS Documentation}
     */
    getInsiderTradingRSS(params: {
        page?: number;
        limit?: number;
    }): Promise<APIResponse<InsiderTradingRSSResponse[]>>;
    /**
     * Search for insider trades with advanced filtering
     *
     * Provides comprehensive insider trading data with multiple filtering options
     * including symbol, CIK numbers, and transaction types. Essential for detailed
     * analysis of insider trading patterns and corporate governance.
     *
     * @param params - Insider trading search parameters
     * @param params.symbol - Stock symbol to filter by (optional)
     * @param params.reportingCik - Reporting CIK to filter by (optional)
     * @param params.companyCik - Company CIK to filter by (optional)
     * @param params.transactionType - Transaction type to filter by (optional)
     * @param params.page - Page number for pagination (default: 0)
     * @param params.limit - Limit number of results (default: 100)
     *
     * @returns Promise resolving to array of insider trading search results
     *
     * @example
     * ```typescript
     * // Search for Apple insider trades
     * const appleTrades = await fmp.insider.searchInsiderTrading({
     *   symbol: 'AAPL',
     *   page: 0
     * });
     * appleTrades.data.forEach(trade => {
     *   console.log(`${trade.date}: ${trade.insiderName} - ${trade.transactionType} ${trade.sharesTraded} shares`);
     * });
     *
     * // Search by transaction type
     * const purchases = await fmp.insider.searchInsiderTrading({
     *   transactionType: 'P-Purchase',
     *   page: 0
     * });
     *
     * // Search by CIK
     * const cikTrades = await fmp.insider.searchInsiderTrading({
     *   companyCik: '0000320193',
     *   page: 0
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#search-insider-trades|FMP Insider Trading Search Documentation}
     */
    searchInsiderTrading(params: {
        symbol?: string;
        reportingCik?: string;
        companyCik?: string;
        transactionType?: string;
        page?: number;
        limit?: number;
    }): Promise<APIResponse<InsiderTradingSearchResponse[]>>;
    /**
     * Get all available transaction types
     *
     * Provides a comprehensive list of all insider trading transaction types
     * used in SEC filings. Essential for understanding different types of
     * insider trading activities and filtering search results.
     *
     * @returns Promise resolving to array of transaction types with descriptions
     *
     * @example
     * ```typescript
     * // Get all transaction types
     * const transactionTypes = await fmp.insider.getTransactionTypes();
     * transactionTypes.data.forEach(type => {
     *   console.log(`${type.code}: ${type.description}`);
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#all-transaction-types|FMP Transaction Types Documentation}
     */
    getTransactionTypes(): Promise<APIResponse<TransactionTypesResponse>>;
    /**
     * Get insiders roster for a specific company
     *
     * Provides a list of all insiders (officers, directors, and beneficial owners)
     * for a specific company. Essential for understanding corporate governance
     * structure and identifying key personnel.
     *
     * @deprecated This endpoint uses API version v4 which will be deprecated.
     *
     * @param params - Insiders request parameters
     * @param params.symbol - Stock symbol to get insiders for
     *
     * @returns Promise resolving to array of insiders data for the company
     *
     * @example
     * ```typescript
     * // Get Apple's insiders roster
     * const appleInsiders = await fmp.insider.getInsidersBySymbol({ symbol: 'AAPL' });
     * appleInsiders.data.forEach(insider => {
     *   console.log(`${insider.name} - ${insider.title} (${insider.cik})`);
     * });
     *
     * // Get Microsoft's insiders
     * const msftInsiders = await fmp.insider.getInsidersBySymbol({ symbol: 'MSFT' });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#insiders-by-symbol-insider-trading|FMP Insiders by Symbol Documentation}
     */
    getInsidersBySymbol(params: {
        symbol: string;
    }): Promise<APIResponse<InsidersBySymbolResponse[]>>;
    /**
     * Get insider trade statistics for a company
     *
     * Provides comprehensive statistics on insider trading activity for a
     * specific company including total trades, volume, and value metrics.
     * Essential for analyzing insider trading patterns and sentiment.
     *
     * @param params - Statistics request parameters
     * @param params.symbol - Stock symbol to get statistics for
     *
     * @returns Promise resolving to array of insider trade statistics data
     *
     * @example
     * ```typescript
     * // Get Apple's insider trade statistics
     * const appleStats = await fmp.insider.getInsiderTradeStatistics({ symbol: 'AAPL' });
     * appleStats.data.forEach(stat => {
     *   console.log(`${stat.insiderName}: ${stat.totalTrades} trades, ${stat.totalShares} shares`);
     * });
     *
     * // Get Microsoft's statistics
     * const msftStats = await fmp.insider.getInsiderTradeStatistics({ symbol: 'MSFT' });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#insider-trade-statistics|FMP Insider Trade Statistics Documentation}
     */
    getInsiderTradeStatistics(params: {
        symbol: string;
    }): Promise<APIResponse<InsiderTradeStatisticsResponse[]>>;
    /**
     * Get CIK mapper data
     *
     * Provides a mapping between CIK (Central Index Key) numbers and company
     * names. Essential for converting between CIK numbers and company
     * identifiers in insider trading analysis.
     *
     * @deprecated This endpoint uses API version v4 which will be deprecated.
     *
     * @param params - CIK mapper request parameters
     * @param params.page - Page number for pagination (default: 0)
     *
     * @returns Promise resolving to array of CIK mapper data
     *
     * @example
     * ```typescript
     * // Get first page of CIK mapper
     * const cikMapper = await fmp.insider.getCikMapper({ page: 0 });
     * cikMapper.data.forEach(mapping => {
     *   console.log(`CIK: ${mapping.cik} - Company: ${mapping.name}`);
     * });
     *
     * // Get second page
     * const nextPage = await fmp.insider.getCikMapper({ page: 1 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#cik-mapper-insider-trading|FMP CIK Mapper Documentation}
     */
    getCikMapper(params: {
        page?: number;
    }): Promise<APIResponse<CikMapperResponse[]>>;
    /**
     * Get CIK mapper by name search
     *
     * Provides CIK numbers and company names matching a search term.
     * Useful for finding companies by partial name matches and
     * converting company names to CIK numbers.
     *
     * @deprecated This endpoint uses API version v4 which will be deprecated.
     *
     * @param params - CIK mapper by name request parameters
     * @param params.name - Company name or partial name to search for
     * @param params.page - Page number for pagination (default: 0)
     *
     * @returns Promise resolving to array of CIK mapper data matching the search
     *
     * @example
     * ```typescript
     * // Search for Apple by name
     * const appleCik = await fmp.insider.getCikMapperByName({
     *   name: 'Apple',
     *   page: 0
     * });
     * appleCik.data.forEach(mapping => {
     *   console.log(`CIK: ${mapping.cik} - Company: ${mapping.name}`);
     * });
     *
     * // Search for Microsoft
     * const msftCik = await fmp.insider.getCikMapperByName({
     *   name: 'Microsoft',
     *   page: 0
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#cik-mapper-by-name-insider-trading|FMP CIK Mapper by Name Documentation}
     */
    getCikMapperByName(params: {
        name: string;
        page?: number;
    }): Promise<APIResponse<CikMapperResponse[]>>;
    /**
     * Get CIK mapper by symbol
     *
     * Provides CIK number and company name for a specific stock symbol.
     * Essential for converting stock symbols to CIK numbers for use
     * in insider trading searches and analysis.
     *
     * @deprecated This endpoint uses API version v4 which will be deprecated.
     *
     * @param params - CIK mapper by symbol request parameters
     * @param params.symbol - Stock symbol to get CIK for
     *
     * @returns Promise resolving to CIK mapper data for the symbol
     *
     * @example
     * ```typescript
     * // Get Apple's CIK by symbol
     * const appleCik = await fmp.insider.getCikMapperBySymbol({ symbol: 'AAPL' });
     * console.log(`Apple CIK: ${appleCik.data.cik} - ${appleCik.data.name}`);
     *
     * // Get Microsoft's CIK
     * const msftCik = await fmp.insider.getCikMapperBySymbol({ symbol: 'MSFT' });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#cik-mapper-company-insider-trading|FMP CIK Mapper by Symbol Documentation}
     */
    getCikMapperBySymbol(params: {
        symbol: string;
    }): Promise<APIResponse<CikMapperBySymbolResponse>>;
    /**
     * Get beneficial ownership acquisitions
     *
     * Provides data on acquisitions of beneficial ownership for a specific
     * company. Essential for tracking significant ownership changes and
     * corporate governance events.
     *
     * @param params - Beneficial ownership request parameters
     * @param params.symbol - Stock symbol to get beneficial ownership data for
     * @param params.limit - Limit number of results (default: 100)
     *
     * @returns Promise resolving to array of beneficial ownership acquisition data
     *
     * @example
     * ```typescript
     * // Get Apple's beneficial ownership acquisitions
     * const appleOwnership = await fmp.insider.getBeneficialOwnership({ symbol: 'AAPL' });
     * appleOwnership.data.forEach(acquisition => {
     *   console.log(`${acquisition.date}: ${acquisition.insiderName} acquired ${acquisition.sharesAcquired} shares`);
     * });
     *
     * // Get Microsoft's beneficial ownership
     * const msftOwnership = await fmp.insider.getBeneficialOwnership({ symbol: 'MSFT' });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#acquisition-of-beneficial-ownership|FMP Beneficial Ownership Documentation}
     */
    getBeneficialOwnership(params: {
        symbol: string;
        limit?: number;
    }): Promise<APIResponse<BeneficialOwnershipResponse[]>>;
    /**
     * Get fail to deliver data
     *
     * Provides fail to deliver data for a specific company, which indicates
     * when market participants fail to deliver securities on settlement date.
     * Important for understanding market mechanics and potential short interest.
     *
     * @deprecated This endpoint uses API version v4 which will be deprecated.
     *
     * @param params - Fail to deliver request parameters
     * @param params.symbol - Stock symbol to get fail to deliver data for
     * @param params.page - Page number for pagination (default: 0)
     *
     * @returns Promise resolving to array of fail to deliver data
     *
     * @example
     * ```typescript
     * // Get Apple's fail to deliver data
     * const appleFailToDeliver = await fmp.insider.getFailToDeliver({
     *   symbol: 'AAPL',
     *   page: 0
     * });
     * appleFailToDeliver.data.forEach(entry => {
     *   console.log(`${entry.date}: ${entry.shares} shares failed to deliver`);
     * });
     *
     * // Get Microsoft's fail to deliver data
     * const msftFailToDeliver = await fmp.insider.getFailToDeliver({
     *   symbol: 'MSFT',
     *   page: 0
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#fail-to-deliver|FMP Fail to Deliver Documentation}
     */
    getFailToDeliver(params: {
        symbol: string;
        page?: number;
    }): Promise<APIResponse<FailToDeliverResponse[]>>;
    /**
     * Get all insider trades for a symbol (convenience method)
     * @param symbol - The stock symbol to get insider trades for
     * @param page - Page number for pagination (default: 0)
     * @returns A list of insider trades for the specified symbol
     */
    getInsiderTradesBySymbol(symbol: string, page?: number): Promise<APIResponse<InsiderTradingSearchResponse[]>>;
    /**
     * Get insider trades by transaction type (convenience method)
     * @param transactionType - The transaction type to filter by
     * @param page - Page number for pagination (default: 0)
     * @returns A list of insider trades filtered by transaction type
     */
    getInsiderTradesByType(transactionType: TransactionType | string, page?: number): Promise<APIResponse<InsiderTradingSearchResponse[]>>;
    /**
     * Get insider trades by reporting CIK (convenience method)
     * @param reportingCik - The reporting CIK to filter by
     * @param page - Page number for pagination (default: 0)
     * @returns A list of insider trades filtered by reporting CIK
     */
    getInsiderTradesByReportingCik(reportingCik: string, page?: number): Promise<APIResponse<InsiderTradingSearchResponse[]>>;
    /**
     * Get insider trades by company CIK (convenience method)
     * @param companyCik - The company CIK to filter by
     * @param page - Page number for pagination (default: 0)
     * @returns A list of insider trades filtered by company CIK
     */
    getInsiderTradesByCompanyCik(companyCik: string, page?: number): Promise<APIResponse<InsiderTradingSearchResponse[]>>;
}

declare class InstitutionalEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get Form 13F institutional stock ownership data
     *
     * Provides Form 13F institutional stock ownership data for investment
     * managers with over $100 million in assets under management. Essential
     * for analyzing institutional investment patterns and holdings.
     *
     * @param params - Form 13F request parameters
     * @param params.cik - Central Index Key (CIK) of the investment manager
     * @param params.date - Specific date in YYYY-MM-DD format (optional, defaults to most recent filing)
     *
     * @returns Promise resolving to array of Form 13F institutional ownership data
     *
     * @example
     * ```typescript
     * // Get Berkshire Hathaway's Form 13F data
     * const berkshire13F = await fmp.institutional.getForm13F({
     *   cik: '0001067983'
     * });
     * berkshire13F.data.forEach(holding => {
     *   console.log(`${holding.issuerName}: ${holding.value.toLocaleString()} shares, $${holding.value.toLocaleString()}`);
     * });
     *
     * // Get Form 13F data for specific date
     * const historical13F = await fmp.institutional.getForm13F({
     *   cik: '0001067983',
     *   date: '2023-12-31'
     * });
     *
     * // Get BlackRock's Form 13F data
     * const blackrock13F = await fmp.institutional.getForm13F({
     *   cik: '0001364742'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#form-13f-13f---institutional-stock-ownership|FMP Form 13F Documentation}
     */
    getForm13F(params: {
        cik: string;
        date?: string;
    }): Promise<APIResponse<Form13FResponse[]>>;
    /**
     * Get Form 13F filing dates for an investment manager
     *
     * Provides available filing dates for Form 13F submissions by a specific
     * investment manager. Essential for discovering historical filing dates
     * before requesting detailed Form 13F data.
     *
     * @param params - Form 13F dates request parameters
     * @param params.cik - Central Index Key (CIK) of the investment manager
     *
     * @returns Promise resolving to array of available Form 13F filing dates
     *
     * @example
     * ```typescript
     * // Get Berkshire Hathaway's Form 13F filing dates
     * const berkshireDates = await fmp.institutional.getForm13FDates({
     *   cik: '0001067983'
     * });
     * berkshireDates.data.forEach(date => {
     *   console.log(`Filing date: ${date}`);
     * });
     *
     * // Get BlackRock's filing dates
     * const blackrockDates = await fmp.institutional.getForm13FDates({
     *   cik: '0001364742'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#form-13f-dates-13f---institutional-stock-ownership|FMP Form 13F Dates Documentation}
     */
    getForm13FDates(params: {
        cik: string;
    }): Promise<APIResponse<string[]>>;
    /**
     * Get institutional holders for a company
     *
     * Provides data on institutional investors holding shares in a specific
     * company. Essential for understanding institutional ownership patterns,
     * major shareholders, and investment sentiment.
     *
     * @param params - Institutional holders request parameters
     * @param params.symbol - Stock symbol to get institutional holders for
     *
     * @returns Promise resolving to array of institutional holders data
     *
     * @example
     * ```typescript
     * // Get Apple's institutional holders
     * const appleHolders = await fmp.institutional.getInstitutionalHolders({
     *   symbol: 'AAPL'
     * });
     * appleHolders.data.forEach(holder => {
     *   console.log(`${holder.holder}: ${holder.shares.toLocaleString()} shares (${holder.weight}%)`);
     * });
     *
     * // Get Microsoft's institutional holders
     * const msftHolders = await fmp.institutional.getInstitutionalHolders({
     *   symbol: 'MSFT'
     * });
     *
     * // Get Tesla's institutional holders
     * const teslaHolders = await fmp.institutional.getInstitutionalHolders({
     *   symbol: 'TSLA'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#institutional-holder-13f---institutional-stock-ownership|FMP Institutional Holders Documentation}
     */
    getInstitutionalHolders(params: {
        symbol: string;
    }): Promise<APIResponse<InstitutionalHolderResponse[]>>;
}

declare class ListEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get comprehensive list of all available stocks
     *
     * Provides a complete list of all stocks available on major exchanges including
     * NYSE, NASDAQ, and other global markets. Essential for discovering available
     * symbols, building watchlists, or creating stock screening applications.
     *
     * @returns Promise resolving to array of stock data with symbol, name, exchange, and price information
     *
     * @example
     * ```typescript
     * // Get all available stocks
     * const stocks = await fmp.list.getStockList();
     * console.log(`Total stocks available: ${stocks.data.length}`);
     *
     * // Find specific stocks
     * const appleStock = stocks.data.find(stock => stock.symbol === 'AAPL');
     * console.log(`Apple: ${appleStock?.name} (${appleStock?.exchange})`);
     *
     * // Filter by exchange
     * const nasdaqStocks = stocks.data.filter(stock => stock.exchange === 'NASDAQ');
     * console.log(`NASDAQ stocks: ${nasdaqStocks.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#symbol-list-stock-list|FMP Stock List Documentation}
     */
    getStockList(): Promise<APIResponse<StockList[]>>;
    /**
     * Get comprehensive list of all available ETFs
     *
     * Provides a complete list of all Exchange-Traded Funds (ETFs) available for trading.
     * Includes ETFs from various asset classes including equity, bond, commodity, and
     * sector-specific funds. Essential for ETF research and portfolio construction.
     *
     * @returns Promise resolving to array of ETF data with symbol, name, exchange, and asset class information
     *
     * @example
     * ```typescript
     * // Get all available ETFs
     * const etfs = await fmp.list.getETFList();
     * console.log(`Total ETFs available: ${etfs.data.length}`);
     *
     * // Find specific ETFs
     * const spyETF = etfs.data.find(etf => etf.symbol === 'SPY');
     * console.log(`SPY: ${spyETF?.name} (${spyETF?.assetClass})`);
     *
     * // Filter by asset class
     * const equityETFs = etfs.data.filter(etf => etf.assetClass === 'Equity');
     * console.log(`Equity ETFs: ${equityETFs.length}`);
     *
     * // Find sector ETFs
     * const techETFs = etfs.data.filter(etf =>
     *   etf.name.toLowerCase().includes('technology') ||
     *   etf.name.toLowerCase().includes('tech')
     * );
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#exchange-traded-fund-search-stock-list|FMP ETF List Documentation}
     */
    getETFList(): Promise<APIResponse<ETFList[]>>;
    /**
     * Get comprehensive list of all available cryptocurrencies
     *
     * Provides a complete list of all cryptocurrencies available for trading.
     * Includes major cryptocurrencies like Bitcoin, Ethereum, and thousands of altcoins
     * with their trading pairs against USD and other major currencies.
     *
     * @returns Promise resolving to array of cryptocurrency data with symbol, name, and exchange information
     *
     * @example
     * ```typescript
     * // Get all available cryptocurrencies
     * const cryptos = await fmp.list.getCryptoList();
     * console.log(`Total cryptocurrencies available: ${cryptos.data.length}`);
     *
     * // Find major cryptocurrencies
     * const bitcoin = cryptos.data.find(crypto => crypto.symbol === 'BTCUSD');
     * console.log(`Bitcoin: ${bitcoin?.name} (${bitcoin?.exchange})`);
     *
     * const ethereum = cryptos.data.find(crypto => crypto.symbol === 'ETHUSD');
     * console.log(`Ethereum: ${ethereum?.name} (${ethereum?.exchange})`);
     *
     * // Filter by exchange
     * const binanceCryptos = cryptos.data.filter(crypto => crypto.exchange === 'Binance');
     * console.log(`Binance cryptocurrencies: ${binanceCryptos.length}`);
     *
     * // Find altcoins
     * const altcoins = cryptos.data.filter(crypto =>
     *   !['BTCUSD', 'ETHUSD', 'USDTUSD', 'USDCUSD'].includes(crypto.symbol)
     * );
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#cryptocurrencies-list-crypto|FMP Cryptocurrency List Documentation}
     */
    getCryptoList(): Promise<APIResponse<CryptoList[]>>;
    /**
     * Get comprehensive list of all available forex currency pairs
     *
     * Provides a complete list of all foreign exchange currency pairs available for trading.
     * Includes major, minor, and exotic currency pairs with their base and quote currencies.
     * Essential for forex trading, currency analysis, and international market research.
     *
     * @returns Promise resolving to array of forex data with currency pair symbols and exchange information
     *
     * @example
     * ```typescript
     * // Get all available forex pairs
     * const forexPairs = await fmp.list.getForexList();
     * console.log(`Total forex pairs available: ${forexPairs.data.length}`);
     *
     * // Find major currency pairs
     * const eurUsd = forexPairs.data.find(pair => pair.symbol === 'EURUSD');
     * console.log(`EUR/USD: ${eurUsd?.name} (${eurUsd?.exchange})`);
     *
     * const gbpUsd = forexPairs.data.find(pair => pair.symbol === 'GBPUSD');
     * console.log(`GBP/USD: ${gbpUsd?.name} (${gbpUsd?.exchange})`);
     *
     * // Filter major pairs (USD as quote currency)
     * const majorPairs = forexPairs.data.filter(pair =>
     *   pair.symbol.endsWith('USD') && pair.symbol.length === 6
     * );
     * console.log(`Major pairs: ${majorPairs.length}`);
     *
     * // Find exotic pairs
     * const exoticPairs = forexPairs.data.filter(pair =>
     *   pair.symbol.includes('ZAR') || pair.symbol.includes('TRY') || pair.symbol.includes('BRL')
     * );
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#forex-list-forex|FMP Forex List Documentation}
     */
    getForexList(): Promise<APIResponse<ForexList[]>>;
    /**
     * Get comprehensive list of all available market indexes
     *
     * Provides a complete list of all market indexes available for tracking and analysis.
     * Includes major global indexes like S&P 500, NASDAQ, Dow Jones, as well as
     * international indexes, sector indexes, and specialized market benchmarks.
     *
     * @returns Promise resolving to array of index data with symbol, name, and exchange information
     *
     * @example
     * ```typescript
     * // Get all available indexes
     * const indexes = await fmp.list.getAvailableIndexes();
     * console.log(`Total indexes available: ${indexes.data.length}`);
     *
     * // Find major US indexes
     * const sp500 = indexes.data.find(index => index.symbol === '^GSPC');
     * console.log(`S&P 500: ${sp500?.name} (${sp500?.exchange})`);
     *
     * const nasdaq = indexes.data.find(index => index.symbol === '^IXIC');
     * console.log(`NASDAQ: ${nasdaq?.name} (${nasdaq?.exchange})`);
     *
     * const dowJones = indexes.data.find(index => index.symbol === '^DJI');
     * console.log(`Dow Jones: ${dowJones?.name} (${dowJones?.exchange})`);
     *
     * // Filter by exchange
     * const nyseIndexes = indexes.data.filter(index => index.exchange === 'NYSE');
     * console.log(`NYSE indexes: ${nyseIndexes.length}`);
     *
     * // Find sector indexes
     * const techIndexes = indexes.data.filter(index =>
     *   index.name.toLowerCase().includes('technology') ||
     *   index.name.toLowerCase().includes('tech')
     * );
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#available-indexes|FMP Available Indexes Documentation}
     */
    getAvailableIndexes(): Promise<APIResponse<AvailableIndexesList[]>>;
}

declare class MarketEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get current market hours and trading status
     *
     * Provides real-time information about market trading hours, including
     * whether markets are currently open or closed, trading session times,
     * and upcoming market holidays. Essential for determining trading
     * availability and market status.
     *
     * @returns Promise resolving to market hours data with trading status and session information
     *
     * @example
     * ```typescript
     * // Get current market status
     * const marketHours = await fmp.market.getMarketHours();
     * console.log(`Market is ${marketHours.data.isTheStockMarketOpen ? 'OPEN' : 'CLOSED'}`);
     * console.log(`Current time: ${marketHours.data.currentTime}`);
     * console.log(`Next trading day: ${marketHours.data.nextTradingDay}`);
     *
     * // Check if it's a trading day
     * if (marketHours.data.isTheStockMarketOpen) {
     *   console.log('Markets are currently open for trading');
     * } else {
     *   console.log('Markets are closed');
     * }
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#market-hours|FMP Market Hours Documentation}
     */
    getMarketHours(): Promise<APIResponse<MarketHours>>;
    /**
     * Get overall market performance data
     *
     * Provides comprehensive market performance data including major indices,
     * market breadth, and key performance metrics. Essential for understanding
     * overall market sentiment, trends, and daily market activity.
     *
     * @returns Promise resolving to array of market performance data with indices and metrics
     *
     * @example
     * ```typescript
     * // Get overall market performance
     * const marketPerformance = await fmp.market.getMarketPerformance();
     * marketPerformance.data.forEach(market => {
     *   console.log(`${market.index}: ${market.change} (${market.changesPercentage}%)`);
     *   console.log(`  Open: $${market.open}, High: $${market.dayHigh}, Low: $${market.dayLow}`);
     * });
     *
     * // Find specific indices
     * const sp500 = marketPerformance.data.find(market => market.index === 'S&P 500');
     * console.log(`S&P 500 performance: ${sp500?.changesPercentage}%`);
     *
     * // Check market sentiment
     * const gainers = marketPerformance.data.filter(market => market.changesPercentage > 0);
     * const losers = marketPerformance.data.filter(market => market.changesPercentage < 0);
     * console.log(`Gaining indices: ${gainers.length}, Losing indices: ${losers.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#market-index-market-overview|FMP Market Performance Documentation}
     */
    getMarketPerformance(): Promise<APIResponse<MarketPerformance[]>>;
    /**
     * Get top gaining stocks for the current trading day
     *
     * Provides a list of stocks that have gained the most value during the
     * current trading session. Essential for identifying momentum stocks,
     * tracking market movers, and discovering potential investment opportunities.
     * Useful for day trading, momentum strategies, and market analysis.
     *
     * @returns Promise resolving to array of top gaining stocks with price and percentage change data
     *
     * @example
     * ```typescript
     * // Get top gainers for the day
     * const gainers = await fmp.market.getGainers();
     * console.log(`Top ${gainers.data.length} gaining stocks today:`);
     *
     * gainers.data.forEach((stock, index) => {
     *   console.log(`${index + 1}. ${stock.symbol} (${stock.name})`);
     *   console.log(`   Price: $${stock.price} | Change: +${stock.change} (${stock.changesPercentage}%)`);
     *   console.log(`   Volume: ${stock.volume.toLocaleString()}`);
     * });
     *
     * // Find stocks with >10% gains
     * const bigGainers = gainers.data.filter(stock => stock.changesPercentage > 10);
     * console.log(`Stocks with >10% gains: ${bigGainers.length}`);
     *
     * // Check volume leaders among gainers
     * const highVolumeGainers = gainers.data.filter(stock => stock.volume > 1000000);
     * console.log(`High volume gainers (>1M shares): ${highVolumeGainers.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#biggest-gainers|FMP Market Biggest Gainers Documentation}
     */
    getGainers(): Promise<APIResponse<MarketPerformance[]>>;
    /**
     * Get top losing stocks for the current trading day
     *
     * Provides a list of stocks that have lost the most value during the
     * current trading session. Essential for identifying underperforming stocks,
     * tracking market decliners, and discovering potential contrarian opportunities.
     * Useful for risk management, short selling strategies, and market analysis.
     *
     * @returns Promise resolving to array of top losing stocks with price and percentage change data
     *
     * @example
     * ```typescript
     * // Get top losers for the day
     * const losers = await fmp.market.getLosers();
     * console.log(`Top ${losers.data.length} losing stocks today:`);
     *
     * losers.data.forEach((stock, index) => {
     *   console.log(`${index + 1}. ${stock.symbol} (${stock.name})`);
     *   console.log(`   Price: $${stock.price} | Change: ${stock.change} (${stock.changesPercentage}%)`);
     *   console.log(`   Volume: ${stock.volume.toLocaleString()}`);
     * });
     *
     * // Find stocks with >10% losses
     * const bigLosers = losers.data.filter(stock => stock.changesPercentage < -10);
     * console.log(`Stocks with >10% losses: ${bigLosers.length}`);
     *
     * // Check for potential oversold conditions
     * const highVolumeLosers = losers.data.filter(stock => stock.volume > 1000000);
     * console.log(`High volume losers (>1M shares): ${highVolumeLosers.length}`);
     *
     * // Look for potential bounce candidates
     * const oversoldStocks = losers.data.filter(stock =>
     *   stock.changesPercentage < -5 && stock.volume > 500000
     * );
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#biggest-losers|FMP Market Biggest Losers Documentation}
     */
    getLosers(): Promise<APIResponse<MarketPerformance[]>>;
    /**
     * Get most actively traded stocks for the current trading day
     *
     * Provides a list of stocks with the highest trading volume during the
     * current trading session. Essential for identifying stocks with high
     * liquidity, tracking market interest, and discovering stocks with
     * significant trading activity. Useful for day trading and liquidity analysis.
     *
     * @returns Promise resolving to array of most active stocks with volume and price data
     *
     * @example
     * ```typescript
     * // Get most active stocks for the day
     * const mostActive = await fmp.market.getMostActive();
     * console.log(`Top ${mostActive.data.length} most active stocks today:`);
     *
     * mostActive.data.forEach((stock, index) => {
     *   console.log(`${index + 1}. ${stock.symbol} (${stock.name})`);
     *   console.log(`   Volume: ${stock.volume.toLocaleString()} shares`);
     *   console.log(`   Price: $${stock.price} | Change: ${stock.change} (${stock.changesPercentage}%)`);
     *   console.log(`   Avg Volume: ${stock.avgVolume?.toLocaleString() || 'N/A'}`);
     * });
     *
     * // Find stocks with unusual volume (>2x average)
     * const unusualVolume = mostActive.data.filter(stock =>
     *   stock.avgVolume && stock.volume > stock.avgVolume * 2
     * );
     * console.log(`Stocks with unusual volume: ${unusualVolume.length}`);
     *
     * // Check for high volume gainers
     * const highVolumeGainers = mostActive.data.filter(stock =>
     *   stock.changesPercentage > 0 && stock.volume > 1000000
     * );
     * console.log(`High volume gainers: ${highVolumeGainers.length}`);
     *
     * // Find penny stocks with high volume
     * const pennyStocks = mostActive.data.filter(stock =>
     *   stock.price < 5 && stock.volume > 500000
     * );
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#most-active|FMP Market Most Actives Documentation}
     */
    getMostActive(): Promise<APIResponse<MarketPerformance[]>>;
    /**
     * Get sector performance data for the current trading day
     *
     * Provides performance data for all major market sectors including
     * technology, healthcare, financials, energy, and others. Essential for
     * sector rotation analysis, identifying leading/lagging sectors, and
     * understanding market breadth and sector-specific trends.
     *
     * @returns Promise resolving to array of sector performance data with percentage changes
     *
     * @example
     * ```typescript
     * // Get sector performance for the day
     * const sectorPerformance = await fmp.market.getSectorPerformance();
     * console.log(`Sector performance for ${sectorPerformance.data.length} sectors:`);
     *
     * sectorPerformance.data.forEach(sector => {
     *   const changeColor = sector.changesPercentage >= 0 ? 'green' : 'red';
     *   console.log(`${sector.sector}: ${sector.changesPercentage}%`);
     *   console.log(`  Change: ${sector.changesPercentage >= 0 ? '+' : ''}${sector.changesPercentage}%`);
     * });
     *
     * // Find best performing sectors
     * const topSectors = sectorPerformance.data
     *   .sort((a, b) => b.changesPercentage - a.changesPercentage)
     *   .slice(0, 3);
     * console.log('Top 3 performing sectors:');
     * topSectors.forEach((sector, index) => {
     *   console.log(`${index + 1}. ${sector.sector}: ${sector.changesPercentage}%`);
     * });
     *
     * // Find worst performing sectors
     * const bottomSectors = sectorPerformance.data
     *   .sort((a, b) => a.changesPercentage - b.changesPercentage)
     *   .slice(0, 3);
     * console.log('Bottom 3 performing sectors:');
     * bottomSectors.forEach((sector, index) => {
     *   console.log(`${index + 1}. ${sector.sector}: ${sector.changesPercentage}%`);
     * });
     *
     * // Check for sector rotation
     * const gainingSectors = sectorPerformance.data.filter(sector => sector.changesPercentage > 0);
     * const losingSectors = sectorPerformance.data.filter(sector => sector.changesPercentage < 0);
     * console.log(`Sectors gaining: ${gainingSectors.length}, Sectors losing: ${losingSectors.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#sector-performance-market-overview|FMP Sector Performance Documentation}
     */
    getSectorPerformance(): Promise<APIResponse<MarketSectorPerformance[]>>;
    /**
     * Get real-time data for major market indices
     *
     * Provides real-time quote data for all major stock market indices including
     * S&P 500, Dow Jones Industrial Average, NASDAQ Composite, and other global
     * indices. Essential for tracking overall market performance, understanding
     * market sentiment, and identifying broad market trends.
     *
     * @returns Promise resolving to array of market index data with real-time quotes
     *
     * @example
     * ```typescript
     * // Get real-time market indices
     * const marketIndices = await fmp.market.getMarketIndex();
     * console.log(`Real-time data for ${marketIndices.data.length} major indices:`);
     *
     * marketIndices.data.forEach(index => {
     *   console.log(`${index.symbol} (${index.name}):`);
     *   console.log(`  Price: $${index.price}`);
     *   console.log(`  Change: ${index.change} (${index.changesPercentage}%)`);
     *   console.log(`  Day Range: $${index.dayLow} - $${index.dayHigh}`);
     *   console.log(`  Volume: ${index.volume?.toLocaleString() || 'N/A'}`);
     * });
     *
     * // Find specific major indices
     * const sp500 = marketIndices.data.find(index => index.symbol === '^GSPC');
     * const nasdaq = marketIndices.data.find(index => index.symbol === '^IXIC');
     * const dowJones = marketIndices.data.find(index => index.symbol === '^DJI');
     *
     * console.log(`S&P 500: ${sp500?.price} (${sp500?.changesPercentage}%)`);
     * console.log(`NASDAQ: ${nasdaq?.price} (${nasdaq?.changesPercentage}%)`);
     * console.log(`Dow Jones: ${dowJones?.price} (${dowJones?.changesPercentage}%)`);
     *
     * // Check market breadth
     * const gainingIndices = marketIndices.data.filter(index => index.changesPercentage > 0);
     * const losingIndices = marketIndices.data.filter(index => index.changesPercentage < 0);
     * console.log(`Indices gaining: ${gainingIndices.length}, Indices losing: ${losingIndices.length}`);
     *
     * // Find international indices
     * const internationalIndices = marketIndices.data.filter(index =>
     *   !index.symbol.startsWith('^') ||
     *   index.name.toLowerCase().includes('europe') ||
     *   index.name.toLowerCase().includes('asia')
     * );
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#market-index-market-overview|FMP Market Index Documentation}
     */
    getMarketIndex(): Promise<APIResponse<MarketIndex[]>>;
}

declare class MutualFundEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get mutual fund holders of a specific stock
     *
     * Provides data on mutual funds that hold shares in a specific stock.
     * Essential for understanding mutual fund ownership patterns and
     * which mutual funds are invested in particular companies.
     *
     * @param symbol - The stock symbol to get mutual fund holders for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     *
     * @returns Promise resolving to array of mutual fund holders with position details
     *
     * @example
     * ```typescript
     * // Get mutual funds that hold Apple stock
     * const appleHolders = await fmp.mutualFund.getHolders('AAPL');
     * console.log(`${appleHolders.data.length} mutual funds hold AAPL`);
     *
     * appleHolders.data.forEach((holder, index) => {
     *   console.log(`${index + 1}. ${holder.holder}`);
     *   console.log(`   Shares: ${holder.shares?.toLocaleString() || 'N/A'}`);
     *   console.log(`   Weight: ${holder.weightPercent}% | Change: ${holder.change}`);
     * });
     *
     * // Get mutual funds that hold Microsoft stock
     * const msftHolders = await fmp.mutualFund.getHolders('MSFT');
     *
     * // Find top mutual fund holders by shares
     * const topHolders = msftHolders.data
     *   .sort((a, b) => (b.shares || 0) - (a.shares || 0))
     *   .slice(0, 10);
     * console.log('Top 10 mutual fund holders by shares:');
     * topHolders.forEach((holder, index) => {
     *   console.log(`${index + 1}. ${holder.holder}: ${holder.shares.toLocaleString()} shares`);
     * });
     *
     * // Get mutual funds that hold Google stock
     * const googlHolders = await fmp.mutualFund.getHolders('GOOGL');
     *
     * // Analyze mutual fund concentration
     * const totalShares = googlHolders.data.reduce((sum, holder) => sum + (holder.shares || 0), 0);
     * console.log(`Total shares held by mutual funds: ${totalShares.toLocaleString()}`);
     *
     * googlHolders.data.forEach(holder => {
     *   const percentage = ((holder.shares || 0) / totalShares * 100).toFixed(2);
     *   console.log(`${holder.holder}: ${percentage}% of total mutual fund holdings`);
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#mutual-fund-holder-mutual-funds-holdings|FMP Mutual Fund Holders Documentation}
     */
    getHolders(symbol: string): Promise<APIResponse<MutualFundHolding[]>>;
}

declare class NewsEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get FMP's curated financial articles and market insights
     *
     * Retrieves Financial Modeling Prep's own articles covering market analysis,
     * financial insights, and educational content. These articles provide valuable
     * context and analysis beyond raw market data.
     *
     * @param params - Article request parameters
     * @param params.page - Page number for pagination (optional, defaults to 1)
     * @param params.limit - Number of articles per page (optional, defaults to 100)
     *
     * @returns Promise resolving to an array of FMP articles with content and metadata
     *
     * @example
     * ```typescript
     * // Get latest FMP articles
     * const articles = await fmp.news.getArticles({
     *   page: 1,
     *   limit: 10
     * });
     *
     * // Get first page with default limit
     * const latestArticles = await fmp.news.getArticles({ page: 1 });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#fmp-articles|FMP Articles Documentation}
     */
    getArticles(params?: {
        page?: number;
        limit?: number;
    }): Promise<APIResponse<Article[]>>;
    /**
     * Get latest stock market news from various financial sources
     *
     * Retrieves the most recent stock market news articles from multiple financial
     * news sources. Perfect for staying updated on market movements, earnings
     * announcements, and corporate developments.
     *
     * @param params - Stock news request parameters
     * @param params.from - Start date in YYYY-MM-DD format (optional)
     * @param params.to - End date in YYYY-MM-DD format (optional)
     * @param params.page - Page number for pagination (optional, defaults to 1)
     * @param params.limit - Number of articles per page (optional, defaults to 100)
     *
     * @returns Promise resolving to an array of stock news articles with timestamps and sources
     *
     * @example
     * ```typescript
     * // Get latest stock news
     * const stockNews = await fmp.news.getStockNews({
     *   limit: 20
     * });
     *
     * // Get stock news from specific date range
     * const recentNews = await fmp.news.getStockNews({
     *   from: '2024-01-01',
     *   to: '2024-01-15',
     *   limit: 50
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#stock-news|Stock News Documentation}
     */
    getStockNews(params?: {
        from?: string;
        to?: string;
        page?: number;
        limit?: number;
    }): Promise<APIResponse<News[]>>;
    /**
     * Get latest cryptocurrency news from various sources
     *
     * Retrieves the most recent cryptocurrency news articles covering market trends,
     * regulatory updates, technology developments, and major crypto events.
     * Essential for crypto traders and investors.
     *
     * @param params - Crypto news request parameters
     * @param params.from - Start date in YYYY-MM-DD format (optional)
     * @param params.to - End date in YYYY-MM-DD format (optional)
     * @param params.page - Page number for pagination (optional, defaults to 1)
     * @param params.limit - Number of articles per page (optional, defaults to 100)
     *
     * @returns Promise resolving to an array of cryptocurrency news articles
     *
     * @example
     * ```typescript
     * // Get latest crypto news
     * const cryptoNews = await fmp.news.getCryptoNews({
     *   limit: 15
     * });
     *
     * // Get crypto news from last week
     * const weeklyCryptoNews = await fmp.news.getCryptoNews({
     *   from: '2024-01-08',
     *   to: '2024-01-15'
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#crypto-news|Crypto News Documentation}
     */
    getCryptoNews(params?: {
        from?: string;
        to?: string;
        page?: number;
        limit?: number;
    }): Promise<APIResponse<News[]>>;
    /**
     * Get latest forex (foreign exchange) market news
     *
     * Retrieves the most recent forex market news covering currency movements,
     * central bank announcements, economic indicators, and geopolitical events
     * that impact currency markets.
     *
     * @param params - Forex news request parameters
     * @param params.from - Start date in YYYY-MM-DD format (optional)
     * @param params.to - End date in YYYY-MM-DD format (optional)
     * @param params.page - Page number for pagination (optional, defaults to 1)
     * @param params.limit - Number of articles per page (optional, defaults to 100)
     *
     * @returns Promise resolving to an array of forex news articles
     *
     * @example
     * ```typescript
     * // Get latest forex news
     * const forexNews = await fmp.news.getForexNews({
     *   limit: 25
     * });
     *
     * // Get forex news from specific period
     * const forexUpdates = await fmp.news.getForexNews({
     *   from: '2024-01-10',
     *   limit: 30
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#forex-news|Forex News Documentation}
     */
    getForexNews(params?: {
        from?: string;
        to?: string;
        page?: number;
        limit?: number;
    }): Promise<APIResponse<News[]>>;
    /**
     * Get stock news filtered by specific company symbols
     *
     * Retrieves news articles specifically related to the provided stock symbols.
     * Perfect for monitoring news about specific companies in your portfolio or
     * watchlist. Supports multiple symbols for efficient batch news retrieval.
     *
     * @param params - Symbol-specific stock news request parameters
     * @param params.symbols - Array of stock symbols to get news for (required)
     * @param params.from - Start date in YYYY-MM-DD format (optional)
     * @param params.to - End date in YYYY-MM-DD format (optional)
     * @param params.page - Page number for pagination (optional, defaults to 1)
     * @param params.limit - Number of articles per page (optional, defaults to 100)
     *
     * @returns Promise resolving to an array of news articles filtered by the specified symbols
     *
     * @example
     * ```typescript
     * // Get news for specific stocks
     * const appleNews = await fmp.news.getStockNewsBySymbol({
     *   symbols: ['AAPL'],
     *   limit: 10
     * });
     *
     * // Get news for multiple tech stocks
     * const techNews = await fmp.news.getStockNewsBySymbol({
     *   symbols: ['AAPL', 'MSFT', 'GOOGL', 'AMZN'],
     *   from: '2024-01-01',
     *   limit: 20
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#search-stock-news|Search Stock News Documentation}
     */
    getStockNewsBySymbol(params: {
        symbols: string[];
        from?: string;
        to?: string;
        page?: number;
        limit?: number;
    }): Promise<APIResponse<News[]>>;
    /**
     * Get cryptocurrency news filtered by specific crypto symbols
     *
     * Retrieves news articles specifically related to the provided cryptocurrency
     * symbols. Ideal for monitoring news about specific cryptocurrencies in your
     * portfolio or tracking particular digital assets.
     *
     * @param params - Symbol-specific crypto news request parameters
     * @param params.symbols - Array of cryptocurrency symbols to get news for (required)
     * @param params.from - Start date in YYYY-MM-DD format (optional)
     * @param params.to - End date in YYYY-MM-DD format (optional)
     * @param params.page - Page number for pagination (optional, defaults to 1)
     * @param params.limit - Number of articles per page (optional, defaults to 100)
     *
     * @returns Promise resolving to an array of news articles filtered by the specified crypto symbols
     *
     * @example
     * ```typescript
     * // Get news for Bitcoin
     * const bitcoinNews = await fmp.news.getCryptoNewsBySymbol({
     *   symbols: ['BTCUSD'],
     *   limit: 15
     * });
     *
     * // Get news for multiple cryptocurrencies
     * const cryptoNews = await fmp.news.getCryptoNewsBySymbol({
     *   symbols: ['BTCUSD', 'ETHUSD', 'ADAUSD'],
     *   from: '2024-01-01',
     *   limit: 25
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#search-crypto-news|Search Crypto News Documentation}
     */
    getCryptoNewsBySymbol(params: {
        symbols: string[];
        from?: string;
        to?: string;
        page?: number;
        limit?: number;
    }): Promise<APIResponse<News[]>>;
    /**
     * Get forex news filtered by specific currency pair symbols
     *
     * Retrieves news articles specifically related to the provided forex currency
     * pairs. Perfect for monitoring news about specific currency pairs you're
     * trading or analyzing for forex market movements.
     *
     * @param params - Symbol-specific forex news request parameters
     * @param params.symbols - Array of forex currency pair symbols to get news for (required)
     * @param params.from - Start date in YYYY-MM-DD format (optional)
     * @param params.to - End date in YYYY-MM-DD format (optional)
     * @param params.page - Page number for pagination (optional, defaults to 1)
     * @param params.limit - Number of articles per page (optional, defaults to 100)
     *
     * @returns Promise resolving to an array of news articles filtered by the specified forex symbols
     *
     * @example
     * ```typescript
     * // Get news for EUR/USD pair
     * const eurUsdNews = await fmp.news.getForexNewsBySymbol({
     *   symbols: ['EURUSD'],
     *   limit: 10
     * });
     *
     * // Get news for multiple currency pairs
     * const forexNews = await fmp.news.getForexNewsBySymbol({
     *   symbols: ['EURUSD', 'GBPUSD', 'USDJPY'],
     *   from: '2024-01-01',
     *   limit: 20
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#search-forex-news|Search Forex News Documentation}
     */
    getForexNewsBySymbol(params: {
        symbols: string[];
        from?: string;
        to?: string;
        page?: number;
        limit?: number;
    }): Promise<APIResponse<News[]>>;
}

declare class QuoteEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get real-time quote data for any asset type (stocks, crypto, forex, commodities, ETFs)
     *
     * This endpoint provides current market data including price, volume, market cap, and key metrics.
     * Works with any valid symbol across all supported asset classes.
     *
     * @param symbol - The trading symbol (e.g., 'AAPL', 'BTCUSD', 'EURUSD', 'GCUSD', 'SPY')
     *
     * @returns Promise resolving to quote data with current price, volume, market cap, and performance metrics
     *
     * @example
     * ```typescript
     * // Get stock quote
     * const aaplQuote = await fmp.quote.getQuote('AAPL');
     *
     * // Get crypto quote
     * const btcQuote = await fmp.quote.getQuote('BTCUSD');
     *
     * // Get forex quote
     * const eurQuote = await fmp.quote.getQuote('EURUSD');
     * ```
     */
    getQuote(symbol: string): Promise<APIResponse<Quote>>;
    /**
     * Get historical price data for any asset type with customizable date range
     *
     * Retrieves daily OHLCV (Open, High, Low, Close, Volume) data for the specified symbol.
     * Data includes adjusted close prices, volume, and percentage changes.
     *
     * @param params - Historical price request parameters
     * @param params.symbol - The trading symbol to get historical data for
     * @param params.from - Start date in YYYY-MM-DD format (optional, defaults to 1 year ago)
     * @param params.to - End date in YYYY-MM-DD format (optional, defaults to today)
     *
     * @returns Promise resolving to historical price data with daily OHLCV information
     *
     * @example
     * ```typescript
     * // Get last year's data
     * const history = await fmp.quote.getHistoricalPrice({
     *   symbol: 'AAPL',
     *   from: '2023-01-01',
     *   to: '2023-12-31'
     * });
     *
     * // Get recent data (last 30 days)
     * const recent = await fmp.quote.getHistoricalPrice({
     *   symbol: 'BTCUSD',
     *   from: '2024-01-01'
     * });
     * ```
     */
    getHistoricalPrice(params: {
        symbol: string;
        from?: string;
        to?: string;
    }): Promise<APIResponse<HistoricalPriceResponse>>;
    /**
     * Get real-time quotes for multiple symbols in a single request
     *
     * Efficiently retrieve quote data for multiple assets across different asset classes.
     * Useful for portfolio tracking, market monitoring, or batch data collection.
     *
     * @param symbols - Array of trading symbols to get quotes for
     *
     * @returns Promise resolving to an array of quote data for all requested symbols
     *
     * @example
     * ```typescript
     * // Get quotes for a mixed portfolio
     * const quotes = await fmp.quote.getQuotes([
     *   'AAPL',    // Stock
     *   'BTCUSD',  // Crypto
     *   'EURUSD',  // Forex
     *   'SPY'      // ETF
     * ]);
     *
     * // Get quotes for tech stocks
     * const techQuotes = await fmp.quote.getQuotes([
     *   'AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA'
     * ]);
     * ```
     */
    getQuotes(symbols: string[]): Promise<APIResponse<Quote[]>>;
    /**
     * Get intraday price data with customizable time intervals
     *
     * Retrieves intraday OHLCV data at specified intervals (1min to 4hour).
     * Perfect for technical analysis, day trading, or short-term price monitoring.
     *
     * @param params - Intraday request parameters
     * @param params.symbol - The trading symbol to get intraday data for
     * @param params.interval - Time interval: '1min', '5min', '15min', '30min', '1hour', or '4hour'
     * @param params.from - Start date in YYYY-MM-DD format (optional)
     * @param params.to - End date in YYYY-MM-DD format (optional)
     *
     * @returns Promise resolving to intraday price data with OHLCV information at specified intervals
     *
     * @example
     * ```typescript
     * // Get 5-minute intraday data for today
     * const intraday = await fmp.quote.getIntraday({
     *   symbol: 'AAPL',
     *   interval: '5min',
     *   from: '2024-01-15'
     * });
     *
     * // Get 1-hour data for crypto
     * const cryptoIntraday = await fmp.quote.getIntraday({
     *   symbol: 'BTCUSD',
     *   interval: '1hour',
     *   from: '2024-01-10',
     *   to: '2024-01-15'
     * });
     * ```
     */
    getIntraday(params: {
        symbol: string;
        interval: '1min' | '5min' | '15min' | '30min' | '1hour' | '4hour';
        from?: string;
        to?: string;
    }): Promise<APIResponse<HistoricalPriceData[]>>;
}

declare class ScreenerEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Screen companies based on customizable financial criteria
     *
     * This endpoint allows you to filter and search for companies based on various financial metrics,
     * market data, and company characteristics. Perfect for finding investment opportunities,
     * conducting market research, or building custom stock filters.
     *
     * @param params - Screening criteria and filters
     * @param params.marketCapMoreThan - Minimum market capitalization
     * @param params.marketCapLowerThan - Maximum market capitalization
     * @param params.priceMoreThan - Minimum stock price
     * @param params.priceLowerThan - Maximum stock price
     * @param params.betaMoreThan - Minimum beta value
     * @param params.betaLowerThan - Maximum beta value
     * @param params.volumeMoreThan - Minimum trading volume
     * @param params.volumeLowerThan - Maximum trading volume
     * @param params.dividendMoreThan - Minimum dividend yield
     * @param params.dividendLowerThan - Maximum dividend yield
     * @param params.isEtf - Filter for ETFs only
     * @param params.isActivelyTrading - Filter for actively trading stocks
     * @param params.sector - Filter by specific sector
     * @param params.industry - Filter by specific industry
     * @param params.country - Filter by specific country
     * @param params.exchange - Filter by specific exchange
     * @param params.limit - Maximum number of results to return
     *
     * @returns Promise resolving to an array of companies matching the screening criteria
     *
     * @example
     * ```typescript
     * // Find large-cap tech stocks
     * const techStocks = await fmp.screener.getScreener({
     *   marketCapMoreThan: 10000000000, // $10B+
     *   sector: 'Technology',
     *   isActivelyTrading: true,
     *   limit: 50
     * });
     *
     * // Find dividend-paying stocks
     * const dividendStocks = await fmp.screener.getScreener({
     *   dividendMoreThan: 0.03, // 3%+ dividend yield
     *   marketCapMoreThan: 1000000000, // $1B+ market cap
     *   isActivelyTrading: true
     * });
     *
     * // Find small-cap value stocks
     * const smallCapValue = await fmp.screener.getScreener({
     *   marketCapLowerThan: 2000000000, // Under $2B
     *   priceMoreThan: 5, // Above $5
     *   betaLowerThan: 1.2, // Lower volatility
     *   limit: 100
     * });
     * ```
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#search-company-screener|FMP Income Statement Documentation}
     */
    getScreener(params: ScreenerParams): Promise<APIResponse<Screener[]>>;
    /**
     * Get list of available stock exchanges for screening
     *
     * Retrieves all supported stock exchanges that can be used as filters
     * in the company screener. Useful for building dynamic filter options
     * or validating exchange parameters.
     *
     * @returns Promise resolving to an array of available exchanges with their details
     *
     * @example
     * ```typescript
     * // Get all available exchanges
     * const exchanges = await fmp.screener.getAvailableExchanges();
     *
     * // Use in screener filter
     * const nasdaqStocks = await fmp.screener.getScreener({
     *   exchange: 'NASDAQ',
     *   marketCapMoreThan: 1000000000
     * });
     * ```
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#available-exchanges|FMP Income Statement Documentation}
     */
    getAvailableExchanges(): Promise<APIResponse<AvailableExchanges[]>>;
    /**
     * Get list of available sectors for screening
     *
     * Retrieves all supported business sectors that can be used as filters
     * in the company screener. Essential for sector-based analysis and
     * building comprehensive screening tools.
     *
     * @returns Promise resolving to an array of available sectors with their details
     *
     * @example
     * ```typescript
     * // Get all available sectors
     * const sectors = await fmp.screener.getAvailableSectors();
     *
     * // Screen by specific sector
     * const healthcareStocks = await fmp.screener.getScreener({
     *   sector: 'Healthcare',
     *   marketCapMoreThan: 5000000000
     * });
     * ```
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#available-sectors|FMP Income Statement Documentation}
     */
    getAvailableSectors(): Promise<APIResponse<AvailableSectors[]>>;
    /**
     * Get list of available industries for screening
     *
     * Retrieves all supported industries that can be used as filters
     * in the company screener. Provides more granular filtering than
     * sectors for detailed industry analysis.
     *
     * @returns Promise resolving to an array of available industries with their details
     *
     * @example
     * ```typescript
     * // Get all available industries
     * const industries = await fmp.screener.getAvailableIndustries();
     *
     * // Screen by specific industry
     * const softwareStocks = await fmp.screener.getScreener({
     *   industry: 'Software—Application',
     *   isActivelyTrading: true,
     *   limit: 25
     * });
     * ```
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#available-industries|FMP Income Statement Documentation}
     */
    getAvailableIndustries(): Promise<APIResponse<AvailableIndustries[]>>;
    /**
     * Get list of available countries for screening
     *
     * Retrieves all supported countries that can be used as filters
     * in the company screener. Useful for geographic analysis and
     * international market screening.
     *
     * @returns Promise resolving to an array of available countries with their details
     *
     * @example
     * ```typescript
     * // Get all available countries
     * const countries = await fmp.screener.getAvailableCountries();
     *
     * // Screen by specific country
     * const usStocks = await fmp.screener.getScreener({
     *   country: 'US',
     *   marketCapMoreThan: 1000000000,
     *   isActivelyTrading: true
     * });
     * ```
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#available-countries|FMP Income Statement Documentation}
     */
    getAvailableCountries(): Promise<APIResponse<AvailableCountries[]>>;
}

declare class SECEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get RSS feed of SEC filings
     *
     * Provides a real-time feed of SEC filings from publicly traded companies,
     * including filing types, links to SEC pages, and direct links to filings.
     * Essential for staying up-to-date on the latest SEC filings for all companies
     * or for monitoring specific companies' regulatory activities.
     *
     * @param params - RSS feed parameters (optional)
     * @returns Promise resolving to array of RSS feed items with SEC filing information
     *
     * @example
     * ```typescript
     * // Get all recent SEC filings
     * const allFilings = await fmp.sec.getRSSFeed();
     * console.log(`Recent SEC filings: ${allFilings.data.length}`);
     *
     * // Get specific filing type
     * const form4Filings = await fmp.sec.getRSSFeed({ type: '4' });
     * console.log(`Form 4 filings: ${form4Filings.data.length}`);
     *
     * // Get filings with date range
     * const recentFilings = await fmp.sec.getRSSFeed({
     *   from: '2024-01-01',
     *   to: '2024-01-31'
     * });
     * console.log(`Recent filings: ${recentFilings.data.length}`);
     *
     * // Get limited results
     * const limitedFilings = await fmp.sec.getRSSFeed({ limit: 10 });
     * console.log(`Limited filings: ${limitedFilings.data.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#rss-feed-securities-and-exchange-commission-(s.e.c)|FMP RSS Feed Documentation}
     */
    getRSSFeed(params?: {
        limit?: number;
        type?: string;
        from?: string;
        to?: string;
        isDone?: boolean;
    }): Promise<APIResponse<RSSFeedItem[]>>;
    /**
     * Get comprehensive RSS feed of all SEC filings
     *
     * Provides a comprehensive real-time feed of all SEC filings from publicly
     * traded companies in the latest RSS feed format. This endpoint offers the
     * most complete overview of SEC filings with enhanced metadata and formatting.
     *
     * @param params - RSS feed all parameters (optional)
     * @returns Promise resolving to array of comprehensive RSS feed items with enhanced SEC filing information
     *
     * @example
     * ```typescript
     * // Get all comprehensive SEC filings
     * const allFilings = await fmp.sec.getRSSFeedAll();
     * console.log(`Comprehensive SEC filings: ${allFilings.data.length}`);
     *
     * // Get paginated results
     * const page2Filings = await fmp.sec.getRSSFeedAll({ page: 1 });
     * console.log(`Page 2 filings: ${page2Filings.data.length}`);
     *
     * // Get specific data type
     * const specificData = await fmp.sec.getRSSFeedAll({ datatype: 'json' });
     * console.log(`Specific data type filings: ${specificData.data.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#rss-feed-all-securities-and-exchange-commission-(s.e.c)|FMP RSS Feed All Documentation}
     */
    getRSSFeedAll(params?: {
        page?: number;
        datatype?: string;
    }): Promise<APIResponse<RSSFeedAllItem[]>>;
    /**
     * Get RSS feed V3 of SEC filings
     *
     * Provides a real-time feed of SEC filings from publicly traded companies
     * in the V3 RSS feed format. This version offers enhanced metadata and
     * improved structure for better parsing and analysis of SEC filings.
     *
     * @param params - RSS feed V3 parameters (optional)
     * @returns Promise resolving to array of V3 RSS feed items with enhanced SEC filing information
     *
     * @example
     * ```typescript
     * // Get V3 format SEC filings
     * const v3Filings = await fmp.sec.getRSSFeedV3();
     * console.log(`V3 SEC filings: ${v3Filings.data.length}`);
     *
     * // Get paginated V3 results
     * const page2V3 = await fmp.sec.getRSSFeedV3({ page: 1 });
     * console.log(`Page 2 V3 filings: ${page2V3.data.length}`);
     *
     * // Get specific data type
     * const specificV3 = await fmp.sec.getRSSFeedV3({ datatype: 'json' });
     * console.log(`Specific V3 data type: ${specificV3.data.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#rss-feed-v3-securities-and-exchange-commission-(s.e.c)|FMP RSS Feed V3 Documentation}
     */
    getRSSFeedV3(params?: {
        page?: number;
        datatype?: string;
    }): Promise<APIResponse<RSSFeedV3Item[]>>;
    /**
     * Get RSS feed of 8-K SEC filings
     *
     * Provides a real-time feed specifically for 8-K SEC filings from publicly
     * traded companies. 8-K filings are used to announce major events that
     * shareholders should know about, such as earnings releases, mergers,
     * acquisitions, and other material events.
     *
     * @param params - RSS feed 8-K parameters (optional)
     * @returns Promise resolving to array of 8-K RSS feed items with material event information
     *
     * @example
     * ```typescript
     * // Get all 8-K filings
     * const form8KFilings = await fmp.sec.getRSSFeed8K();
     * console.log(`8-K filings: ${form8KFilings.data.length}`);
     *
     * // Get 8-K filings with date range
     * const recent8K = await fmp.sec.getRSSFeed8K({
     *   from: '2024-01-01',
     *   to: '2024-01-31'
     * });
     * console.log(`Recent 8-K filings: ${recent8K.data.length}`);
     *
     * // Get 8-K filings with financials
     * const financial8K = await fmp.sec.getRSSFeed8K({ hasFinancial: true });
     * console.log(`8-K filings with financials: ${financial8K.data.length}`);
     *
     * // Get limited 8-K results
     * const limited8K = await fmp.sec.getRSSFeed8K({ limit: 10 });
     * console.log(`Limited 8-K filings: ${limited8K.data.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#rss-feed-8-k-securities-and-exchange-commission-(s.e.c)|FMP RSS Feed 8-K Documentation}
     */
    getRSSFeed8K(params?: {
        page?: number;
        from?: string;
        to?: string;
        hasFinancial?: boolean;
        limit?: number;
    }): Promise<APIResponse<RSSFeed8KItem[]>>;
    /**
     * Get SEC filings for a specific company
     *
     * Provides direct access to SEC filings for a specific company, including
     * filing types, links to SEC pages, and direct links to specific filings.
     * Essential for monitoring a company's regulatory compliance and staying
     * informed about important corporate events and disclosures.
     *
     * @param symbol - The stock symbol to get SEC filings for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     * @param params - SEC filings parameters (optional)
     * @returns Promise resolving to array of SEC filings with detailed filing information
     *
     * @example
     * ```typescript
     * // Get all SEC filings for Apple
     * const appleFilings = await fmp.sec.getSECFilings({ symbol: 'AAPL' });
     * console.log(`Apple SEC filings: ${appleFilings.data.length}`);
     *
     * // Get specific filing type for Microsoft
     * const msftForm4 = await fmp.sec.getSECFilings({
     *   symbol: 'MSFT',
     *   params: { type: '4' }
     * });
     * console.log(`Microsoft Form 4 filings: ${msftForm4.data.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#sec-filings-securities-and-exchange-commission-(s.e.c)|FMP SEC Filings Documentation}
     */
    getSECFilings({ symbol, params, }: {
        symbol: string;
        params?: {
            type?: string;
            page?: number;
        };
    }): Promise<APIResponse<SECFiling[]>>;
    /**
     * Get individual industry classification for a company
     *
     * Provides the industry classification for a specific company based on the
     * Standard Industrial Classification (SIC) system. Essential for understanding
     * a company's business sector, industry peers, and market positioning.
     *
     * @param params - Industry classification parameters
     * @returns Promise resolving to industry classification data with SIC code and description
     *
     * @example
     * ```typescript
     * // Get Apple's industry classification by symbol
     * const appleIndustry = await fmp.sec.getIndividualIndustryClassification({ symbol: 'AAPL' });
     * console.log(`Apple Industry: ${appleIndustry.data.industryTitle}`);
     * console.log(`SIC Code: ${appleIndustry.data.sicCode}`);
     *
     * // Get industry classification by CIK
     * const cikIndustry = await fmp.sec.getIndividualIndustryClassification({ cik: 320193 });
     * console.log(`CIK Industry: ${cikIndustry.data.industryTitle}`);
     *
     * // Get industry classification by SIC code
     * const sicIndustry = await fmp.sec.getIndividualIndustryClassification({ sicCode: 3571 });
     * console.log(`SIC Industry: ${sicIndustry.data.industryTitle}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#individual-industry-classification-standard-industrial-classification|FMP Individual Industry Classification Documentation}
     */
    getIndividualIndustryClassification(params: {
        symbol?: string;
        cik?: string;
        sicCode?: number;
    }): Promise<APIResponse<IndustryClassification>>;
    /**
     * Get all industry classifications
     *
     * Provides a comprehensive overview of all industries classified according
     * to the Standard Industrial Classification (SIC) system. Essential for
     * understanding industry categories, sector analysis, and market research.
     *
     * @returns Promise resolving to array of all industry classifications with SIC codes and descriptions
     *
     * @example
     * ```typescript
     * // Get all industry classifications
     * const allIndustries = await fmp.sec.getAllIndustryClassifications();
     * console.log(`Total industries: ${allIndustries.data.length}`);
     *
     * allIndustries.data.forEach((industry, index) => {
     *   console.log(`${index + 1}. ${industry.industryTitle}`);
     *   console.log(`   SIC Code: ${industry.sicCode}`);
     * });
     *
     * // Find specific industry
     * const techIndustry = allIndustries.data.find(industry =>
     *   industry.industryTitle.toLowerCase().includes('computer')
     * );
     * console.log(`Tech Industry: ${techIndustry?.industryTitle}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#all-industry-classification-standard-industrial-classification|FMP All Industry Classifications Documentation}
     */
    getAllIndustryClassifications(): Promise<APIResponse<IndustryClassification[]>>;
    /**
     * Get industry classification codes
     *
     * Provides detailed information about the Standard Industrial Classification
     * (SIC) system and helps identify SIC codes for specific industries.
     * Essential for understanding industry categorization and sector analysis.
     *
     * @param params - Industry classification codes parameters
     * @returns Promise resolving to array of industry classification codes with detailed information
     *
     * @example
     * ```typescript
     * // Get all industry classification codes
     * const allCodes = await fmp.sec.getIndustryClassificationCodes({});
     * console.log(`Total SIC codes: ${allCodes.data.length}`);
     *
     * // Search for specific SIC code
     * const code3571 = await fmp.sec.getIndustryClassificationCodes({ sicCode: 3571 });
     * console.log(`SIC 3571: ${code3571.data[0]?.industryTitle}`);
     *
     * // Search for industry by title
     * const computerIndustry = await fmp.sec.getIndustryClassificationCodes({ industryTitle: 'Computer' });
     * console.log(`Computer-related industries: ${computerIndustry.data.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#industry-classification-codes-standard-industrial-classification|FMP Industry Classification Codes Documentation}
     */
    getIndustryClassificationCodes(params: {
        industryTitle?: string;
        sicCode?: number;
    }): Promise<APIResponse<IndustryClassificationCode[]>>;
}

declare class SenateHouseEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get senate trading data for a specific stock symbol
     *
     * Provides detailed information about senate members' trading activities for a specific stock.
     * Includes transaction details, amounts, dates, and ownership information for transparency
     * and compliance with the STOCK Act (Stop Trading on Congressional Knowledge).
     *
     * @param params - Senate trading request parameters
     * @param params.symbol - The stock symbol to get senate trading data for (e.g., 'AAPL', 'MSFT', 'TSLA')
     *
     * @returns Promise resolving to array of senate trading data with transaction details
     *
     * @example
     * ```typescript
     * // Get senate trading data for Apple
     * const appleSenateTrading = await fmp.senateHouse.getSenateTrading({ symbol: 'AAPL' });
     * appleSenateTrading.data.forEach(trade => {
     *   console.log(`${trade.firstName} ${trade.lastName} (${trade.office}):`);
     *   console.log(`  ${trade.type} ${trade.amount} of ${trade.assetDescription}`);
     *   console.log(`  Transaction Date: ${trade.transactionDate}`);
     * });
     *
     * // Get senate trading data for Tesla
     * const teslaSenateTrading = await fmp.senateHouse.getSenateTrading({ symbol: 'TSLA' });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#senate-trading|FMP Senate Trading Documentation}
     */
    getSenateTrading(params: {
        symbol: string;
    }): Promise<APIResponse<SenateTradingResponse[]>>;
    /**
     * Get senate trading RSS feed with pagination
     *
     * Provides a paginated RSS feed of all senate trading activities across all stocks.
     * Useful for monitoring congressional trading activities, compliance tracking,
     * and transparency reporting. Returns recent trading disclosures from senate members.
     *
     * @param params - Senate trading RSS feed request parameters
     * @param params.page - The page number to retrieve (starts from 0)
     *
     * @returns Promise resolving to array of senate trading data from RSS feed
     *
     * @example
     * ```typescript
     * // Get first page of senate trading RSS feed
     * const firstPage = await fmp.senateHouse.getSenateTradingRSSFeed({ page: 0 });
     * console.log(`First page: ${firstPage.data.length} trading activities`);
     *
     * // Get second page of senate trading RSS feed
     * const secondPage = await fmp.senateHouse.getSenateTradingRSSFeed({ page: 1 });
     * console.log(`Second page: ${secondPage.data.length} trading activities`);
     *
     * // Get recent senate trading activities
     * const recentTrades = await fmp.senateHouse.getSenateTradingRSSFeed({ page: 0 });
     * recentTrades.data.forEach(trade => {
     *   console.log(`${trade.firstName} ${trade.lastName}: ${trade.type} ${trade.amount}`);
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#senate-latest|FMP Senate Trading RSS Feed Documentation}
     */
    getSenateTradingRSSFeed(params: {
        page: number;
        limit?: number;
    }): Promise<APIResponse<SenateTradingResponse[]>>;
    /**
     * Get senate trading data for a specific senator by name
     *
     * Provides detailed trading activities for a specific senate member across all stocks.
     * Useful for tracking individual senator's trading patterns, compliance monitoring,
     * and transparency reporting. Returns all trading disclosures for the specified senator.
     *
     * @param params - Senate trading by name request parameters
     * @param params.name - The name of the senator to get trading data for (e.g., 'John Smith', 'Jane Doe')
     *
     * @returns Promise resolving to array of senate trading data for the specified senator
     *
     * @example
     * ```typescript
     * // Get trading data for Senator John Smith
     * const johnSmithTrades = await fmp.senateHouse.getSenateTradingByName({ name: 'John Smith' });
     * johnSmithTrades.data.forEach(trade => {
     *   console.log(`${trade.symbol}: ${trade.type} ${trade.amount}`);
     *   console.log(`  Transaction Date: ${trade.transactionDate}`);
     *   console.log(`  Asset: ${trade.assetDescription}`);
     * });
     *
     * // Get trading data for Senator Jane Doe
     * const janeDoeTrades = await fmp.senateHouse.getSenateTradingByName({ name: 'Jane Doe' });
     * console.log(`Jane Doe has ${janeDoeTrades.data.length} trading activities`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#senate-trading-by-name|FMP Senate Trading by Name Documentation}
     */
    getSenateTradingByName(params: {
        name: string;
    }): Promise<APIResponse<SenateHouseTradingByNameResponse[]>>;
    /**
     * Get house trading data for a specific stock symbol
     *
     * Provides detailed information about house representatives' trading activities for a specific stock.
     * Includes transaction details, amounts, dates, and district information for transparency
     * and compliance with the STOCK Act (Stop Trading on Congressional Knowledge).
     *
     * @param params - House trading request parameters
     * @param params.symbol - The stock symbol to get house trading data for (e.g., 'AAPL', 'MSFT', 'TSLA')
     *
     * @returns Promise resolving to array of house trading data with transaction details
     *
     * @example
     * ```typescript
     * // Get house trading data for Apple
     * const appleHouseTrading = await fmp.senateHouse.getHouseTrading({ symbol: 'AAPL' });
     * appleHouseTrading.data.forEach(trade => {
     *   console.log(`${trade.representative} (District ${trade.district}):`);
     *   console.log(`  ${trade.type} ${trade.amount} of ${trade.assetDescription}`);
     *   console.log(`  Transaction Date: ${trade.transactionDate}`);
     * });
     *
     * // Get house trading data for Microsoft
     * const msftHouseTrading = await fmp.senateHouse.getHouseTrading({ symbol: 'MSFT' });
     * console.log(`Microsoft house trading activities: ${msftHouseTrading.data.length}`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#house-trading|FMP House Trading Documentation}
     */
    getHouseTrading(params: {
        symbol: string;
    }): Promise<APIResponse<HouseTradingResponse[]>>;
    /**
     * Get house trading RSS feed with pagination
     *
     * Provides a paginated RSS feed of all house trading activities across all stocks.
     * Useful for monitoring congressional trading activities, compliance tracking,
     * and transparency reporting. Returns recent trading disclosures from house representatives.
     *
     * @param params - House trading RSS feed request parameters
     * @param params.page - The page number to retrieve (starts from 0)
     *
     * @returns Promise resolving to array of house trading data from RSS feed
     *
     * @example
     * ```typescript
     * // Get first page of house trading RSS feed
     * const firstPage = await fmp.senateHouse.getHouseTradingRSSFeed({ page: 0 });
     * console.log(`First page: ${firstPage.data.length} trading activities`);
     *
     * // Get second page of house trading RSS feed
     * const secondPage = await fmp.senateHouse.getHouseTradingRSSFeed({ page: 1 });
     * console.log(`Second page: ${secondPage.data.length} trading activities`);
     *
     * // Get recent house trading activities
     * const recentTrades = await fmp.senateHouse.getHouseTradingRSSFeed({ page: 0 });
     * recentTrades.data.forEach(trade => {
     *   console.log(`${trade.representative} (District ${trade.district}): ${trade.type} ${trade.amount}`);
     * });
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#house-latest|FMP House Trading RSS Feed Documentation}
     */
    getHouseTradingRSSFeed(params: {
        page: number;
        limit?: number;
    }): Promise<APIResponse<HouseTradingResponse[]>>;
    /**
     * Get house trading data for a specific representative by name
     *
     * Provides detailed trading activities for a specific house representative across all stocks.
     * Useful for tracking individual representative's trading patterns, compliance monitoring,
     * and transparency reporting. Returns all trading disclosures for the specified representative.
     *
     * @param params - House trading by name request parameters
     * @param params.name - The name of the representative to get trading data for (e.g., 'John Smith', 'Jane Doe')
     *
     * @returns Promise resolving to array of house trading data for the specified representative
     *
     * @example
     * ```typescript
     * // Get trading data for Representative John Smith
     * const johnSmithTrades = await fmp.senateHouse.getHouseTradingByName({ name: 'John Smith' });
     * johnSmithTrades.data.forEach(trade => {
     *   console.log(`${trade.symbol}: ${trade.type} ${trade.amount}`);
     *   console.log(`  Transaction Date: ${trade.transactionDate}`);
     *   console.log(`  Asset: ${trade.assetDescription}`);
     *   console.log(`  District: ${trade.district}`);
     * });
     *
     * // Get trading data for Representative Jane Doe
     * const janeDoeTrades = await fmp.senateHouse.getHouseTradingByName({ name: 'Jane Doe' });
     * console.log(`Jane Doe has ${janeDoeTrades.data.length} trading activities`);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs/stable#house-trading-by-name|FMP House Trading by Name Documentation}
     */
    getHouseTradingByName(params: {
        name: string;
    }): Promise<APIResponse<SenateHouseTradingByNameResponse[]>>;
}

declare class StockEndpoints {
    private client;
    constructor(client: FMPClient);
    /**
     * Get current market capitalization for a stock
     *
     * Market capitalization represents the total value of a company's outstanding shares.
     * Calculated by multiplying the current share price by the number of outstanding shares.
     * This metric is crucial for understanding a company's size and market position.
     *
     * @param symbol - The stock symbol to get market cap for (e.g., 'AAPL', 'MSFT', 'GOOGL')
     *
     * @returns Promise resolving to market cap data including symbol, date, and market cap value
     *
     * @example
     * ```typescript
     * // Get market cap for Apple
     * const marketCap = await fmp.stock.getMarketCap('AAPL');
     * console.log(`Apple's market cap: $${marketCap.data.marketCap.toLocaleString()}`);
     *
     * // Get market cap for Microsoft
     * const msftCap = await fmp.stock.getMarketCap('MSFT');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#market-cap-company-information|FMP Market Cap Documentation}
     */
    getMarketCap(symbol: string): Promise<APIResponse<MarketCap>>;
    /**
     * Get historical stock splits for a company
     *
     * Stock splits occur when a company increases the number of shares by dividing existing shares.
     * This endpoint provides the complete history of stock splits including dates, ratios, and split types.
     * Useful for adjusting historical price data and understanding corporate actions.
     *
     * @param symbol - The stock symbol to get split history for (e.g., 'AAPL', 'TSLA', 'NVDA')
     *
     * @returns Promise resolving to historical stock splits with dates, labels, and split ratios
     *
     * @example
     * ```typescript
     * // Get Apple's split history
     * const splits = await fmp.stock.getStockSplits('AAPL');
     * splits.data.historical.forEach(split => {
     *   console.log(`${split.date}: ${split.numerator}:${split.denominator} split`);
     * });
     *
     * // Get Tesla's split history
     * const teslaSplits = await fmp.stock.getStockSplits('TSLA');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#splits-historical-splits|FMP Stock Splits Documentation}
     */
    getStockSplits(symbol: string): Promise<APIResponse<StockSplitResponse>>;
    /**
     * Get historical dividend payments for a stock
     *
     * Dividends are periodic payments made by companies to shareholders from profits.
     * This endpoint provides the complete dividend history including payment dates, amounts,
     * and important dates like ex-dividend, record, and declaration dates.
     *
     * @param symbol - The stock symbol to get dividend history for (e.g., 'KO', 'JNJ', 'PG')
     *
     * @returns Promise resolving to dividend history with payment details and important dates
     *
     * @example
     * ```typescript
     * // Get Coca-Cola's dividend history
     * const dividends = await fmp.stock.getDividendHistory('KO');
     * dividends.data.historical.forEach(dividend => {
     *   console.log(`${dividend.date}: $${dividend.dividend} per share`);
     * });
     *
     * // Get Johnson & Johnson's dividend history
     * const jnjDividends = await fmp.stock.getDividendHistory('JNJ');
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#dividends-historical-dividends|FMP Dividends Documentation}
     */
    getDividendHistory(symbol: string): Promise<APIResponse<StockDividendResponse>>;
    /**
     * Get real-time stock prices for multiple symbols
     *
     * Provides current market prices for stocks with minimal data overhead.
     * Returns basic price information including symbol and current price.
     * Ideal for quick price checks and portfolio monitoring.
     *
     * @param symbols - Array of stock symbols to get real-time prices for
     *
     * @returns Promise resolving to array of real-time price data with symbol and price
     *
     * @example
     * ```typescript
     * // Get prices for multiple tech stocks
     * const prices = await fmp.stock.getRealTimePrice([
     *   'AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA'
     * ]);
     *
     * prices.data.forEach(stock => {
     *   console.log(`${stock.symbol}: $${stock.price}`);
     * });
     *
     * // Get price for single stock
     * const aaplPrice = await fmp.stock.getRealTimePrice(['AAPL']);
     * ```
     */
    getRealTimePrice(symbols: string[]): Promise<APIResponse<StockRealTimePrice[]>>;
    /**
     * Get comprehensive real-time stock data for multiple symbols
     *
     * Provides detailed real-time market data including bid/ask prices, volume, trade sizes,
     * and timestamps. This endpoint offers much more information than the basic real-time price.
     * Perfect for trading applications, market analysis, and detailed price monitoring.
     *
     * @param symbols - Array of stock symbols to get detailed real-time data for
     *
     * @returns Promise resolving to array of detailed real-time data including bid/ask, volume, and timestamps
     *
     * @example
     * ```typescript
     * // Get detailed data for multiple stocks
     * const detailedData = await fmp.stock.getRealTimePriceForMultipleStocks([
     *   'AAPL', 'MSFT', 'GOOGL'
     * ]);
     *
     * detailedData.data.forEach(stock => {
     *   console.log(`${stock.symbol}:`);
     *   console.log(`  Bid: $${stock.bidPrice} (${stock.bidSize} shares)`);
     *   console.log(`  Ask: $${stock.askPrice} (${stock.askSize} shares)`);
     *   console.log(`  Last: $${stock.lastSalePrice} (${stock.lastSaleSize} shares)`);
     *   console.log(`  Volume: ${stock.volume.toLocaleString()}`);
     * });
     *
     * // Get detailed data for single stock
     * const aaplDetailed = await fmp.stock.getRealTimePriceForMultipleStocks(['AAPL']);
     * ```
     *
     * @see {@link https://site.financialmodelingprep.com/developer/docs#real-time-full-price-quote|FMP Real-Time Full Price Documentation}
     */
    getRealTimePriceForMultipleStocks(symbols: string[]): Promise<APIResponse<StockRealTimePriceFull[]>>;
}

/**
 * Main FMP API client that provides access to all endpoints
 *
 * @example
 * ```typescript
 * import { FMP } from 'fmp-node-api';
 *
 * // Option 1: Provide API key directly
 * const fmp = new FMP({ apiKey: 'your-api-key' });
 *
 * // Option 2: Use environment variable (FMP_API_KEY)
 * const fmp = new FMP();
 *
 * // Option 3: Provide partial config with environment variable fallback
 * const fmp = new FMP({ timeout: 15000 });
 *
 * // Get quote for any asset type
 * const quote = await fmp.quote.getQuote({ symbol: 'AAPL' });
 *
 * // Get stock-specific data
 * const marketCap = await fmp.stock.getMarketCap({ symbol: 'AAPL' });
 *
 * // Get financial statements
 * const incomeStatement = await fmp.financial.getIncomeStatement({
 *   symbol: 'AAPL',
 *   period: 'annual'
 * });
 *
 * ```
 */
declare class FMP {
    readonly calendar: CalendarEndpoints;
    readonly company: CompanyEndpoints;
    readonly economic: EconomicEndpoints;
    readonly etf: ETFEndpoints;
    readonly financial: FinancialEndpoints;
    readonly insider: InsiderEndpoints;
    readonly institutional: InstitutionalEndpoints;
    readonly list: ListEndpoints;
    readonly market: MarketEndpoints;
    readonly mutualFund: MutualFundEndpoints;
    readonly news: NewsEndpoints;
    readonly quote: QuoteEndpoints;
    readonly screener: ScreenerEndpoints;
    readonly sec: SECEndpoints;
    readonly senateHouse: SenateHouseEndpoints;
    readonly stock: StockEndpoints;
    constructor(config?: FMPConfig);
    /**
     * Get the underlying client instance for advanced usage
     */
    getClient(): FMPClient;
}

/**
 * Format currency value
 */
declare function formatCurrency(value: number, currency?: string): string;
/**
 * Format percentage value
 */
declare function formatPercentage(value: number, decimals?: number): string;
/**
 * Format large numbers with K, M, B suffixes
 */
declare function formatLargeNumber(value: number): string;
/**
 * Format date to YYYY-MM-DD
 */
declare function formatDate(date: Date | string): string;
/**
 * Format volume with appropriate units
 */
declare function formatVolume(volume: number): string;

declare const DEFAULT_TIMEOUT = 10000;
declare const DEFAULT_LIMIT = 100;
declare const MAX_LIMIT = 1000;
declare const PERIODS: {
    readonly ANNUAL: "annual";
    readonly QUARTER: "quarter";
};
declare const EXCHANGES: {
    readonly NYSE: "NYSE";
    readonly NASDAQ: "NASDAQ";
    readonly AMEX: "AMEX";
    readonly TSX: "TSX";
    readonly LSE: "LSE";
    readonly ASX: "ASX";
    readonly NSE: "NSE";
    readonly BSE: "BSE";
};
declare const SECTORS: {
    readonly TECHNOLOGY: "Technology";
    readonly HEALTHCARE: "Healthcare";
    readonly FINANCIAL: "Financial";
    readonly CONSUMER_DISCRETIONARY: "Consumer Discretionary";
    readonly CONSUMER_STAPLES: "Consumer Staples";
    readonly INDUSTRIALS: "Industrials";
    readonly ENERGY: "Energy";
    readonly MATERIALS: "Materials";
    readonly UTILITIES: "Utilities";
    readonly REAL_ESTATE: "Real Estate";
    readonly COMMUNICATION_SERVICES: "Communication Services";
};

export { APIResponse, Article, AvailableCountries, AvailableExchanges, AvailableIndexesList, AvailableIndustries, AvailableSectors, BalanceSheet, BalanceSheetGrowth, BeneficialOwnershipResponse, CalendarEndpoints, CashFlowStatement, CashflowGrowth, CikMapperBySymbolResponse, CikMapperResponse, CompanyEndpoints, CompanyNotes, CompanyProfile, CompanyTranscriptData, CryptoList, DEFAULT_LIMIT, DEFAULT_TIMEOUT, DividendsCalendar, ETFCountryWeighting, ETFEndpoints, ETFHolder, ETFHolding, ETFHoldingDates, ETFList, ETFProfile, ETFStockExposure, ETFWeighting, EXCHANGES, EarningsCalendar, EarningsCallTranscript, EarningsConfirmed, EarningsHistorical, EarningsSurprises, EconomicEndpoints, EconomicIndicator, EconomicsCalendar, EnterpriseValue, ExecutiveCompensation, FMP, FMPClient, FMPConfig, FailToDeliverResponse, FinancialEndpoints, FinancialGrowth, FinancialRatios, ForexList, Form13FResponse, HistoricalEmployeeCount, HistoricalPriceData, HistoricalPriceResponse, HistoricalSharesFloat, HouseTradingResponse, IPOCalendar, IncomeGrowth, IncomeStatement, IndustryClassification, IndustryClassificationCode, InsiderEndpoints, InsiderTradeStatisticsResponse, InsiderTradingRSSResponse, InsiderTradingSearchResponse, InsidersBySymbolResponse, InstitutionalEndpoints, InstitutionalHolderResponse, KeyMetrics, ListEndpoints, MAX_LIMIT, MarketCap, MarketEndpoints, MarketHours, MarketIndex, MarketPerformance, MarketSectorPerformance, MutualFundEndpoints, MutualFundHolding, News, NewsEndpoints, PERIODS, Quote, QuoteEndpoints, RSSFeed8KItem, RSSFeedAllItem, RSSFeedItem, RSSFeedV3Item, SECEndpoints, SECFiling, SECTORS, Screener, ScreenerEndpoints, ScreenerParams, SenateHouseEndpoints, SenateHouseTradingByNameResponse, SenateTradingResponse, SharesFloat, SplitsCalendar, StockDividendResponse, StockEndpoints, StockList, StockRealTimePrice, StockRealTimePriceFull, StockSplitResponse, TransactionType, TransactionTypesResponse, TreasuryRate, formatCurrency, formatDate, formatLargeNumber, formatPercentage, formatVolume };