@fin.cx/opendata 2.1.0 → 3.1.0

package/dist_ts/stocks/providers/provider.secedgar.js

@@ -0,0 +1,343 @@
+import * as plugins from '../../plugins.js';
+/**
+ * Rate limiter for SEC EDGAR API
+ * SEC requires: 10 requests per second maximum
+ */
+class RateLimiter {
+    constructor() {
+        this.requestTimes = [];
+        this.maxRequestsPerSecond = 10;
+    }
+    async waitForSlot() {
+        const now = Date.now();
+        const oneSecondAgo = now - 1000;
+        // Remove requests older than 1 second
+        this.requestTimes = this.requestTimes.filter(time => time > oneSecondAgo);
+        // If we've hit the limit, wait
+        if (this.requestTimes.length >= this.maxRequestsPerSecond) {
+            const oldestRequest = this.requestTimes[0];
+            const waitTime = 1000 - (now - oldestRequest) + 10; // +10ms buffer
+            await plugins.smartdelay.delayFor(waitTime);
+            return this.waitForSlot(); // Recursively check again
+        }
+        // Record this request
+        this.requestTimes.push(now);
+    }
+}
+/**
+ * SEC EDGAR Fundamental Data Provider
+ *
+ * Features:
+ * - Free public access (no API key required)
+ * - All US public companies
+ * - Financial data from 10-K/10-Q filings
+ * - US GAAP standardized metrics
+ * - Historical data back to ~2009
+ * - < 1 minute filing delay
+ *
+ * Documentation: https://www.sec.gov/edgar/sec-api-documentation
+ *
+ * Rate Limits:
+ * - 10 requests per second (enforced by SEC)
+ * - Requires User-Agent header in format: "Company Name Email"
+ *
+ * Data Sources:
+ * - Company Facts API: /api/xbrl/companyfacts/CIK##########.json
+ * - Ticker Lookup: /files/company_tickers.json
+ */
+export class SecEdgarProvider {
+    constructor(config) {
+        this.name = 'SEC EDGAR';
+        this.priority = 100; // High priority - free, authoritative, comprehensive
+        this.requiresAuth = false; // No API key needed!
+        this.rateLimit = {
+            requestsPerMinute: 600, // 10 requests/second = 600/minute
+            requestsPerDay: undefined // No daily limit
+        };
+        this.logger = console;
+        this.baseUrl = 'https://data.sec.gov/api/xbrl';
+        this.tickersUrl = 'https://www.sec.gov/files/company_tickers.json';
+        // Caching
+        this.cikCache = new Map();
+        this.tickerListCache = null;
+        // Rate limiting
+        this.rateLimiter = new RateLimiter();
+        // Validate User-Agent
+        if (!config.userAgent) {
+            throw new Error('User-Agent is required for SEC EDGAR provider (format: "Company Name Email")');
+        }
+        // Validate User-Agent format (must contain space and @ symbol)
+        if (!config.userAgent.includes(' ') || !config.userAgent.includes('@')) {
+            throw new Error('Invalid User-Agent format. Required: "Company Name Email" (e.g., "fin.cx info@fin.cx")');
+        }
+        this.userAgent = config.userAgent;
+        this.config = {
+            userAgent: config.userAgent,
+            cikCacheTTL: config.cikCacheTTL || 30 * 24 * 60 * 60 * 1000, // 30 days
+            fundamentalsCacheTTL: config.fundamentalsCacheTTL || 90 * 24 * 60 * 60 * 1000, // 90 days
+            timeout: config.timeout || 30000
+        };
+    }
+    /**
+     * Unified data fetching method
+     */
+    async fetchData(request) {
+        switch (request.type) {
+            case 'fundamentals-current':
+                return this.fetchFundamentals(request);
+            case 'fundamentals-batch':
+                return this.fetchBatchFundamentals(request);
+            default:
+                throw new Error(`Unsupported request type: ${request.type}`);
+        }
+    }
+    /**
+     * Fetch fundamental data for a single ticker
+     */
+    async fetchFundamentals(request) {
+        try {
+            // 1. Get CIK for ticker (with caching)
+            const cik = await this.getCIK(request.ticker);
+            // 2. Fetch company facts from SEC (with rate limiting)
+            const companyFacts = await this.fetchCompanyFacts(cik);
+            // 3. Parse facts into structured fundamental data
+            return this.parseCompanyFacts(request.ticker, cik, companyFacts);
+        }
+        catch (error) {
+            this.logger.error(`Failed to fetch fundamentals for ${request.ticker}:`, error);
+            throw new Error(`SEC EDGAR: Failed to fetch fundamentals for ${request.ticker}: ${error.message}`);
+        }
+    }
+    /**
+     * Fetch fundamental data for multiple tickers
+     */
+    async fetchBatchFundamentals(request) {
+        const results = [];
+        const errors = [];
+        for (const ticker of request.tickers) {
+            try {
+                const fundamentals = await this.fetchFundamentals({
+                    type: 'fundamentals-current',
+                    ticker
+                });
+                results.push(fundamentals);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to fetch fundamentals for ${ticker}:`, error);
+                errors.push(`${ticker}: ${error.message}`);
+                // Continue with other tickers
+            }
+        }
+        if (results.length === 0) {
+            throw new Error(`Failed to fetch fundamentals for all tickers. Errors: ${errors.join(', ')}`);
+        }
+        return results;
+    }
+    /**
+     * Get CIK (Central Index Key) for a ticker symbol
+     * Uses SEC's public ticker-to-CIK mapping file
+     */
+    async getCIK(ticker) {
+        const tickerUpper = ticker.toUpperCase();
+        // Check cache first
+        const cached = this.cikCache.get(tickerUpper);
+        if (cached) {
+            const age = Date.now() - cached.timestamp.getTime();
+            if (age < this.config.cikCacheTTL) {
+                return cached.cik;
+            }
+            // Cache expired, remove it
+            this.cikCache.delete(tickerUpper);
+        }
+        // Fetch ticker list (with caching at list level)
+        const tickers = await this.fetchTickerList();
+        // Find ticker in list (case-insensitive)
+        const entry = Object.values(tickers).find((t) => t.ticker === tickerUpper);
+        if (!entry) {
+            throw new Error(`CIK not found for ticker ${ticker}`);
+        }
+        const cik = String(entry.cik_str);
+        // Cache the result
+        this.cikCache.set(tickerUpper, {
+            cik,
+            timestamp: new Date()
+        });
+        return cik;
+    }
+    /**
+     * Fetch the SEC ticker-to-CIK mapping list
+     * Cached for 24 hours (list updates daily)
+     */
+    async fetchTickerList() {
+        // Check cache
+        if (this.tickerListCache) {
+            const age = Date.now() - this.tickerListCache.timestamp.getTime();
+            if (age < 24 * 60 * 60 * 1000) { // 24 hours
+                return this.tickerListCache.data;
+            }
+        }
+        // Wait for rate limit slot
+        await this.rateLimiter.waitForSlot();
+        // Fetch from SEC
+        const response = await plugins.smartrequest.SmartRequest.create()
+            .url(this.tickersUrl)
+            .headers({
+            'User-Agent': this.userAgent,
+            'Accept': 'application/json'
+        })
+            .timeout(this.config.timeout)
+            .get();
+        const data = await response.json();
+        // Cache the list
+        this.tickerListCache = {
+            data,
+            timestamp: new Date()
+        };
+        return data;
+    }
+    /**
+     * Fetch company facts from SEC EDGAR
+     */
+    async fetchCompanyFacts(cik) {
+        // Pad CIK to 10 digits
+        const paddedCIK = cik.padStart(10, '0');
+        const url = `${this.baseUrl}/companyfacts/CIK${paddedCIK}.json`;
+        // Wait for rate limit slot
+        await this.rateLimiter.waitForSlot();
+        // Fetch from SEC
+        const response = await plugins.smartrequest.SmartRequest.create()
+            .url(url)
+            .headers({
+            'User-Agent': this.userAgent,
+            'Accept': 'application/json',
+            'Accept-Encoding': 'gzip, deflate',
+            'Host': 'data.sec.gov'
+        })
+            .timeout(this.config.timeout)
+            .get();
+        const data = await response.json();
+        // Validate response
+        if (!data || !data.facts) {
+            throw new Error('Invalid response from SEC EDGAR API');
+        }
+        return data;
+    }
+    /**
+     * Parse SEC company facts into structured fundamental data
+     */
+    parseCompanyFacts(ticker, cik, data) {
+        const usGaap = data.facts?.['us-gaap'];
+        if (!usGaap) {
+            throw new Error('No US GAAP data available');
+        }
+        // Extract latest values for key metrics
+        const fundamentals = {
+            ticker: ticker.toUpperCase(),
+            cik: cik,
+            companyName: data.entityName,
+            provider: this.name,
+            timestamp: new Date(),
+            fetchedAt: new Date(),
+            // Per-share metrics
+            earningsPerShareBasic: this.getLatestValue(usGaap, 'EarningsPerShareBasic'),
+            earningsPerShareDiluted: this.getLatestValue(usGaap, 'EarningsPerShareDiluted'),
+            sharesOutstanding: this.getLatestValue(usGaap, 'CommonStockSharesOutstanding'),
+            weightedAverageSharesOutstanding: this.getLatestValue(usGaap, 'WeightedAverageNumberOfSharesOutstandingBasic'),
+            // Income statement
+            revenue: this.getLatestValue(usGaap, 'Revenues') ||
+                this.getLatestValue(usGaap, 'RevenueFromContractWithCustomerExcludingAssessedTax'),
+            netIncome: this.getLatestValue(usGaap, 'NetIncomeLoss'),
+            operatingIncome: this.getLatestValue(usGaap, 'OperatingIncomeLoss'),
+            grossProfit: this.getLatestValue(usGaap, 'GrossProfit'),
+            costOfRevenue: this.getLatestValue(usGaap, 'CostOfRevenue'),
+            // Balance sheet
+            assets: this.getLatestValue(usGaap, 'Assets'),
+            liabilities: this.getLatestValue(usGaap, 'Liabilities'),
+            stockholdersEquity: this.getLatestValue(usGaap, 'StockholdersEquity'),
+            cash: this.getLatestValue(usGaap, 'CashAndCashEquivalentsAtCarryingValue'),
+            propertyPlantEquipment: this.getLatestValue(usGaap, 'PropertyPlantAndEquipmentNet'),
+            // Metadata (from latest available data point)
+            fiscalYear: this.getLatestMetadata(usGaap, 'EarningsPerShareDiluted')?.fy,
+            fiscalQuarter: this.getLatestMetadata(usGaap, 'EarningsPerShareDiluted')?.fp,
+            filingDate: this.getLatestMetadata(usGaap, 'EarningsPerShareDiluted')?.filed
+                ? new Date(this.getLatestMetadata(usGaap, 'EarningsPerShareDiluted').filed)
+                : undefined,
+            form: this.getLatestMetadata(usGaap, 'EarningsPerShareDiluted')?.form
+        };
+        return fundamentals;
+    }
+    /**
+     * Get the latest value for a US GAAP metric
+     */
+    getLatestValue(usGaap, metricName) {
+        const metric = usGaap[metricName];
+        if (!metric?.units) {
+            return undefined;
+        }
+        // Get the first unit type (USD, shares, etc.)
+        const unitType = Object.keys(metric.units)[0];
+        const values = metric.units[unitType];
+        if (!values || !Array.isArray(values) || values.length === 0) {
+            return undefined;
+        }
+        // Get the latest value (last in array)
+        const latest = values[values.length - 1];
+        return latest?.val;
+    }
+    /**
+     * Get metadata from the latest data point
+     */
+    getLatestMetadata(usGaap, metricName) {
+        const metric = usGaap[metricName];
+        if (!metric?.units) {
+            return undefined;
+        }
+        const unitType = Object.keys(metric.units)[0];
+        const values = metric.units[unitType];
+        if (!values || !Array.isArray(values) || values.length === 0) {
+            return undefined;
+        }
+        return values[values.length - 1];
+    }
+    /**
+     * Check if SEC EDGAR API is available
+     */
+    async isAvailable() {
+        try {
+            // Test with Apple's well-known CIK
+            const url = `${this.baseUrl}/companyfacts/CIK0000320193.json`;
+            const response = await plugins.smartrequest.SmartRequest.create()
+                .url(url)
+                .headers({
+                'User-Agent': this.userAgent,
+                'Accept': 'application/json'
+            })
+                .timeout(5000)
+                .get();
+            const data = await response.json();
+            return data && data.facts !== undefined;
+        }
+        catch (error) {
+            this.logger.warn('SEC EDGAR provider is not available:', error);
+            return false;
+        }
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return {
+            cikCacheSize: this.cikCache.size,
+            hasTickerList: this.tickerListCache !== null
+        };
+    }
+    /**
+     * Clear all caches
+     */
+    clearCache() {
+        this.cikCache.clear();
+        this.tickerListCache = null;
+        this.logger.log('SEC EDGAR cache cleared');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.secedgar.js","sourceRoot":"","sources":["../../../ts/stocks/providers/provider.secedgar.ts"],"names":[],"mappings":"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"}

package/dist_ts/stocks/providers/provider.yahoo.d.ts

@@ -1,5 +1,5 @@
 import type { IStockProvider, IProviderConfig } from '../interfaces/provider.js';
-import type { IStockPrice, IStockQuoteRequest, IStockBatchQuoteRequest } from '../interfaces/stockprice.js';
+import type { IStockPrice, IStockDataRequest } from '../interfaces/stockprice.js';
 export declare class YahooFinanceProvider implements IStockProvider {
     private config?;
     name: string;
@@ -13,8 +13,18 @@ export declare class YahooFinanceProvider implements IStockProvider {
     private baseUrl;
     private userAgent;
     constructor(config?: IProviderConfig);
-    fetchPrice(request: IStockQuoteRequest): Promise<IStockPrice>;
-    fetchPrices(request: IStockBatchQuoteRequest): Promise<IStockPrice[]>;
+    /**
+     * Unified data fetching method
+     */
+    fetchData(request: IStockDataRequest): Promise<IStockPrice | IStockPrice[]>;
+    /**
+     * Fetch current price for a single ticker
+     */
+    private fetchCurrentPrice;
+    /**
+     * Fetch batch current prices
+     */
+    private fetchBatchCurrentPrices;
     isAvailable(): Promise<boolean>;
     supportsMarket(market: string): boolean;
     supportsTicker(ticker: string): boolean;

package/dist_ts/stocks/providers/provider.yahoo.js

@@ -13,7 +13,27 @@ export class YahooFinanceProvider {
         this.baseUrl = 'https://query1.finance.yahoo.com';
         this.userAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
     }
-    async fetchPrice(request) {
+    /**
+     * Unified data fetching method
+     */
+    async fetchData(request) {
+        switch (request.type) {
+            case 'current':
+                return this.fetchCurrentPrice(request);
+            case 'batch':
+                return this.fetchBatchCurrentPrices(request);
+            case 'historical':
+                throw new Error('Yahoo Finance provider does not support historical data. Use Marketstack provider instead.');
+            case 'intraday':
+                throw new Error('Yahoo Finance provider does not support intraday data yet. Use Marketstack provider instead.');
+            default:
+                throw new Error(`Unsupported request type: ${request.type}`);
+        }
+    }
+    /**
+     * Fetch current price for a single ticker
+     */
+    async fetchCurrentPrice(request) {
         try {
             const url = `${this.baseUrl}/v8/finance/chart/${request.ticker}`;
             const response = await plugins.smartrequest.SmartRequest.create()
@@ -54,7 +74,10 @@ export class YahooFinanceProvider {
             throw new Error(`Yahoo Finance: Failed to fetch price for ${request.ticker}: ${error.message}`);
         }
     }
-    async fetchPrices(request) {
+    /**
+     * Fetch batch current prices
+     */
+    async fetchBatchCurrentPrices(request) {
         try {
             const symbols = request.tickers.join(',');
             const url = `${this.baseUrl}/v8/finance/spark?symbols=${symbols}&range=1d&interval=5m`;
@@ -106,7 +129,7 @@ export class YahooFinanceProvider {
     async isAvailable() {
         try {
             // Test with a well-known ticker
-            await this.fetchPrice({ ticker: 'AAPL' });
+            await this.fetchData({ type: 'current', ticker: 'AAPL' });
             return true;
         }
         catch (error) {
@@ -142,4 +165,4 @@ export class YahooFinanceProvider {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXIueWFob28uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9zdG9ja3MvcHJvdmlkZXJzL3Byb3ZpZGVyLnlhaG9vLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFJNUMsTUFBTSxPQUFPLG9CQUFvQjtJQWEvQixZQUFvQixNQUF3QjtRQUF4QixXQUFNLEdBQU4sTUFBTSxDQUFrQjtRQVpyQyxTQUFJLEdBQUcsZUFBZSxDQUFDO1FBQ3ZCLGFBQVEsR0FBRyxHQUFHLENBQUM7UUFDTixpQkFBWSxHQUFHLEtBQUssQ0FBQztRQUNyQixjQUFTLEdBQUc7WUFDMUIsaUJBQWlCLEVBQUUsR0FBRyxFQUFFLHdCQUF3QjtZQUNoRCxjQUFjLEVBQUUsU0FBUztTQUMxQixDQUFDO1FBRU0sV0FBTSxHQUFHLE9BQU8sQ0FBQztRQUNqQixZQUFPLEdBQUcsa0NBQWtDLENBQUM7UUFDN0MsY0FBUyxHQUFHLGlIQUFpSCxDQUFDO0lBRXZGLENBQUM7SUFFekMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxPQUEyQjtRQUNqRCxJQUFJLENBQUM7WUFDSCxNQUFNLEdBQUcsR0FBRyxHQUFHLElBQUksQ0FBQyxPQUFPLHFCQUFxQixPQUFPLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDakUsTUFBTSxRQUFRLEdBQUcsTUFBTSxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBQyxNQUFNLEVBQUU7aUJBQzlELEdBQUcsQ0FBQyxHQUFHLENBQUM7aUJBQ1IsT0FBTyxDQUFDO2dCQUNQLFlBQVksRUFBRSxJQUFJLENBQUMsU0FBUzthQUM3QixDQUFDO2lCQUNELE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLE9BQU8sSUFBSSxLQUFLLENBQUM7aUJBQ3RDLEdBQUcsRUFBRSxDQUFDO1lBRVQsTUFBTSxZQUFZLEdBQUcsTUFBTSxRQUFRLENBQUMsSUFBSSxFQUFTLENBQUM7WUFFbEQsSUFBSSxDQUFDLFlBQVksRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztnQkFDdEMsTUFBTSxJQUFJLEtBQUssQ0FBQyw0QkFBNEIsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7WUFDaEUsQ0FBQztZQUVELE1BQU0sSUFBSSxHQUFHLFlBQVksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQzFDLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUM7WUFFdkIsSUFBSSxDQUFDLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO2dCQUM3QixNQUFNLElBQUksS0FBSyxDQUFDLCtCQUErQixPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztZQUNuRSxDQUFDO1lBRUQsTUFBTSxVQUFVLEdBQWdCO2dCQUM5QixNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxXQUFXLEVBQUU7Z0JBQ3BDLEtBQUssRUFBRSxJQUFJLENBQUMsa0JBQWtCO2dCQUM5QixRQUFRLEVBQUUsSUFBSSxDQUFDLFFBQVEsSUFBSSxLQUFLO2dCQUNoQyxNQUFNLEVBQUUsSUFBSSxDQUFDLGtCQUFrQixHQUFHLElBQUksQ0FBQyxhQUFhO2dCQUNwRCxhQUFhLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxrQkFBa0IsR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxHQUFHLEdBQUc7Z0JBQzFGLGFBQWEsRUFBRSxJQUFJLENBQUMsYUFBYTtnQkFDakMsU0FBUyxFQUFFLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxpQkFBaUIsR0FBRyxJQUFJLENBQUM7Z0JBQ2xELFFBQVEsRUFBRSxJQUFJLENBQUMsSUFBSTtnQkFDbkIsV0FBVyxFQUFFLElBQUksQ0FBQyxvQkFBb0IsQ0FBQyxJQUFJLENBQUM7Z0JBQzVDLFFBQVEsRUFBRSxJQUFJLENBQUMsUUFBUTtnQkFDdkIsWUFBWSxFQUFFLElBQUksQ0FBQyxZQUFZO2dCQUMvQixRQUFRLEVBQUUsTUFBTSxFQUFFLCtDQUErQztnQkFDakUsU0FBUyxFQUFFLElBQUksSUFBSSxFQUFFO2FBQ3RCLENBQUM7WUFFRixPQUFPLFVBQVUsQ0FBQztRQUNwQixDQUFDO1FBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztZQUNmLE9BQU8sQ0FBQyxLQUFLLENBQUMsNkJBQTZCLE9BQU8sQ0FBQyxNQUFNLEdBQUcsRUFBRSxLQUFLLENBQUMsQ0FBQztZQUNyRSxNQUFNLElBQUksS0FBSyxDQUFDLDRDQUE0QyxPQUFPLENBQUMsTUFBTSxLQUFLLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQ2xHLENBQUM7SUFDSCxDQUFDO0lBRU0sS0FBSyxDQUFDLFdBQVcsQ0FBQyxPQUFnQztRQUN2RCxJQUFJLENBQUM7WUFDSCxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUMxQyxNQUFNLEdBQUcsR0FBRyxHQUFHLElBQUksQ0FBQyxPQUFPLDZCQUE2QixPQUFPLHVCQUF1QixDQUFDO1lBRXZGLE1BQU0sUUFBUSxHQUFHLE1BQU0sT0FBTyxDQUFDLFlBQVksQ0FBQyxZQUFZLENBQUMsTUFBTSxFQUFFO2lCQUM5RCxHQUFHLENBQUMsR0FBRyxDQUFDO2lCQUNSLE9BQU8sQ0FBQztnQkFDUCxZQUFZLEVBQUUsSUFBSSxDQUFDLFNBQVM7YUFDN0IsQ0FBQztpQkFDRCxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxPQUFPLElBQUksS0FBSyxDQUFDO2lCQUN0QyxHQUFHLEVBQUUsQ0FBQztZQUVULE1BQU0sWUFBWSxHQUFHLE1BQU0sUUFBUSxDQUFDLElBQUksRUFBUyxDQUFDO1lBQ2xELE1BQU0sTUFBTSxHQUFrQixFQUFFLENBQUM7WUFFakMsS0FBSyxNQUFNLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFDLEVBQUUsQ0FBQztnQkFDMUQsSUFBSSxDQUFDLElBQUksSUFBSSxPQUFPLElBQUksS0FBSyxRQUFRO29CQUFFLFNBQVM7Z0JBRWhELE1BQU0sU0FBUyxHQUFHLElBQVcsQ0FBQztnQkFDOUIsSUFBSSxDQUFDLFNBQVMsQ0FBQyxhQUFhLElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxDQUFDO29CQUN6RCxPQUFPLENBQUMsSUFBSSxDQUFDLHVCQUF1QixNQUFNLFlBQVksQ0FBQyxDQUFDO29CQUN4RCxTQUFTO2dCQUNYLENBQUM7Z0JBRUQsTUFBTSxZQUFZLEdBQUcsU0FBUyxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQztnQkFDakUsTUFBTSxTQUFTLEdBQUcsU0FBUyxDQUFDLFNBQVMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDO2dCQUV4RSxNQUFNLENBQUMsSUFBSSxDQUFDO29CQUNWLE1BQU0sRUFBRSxNQUFNLENBQUMsV0FBVyxFQUFFO29CQUM1QixLQUFLLEVBQUUsWUFBWTtvQkFDbkIsUUFBUSxFQUFFLFNBQVMsQ0FBQyxRQUFRLElBQUksS0FBSztvQkFDckMsTUFBTSxFQUFFLFlBQVksR0FBRyxTQUFTLENBQUMsYUFBYTtvQkFDOUMsYUFBYSxFQUFFLENBQUMsQ0FBQyxZQUFZLEdBQUcsU0FBUyxDQUFDLGFBQWEsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxhQUFhLENBQUMsR0FBRyxHQUFHO29CQUN6RixhQUFhLEVBQUUsU0FBUyxDQUFDLGFBQWE7b0JBQ3RDLFNBQVMsRUFBRSxTQUFTLENBQUMsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxJQUFJLEVBQUU7b0JBQzlELFFBQVEsRUFBRSxJQUFJLENBQUMsSUFBSTtvQkFDbkIsV0FBVyxFQUFFLFNBQVMsQ0FBQyxXQUFXLElBQUksU0FBUztvQkFDL0MsUUFBUSxFQUFFLFNBQVMsQ0FBQyxRQUFRO29CQUM1QixZQUFZLEVBQUUsU0FBUyxDQUFDLFlBQVk7b0JBQ3BDLFFBQVEsRUFBRSxNQUFNLEVBQUUsK0NBQStDO29CQUNqRSxTQUFTLEVBQUUsSUFBSSxJQUFJLEVBQUU7aUJBQ3RCLENBQUMsQ0FBQztZQUNMLENBQUM7WUFFRCxJQUFJLE1BQU0sQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQ3hCLE1BQU0sSUFBSSxLQUFLLENBQUMsaURBQWlELENBQUMsQ0FBQztZQUNyRSxDQUFDO1lBRUQsT0FBTyxNQUFNLENBQUM7UUFDaEIsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixPQUFPLENBQUMsS0FBSyxDQUFDLCtCQUErQixFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQ3RELE1BQU0sSUFBSSxLQUFLLENBQUMsZ0RBQWdELEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQ25GLENBQUM7SUFDSCxDQUFDO0lBRU0sS0FBSyxDQUFDLFdBQVc7UUFDdEIsSUFBSSxDQUFDO1lBQ0gsZ0NBQWdDO1lBQ2hDLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDO1lBQzFDLE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixPQUFPLENBQUMsSUFBSSxDQUFDLDBDQUEwQyxFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQ2hFLE9BQU8sS0FBSyxDQUFDO1FBQ2YsQ0FBQztJQUNILENBQUM7SUFFTSxjQUFjLENBQUMsTUFBYztRQUNsQyw0Q0FBNEM7UUFDNUMsTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFDaEYsT0FBTyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUM7SUFDekQsQ0FBQztJQUVNLGNBQWMsQ0FBQyxNQUFjO1FBQ2xDLGlEQUFpRDtRQUNqRCxPQUFPLHNCQUFzQixDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztJQUMzRCxDQUFDO0lBRU8sb0JBQW9CLENBQUMsSUFBUztRQUNwQyxNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsV0FBVyxFQUFFLFdBQVcsRUFBRSxDQUFDO1FBRXBELFFBQVEsV0FBVyxFQUFFLENBQUM7WUFDcEIsS0FBSyxLQUFLO2dCQUNSLE9BQU8sS0FBSyxDQUFDO1lBQ2YsS0FBSyxNQUFNO2dCQUNULE9BQU8sTUFBTSxDQUFDO1lBQ2hCLEtBQUssU0FBUztnQkFDWixPQUFPLFNBQVMsQ0FBQztZQUNuQjtnQkFDRSx3REFBd0Q7Z0JBQ3hELE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUM7Z0JBQzlCLE1BQU0saUJBQWlCLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixDQUFDO2dCQUNqRCxNQUFNLFFBQVEsR0FBRyxHQUFHLEdBQUcsaUJBQWlCLENBQUM7Z0JBRXpDLG1FQUFtRTtnQkFDbkUsT0FBTyxRQUFRLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztRQUNsRCxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fin.cx/opendata",
-  "version": "2.1.0",
+  "version": "3.1.0",
   "private": false,
   "description": "A comprehensive TypeScript library for accessing business data and real-time financial information. Features include German company data management with MongoDB integration, JSONL bulk processing, automated Handelsregister interactions, and real-time stock market data from multiple providers.",
   "main": "dist_ts/index.js",