autoscholar-cli 1.0.0

package/dist/connectors/academic.js

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchOpenAlex = searchOpenAlex;
+exports.searchArxiv = searchArxiv;
+exports.searchCrossRef = searchCrossRef;
+exports.searchGoogleScholar = searchGoogleScholar;
+exports.multiSourceSearch = multiSourceSearch;
+exports.getOpenAlexReferences = getOpenAlexReferences;
+const axios_1 = __importDefault(require("axios"));
+const xml2js_1 = require("xml2js");
+async function searchOpenAlex(query, limit = 25) {
+    try {
+        const response = await axios_1.default.get('https://api.openalex.org/works', {
+            params: {
+                search: query,
+                per_page: Math.min(limit, 50),
+                mailto: 'autoscholar@research.ai',
+            },
+            timeout: 20000,
+        });
+        return (response.data.results || []).map((w) => {
+            const authors = (w.authorships || []).map((a) => a.author?.display_name || 'Unknown');
+            const year = w.publication_year || null;
+            const title = w.title || 'Untitled';
+            const citeKey = buildCiteKey(authors[0] || 'unknown', year);
+            let abstract = '';
+            if (w.abstract_inverted_index) {
+                const entries = Object.entries(w.abstract_inverted_index);
+                const words = [];
+                for (const [word, positions] of entries) {
+                    for (const pos of positions) {
+                        words.push([pos, word]);
+                    }
+                }
+                words.sort((a, b) => a[0] - b[0]);
+                abstract = words.map((w) => w[1]).join(' ');
+            }
+            return {
+                title,
+                authors,
+                year,
+                abstract,
+                doi: w.doi?.replace('https://doi.org/', '') || null,
+                arxivId: null,
+                venue: w.primary_location?.source?.display_name || '',
+                citationCount: w.cited_by_count || 0,
+                pdfUrl: w.open_access?.oa_url || null,
+                source: 'openalex',
+                bibtex: buildBibtex({ title, authors, year, doi: w.doi?.replace('https://doi.org/', ''), venue: w.primary_location?.source?.display_name || '', citeKey }),
+                citeKey,
+            };
+        });
+    }
+    catch (err) {
+        return [];
+    }
+}
+async function searchArxiv(query, limit = 15, category) {
+    try {
+        let searchQuery = query;
+        if (category) {
+            searchQuery = `cat:${category} AND all:${query}`;
+        }
+        const response = await axios_1.default.get('http://export.arxiv.org/api/query', {
+            params: {
+                search_query: `all:${searchQuery}`,
+                max_results: Math.min(limit, 30),
+                sortBy: 'relevance',
+            },
+            timeout: 20000,
+        });
+        return new Promise((resolve) => {
+            (0, xml2js_1.parseString)(response.data, (err, result) => {
+                if (err || !result?.feed?.entry) {
+                    resolve([]);
+                    return;
+                }
+                const papers = result.feed.entry.map((e) => {
+                    const title = (e.title?.[0] || 'Untitled').replace(/\n/g, ' ').trim();
+                    const authors = (e.author || []).map((a) => a.name?.[0] || 'Unknown');
+                    const published = e.published?.[0] || '';
+                    const year = published ? new Date(published).getFullYear() : null;
+                    const arxivId = (e.id?.[0] || '').replace('http://arxiv.org/abs/', '');
+                    const abstract = (e.summary?.[0] || '').trim();
+                    const citeKey = buildCiteKey(authors[0] || 'unknown', year);
+                    const pdfLink = (e.link || []).find((l) => l.$.title === 'pdf');
+                    const pdfUrl = pdfLink?.$.href || null;
+                    return {
+                        title,
+                        authors,
+                        year,
+                        abstract,
+                        doi: null,
+                        arxivId,
+                        venue: 'arXiv',
+                        citationCount: 0,
+                        pdfUrl,
+                        source: 'arxiv',
+                        bibtex: buildBibtex({ title, authors, year, doi: null, venue: 'arXiv', citeKey, arxivId }),
+                        citeKey,
+                    };
+                });
+                resolve(papers);
+            });
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function searchCrossRef(query, limit = 15) {
+    try {
+        const response = await axios_1.default.get('https://api.crossref.org/works', {
+            params: {
+                query,
+                rows: Math.min(limit, 30),
+                mailto: 'autoscholar@research.ai',
+            },
+            timeout: 20000,
+        });
+        return (response.data.message?.items || []).map((item) => {
+            const title = (item.title || ['Untitled'])[0];
+            const authors = (item.author || []).map((a) => `${a.given || ''} ${a.family || ''}`.trim());
+            const year = item.published?.['date-parts']?.[0]?.[0] || null;
+            const doi = item.DOI || null;
+            const venue = item['container-title']?.[0] || '';
+            const citeKey = buildCiteKey(authors[0] || 'unknown', year);
+            return {
+                title,
+                authors,
+                year,
+                abstract: item.abstract || '',
+                doi,
+                arxivId: null,
+                venue,
+                citationCount: item['is-referenced-by-count'] || 0,
+                pdfUrl: item.link?.[0]?.URL || null,
+                source: 'crossref',
+                bibtex: buildBibtex({ title, authors, year, doi, venue, citeKey }),
+                citeKey,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function searchGoogleScholar(query, apiKey, limit = 10) {
+    try {
+        const response = await axios_1.default.get('https://serpapi.com/search', {
+            params: {
+                engine: 'google_scholar',
+                q: query,
+                num: Math.min(limit, 20),
+                api_key: apiKey,
+            },
+            timeout: 20000,
+        });
+        return (response.data.organic_results || []).map((r) => {
+            const title = r.title || 'Untitled';
+            const authors = r.publication_info?.authors?.map((a) => a.name) || ['Unknown'];
+            const yearMatch = r.publication_info?.summary?.match(/(\d{4})/);
+            const year = yearMatch ? parseInt(yearMatch[1]) : null;
+            const citeKey = buildCiteKey(authors[0] || 'unknown', year);
+            return {
+                title,
+                authors,
+                year,
+                abstract: r.snippet || '',
+                doi: null,
+                arxivId: null,
+                venue: r.publication_info?.summary || '',
+                citationCount: r.inline_links?.cited_by?.total || 0,
+                pdfUrl: r.resources?.[0]?.link || null,
+                source: 'google_scholar',
+                bibtex: buildBibtex({ title, authors, year, doi: null, venue: '', citeKey }),
+                citeKey,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function multiSourceSearch(query, options) {
+    const limit = options?.limit || 25;
+    const sources = options?.sources || ['openalex', 'arxiv', 'crossref'];
+    const sourcesUsed = [];
+    const sourcesFailed = [];
+    let allPapers = [];
+    const searches = [];
+    if (sources.includes('openalex')) {
+        searches.push(searchOpenAlex(query, limit)
+            .then((p) => { sourcesUsed.push('openalex'); return p; })
+            .catch(() => { sourcesFailed.push('openalex'); return []; }));
+    }
+    if (sources.includes('arxiv')) {
+        searches.push(searchArxiv(query, limit, options?.arxivCategory)
+            .then((p) => { sourcesUsed.push('arxiv'); return p; })
+            .catch(() => { sourcesFailed.push('arxiv'); return []; }));
+    }
+    if (sources.includes('crossref')) {
+        searches.push(searchCrossRef(query, limit)
+            .then((p) => { sourcesUsed.push('crossref'); return p; })
+            .catch(() => { sourcesFailed.push('crossref'); return []; }));
+    }
+    if (sources.includes('google_scholar') && options?.serpApiKey) {
+        searches.push(searchGoogleScholar(query, options.serpApiKey, limit)
+            .then((p) => { sourcesUsed.push('google_scholar'); return p; })
+            .catch(() => { sourcesFailed.push('google_scholar'); return []; }));
+    }
+    const results = await Promise.all(searches);
+    for (const papers of results) {
+        allPapers.push(...papers);
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (const p of allPapers) {
+        const key = p.doi || p.title.toLowerCase().substring(0, 60);
+        if (!seen.has(key)) {
+            seen.add(key);
+            deduped.push(p);
+        }
+    }
+    const usedKeys = new Set();
+    for (const p of deduped) {
+        let key = p.citeKey;
+        let suffix = 'a';
+        while (usedKeys.has(key)) {
+            key = `${p.citeKey}${suffix}`;
+            suffix = String.fromCharCode(suffix.charCodeAt(0) + 1);
+        }
+        usedKeys.add(key);
+        p.citeKey = key;
+        p.bibtex = buildBibtex({
+            title: p.title,
+            authors: p.authors,
+            year: p.year,
+            doi: p.doi,
+            venue: p.venue,
+            citeKey: key,
+            arxivId: p.arxivId,
+        });
+    }
+    deduped.sort((a, b) => b.citationCount - a.citationCount);
+    const bibtexBlock = deduped.map((p) => p.bibtex).join('\n\n');
+    return { papers: deduped, bibtexBlock, sourcesUsed, sourcesFailed };
+}
+async function getOpenAlexReferences(doi, limit = 15) {
+    try {
+        const response = await axios_1.default.get('https://api.openalex.org/works', {
+            params: {
+                filter: `cites:https://doi.org/${doi}`,
+                per_page: limit,
+                mailto: 'autoscholar@research.ai',
+            },
+            timeout: 15000,
+        });
+        return (response.data.results || []).slice(0, limit).map((w) => {
+            const authors = (w.authorships || []).map((a) => a.author?.display_name || 'Unknown');
+            const year = w.publication_year || null;
+            const title = w.title || 'Untitled';
+            const citeKey = buildCiteKey(authors[0] || 'unknown', year);
+            return {
+                title,
+                authors,
+                year,
+                abstract: '',
+                doi: w.doi?.replace('https://doi.org/', '') || null,
+                arxivId: null,
+                venue: w.primary_location?.source?.display_name || '',
+                citationCount: w.cited_by_count || 0,
+                pdfUrl: null,
+                source: 'openalex',
+                bibtex: buildBibtex({ title, authors, year, doi: w.doi?.replace('https://doi.org/', ''), venue: '', citeKey }),
+                citeKey,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function buildCiteKey(firstAuthor, year) {
+    const lastName = firstAuthor.split(' ').pop()?.toLowerCase().replace(/[^a-z]/g, '') || 'unknown';
+    return `${lastName}${year || 'nd'}`;
+}
+function buildBibtex(p) {
+    const type = p.arxivId ? 'misc' : 'article';
+    const authorStr = p.authors.join(' and ');
+    let bib = `@${type}{${p.citeKey},\n`;
+    bib += `  author = {${authorStr}},\n`;
+    bib += `  title = {${p.title}},\n`;
+    if (p.venue)
+        bib += `  journal = {${p.venue}},\n`;
+    if (p.year)
+        bib += `  year = {${p.year}},\n`;
+    if (p.doi)
+        bib += `  doi = {${p.doi}},\n`;
+    if (p.arxivId)
+        bib += `  eprint = {${p.arxivId}},\n  archivePrefix = {arXiv},\n`;
+    bib += `}`;
+    return bib;
+}

package/dist/connectors/eodhd.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EODHDClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const EODHD_BASE = 'https://eodhd.com/api';
+class EODHDClient {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    normalizeTicker(ticker) {
+        if (!ticker.includes('.')) {
+            return `${ticker}.US`;
+        }
+        return ticker;
+    }
+    async getEOD(ticker, fromDate, toDate, period = 'd') {
+        const normalized = this.normalizeTicker(ticker);
+        const params = {
+            api_token: this.apiKey,
+            fmt: 'json',
+            period,
+        };
+        if (fromDate)
+            params.from = fromDate;
+        if (toDate)
+            params.to = toDate;
+        const response = await axios_1.default.get(`${EODHD_BASE}/eod/${normalized}`, {
+            params,
+            timeout: 30000,
+        });
+        return response.data;
+    }
+    async getIntraday(ticker, interval = '5m', fromDate, toDate) {
+        const normalized = this.normalizeTicker(ticker);
+        const params = {
+            api_token: this.apiKey,
+            fmt: 'json',
+            interval,
+        };
+        if (fromDate)
+            params.from = this.toUnixTimestamp(fromDate);
+        if (toDate)
+            params.to = this.toUnixTimestamp(toDate);
+        const response = await axios_1.default.get(`${EODHD_BASE}/intraday/${normalized}`, {
+            params,
+            timeout: 30000,
+        });
+        return response.data;
+    }
+    async getOptions(ticker) {
+        const normalized = this.normalizeTicker(ticker);
+        const response = await axios_1.default.get(`${EODHD_BASE}/options/${normalized}`, {
+            params: {
+                api_token: this.apiKey,
+                fmt: 'json',
+            },
+            timeout: 30000,
+        });
+        return response.data;
+    }
+    async getLiveQuote(ticker) {
+        const normalized = this.normalizeTicker(ticker);
+        const response = await axios_1.default.get(`${EODHD_BASE}/real-time/${normalized}`, {
+            params: {
+                api_token: this.apiKey,
+                fmt: 'json',
+            },
+            timeout: 10000,
+        });
+        return response.data;
+    }
+    async getExchangeList() {
+        const response = await axios_1.default.get(`${EODHD_BASE}/exchanges-list`, {
+            params: {
+                api_token: this.apiKey,
+                fmt: 'json',
+            },
+            timeout: 10000,
+        });
+        return response.data;
+    }
+    toUnixTimestamp(dateStr) {
+        const d = new Date(dateStr);
+        return Math.floor(d.getTime() / 1000);
+    }
+}
+exports.EODHDClient = EODHDClient;

package/dist/connectors/firecrawl.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirecrawlClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const FIRECRAWL_BASE = 'https://api.firecrawl.dev/v1';
+class FirecrawlClient {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    get headers() {
+        return {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiKey}`,
+        };
+    }
+    async scrape(url, options) {
+        const response = await axios_1.default.post(`${FIRECRAWL_BASE}/scrape`, {
+            url,
+            formats: options?.formats || ['markdown'],
+            onlyMainContent: options?.onlyMainContent ?? true,
+            waitFor: options?.waitFor || 0,
+            timeout: options?.timeout || 30000,
+        }, { headers: this.headers, timeout: 90000 });
+        return {
+            url: response.data.data?.url || url,
+            markdown: response.data.data?.markdown || '',
+            metadata: response.data.data?.metadata || {},
+        };
+    }
+    async search(query, limit = 10) {
+        const response = await axios_1.default.post(`${FIRECRAWL_BASE}/search`, {
+            query,
+            limit,
+            scrapeOptions: { formats: ['markdown'] },
+        }, { headers: this.headers, timeout: 30000 });
+        return (response.data.data || []).map((r) => ({
+            url: r.url || '',
+            title: r.metadata?.title || r.title || '',
+            description: r.metadata?.description || r.description || '',
+            markdown: r.markdown || '',
+        }));
+    }
+    async crawl(url, options) {
+        const response = await axios_1.default.post(`${FIRECRAWL_BASE}/crawl`, {
+            url,
+            limit: options?.limit || 10,
+            maxDepth: options?.maxDepth || 2,
+            includePaths: options?.includePaths,
+            excludePaths: options?.excludePaths,
+            scrapeOptions: { formats: ['markdown'] },
+        }, { headers: this.headers, timeout: 30000 });
+        const jobId = response.data.id;
+        if (!jobId)
+            return { id: '', status: 'failed', data: [] };
+        return this.pollJob('crawl', jobId);
+    }
+    async extract(urls, prompt, schema) {
+        const response = await axios_1.default.post(`${FIRECRAWL_BASE}/extract`, {
+            urls,
+            prompt,
+            schema,
+        }, { headers: this.headers, timeout: 60000 });
+        return response.data;
+    }
+    async mapSite(url) {
+        const response = await axios_1.default.post(`${FIRECRAWL_BASE}/map`, { url }, { headers: this.headers, timeout: 30000 });
+        return response.data.links || [];
+    }
+    async pollJob(type, jobId, maxWaitMs = 120000) {
+        const start = Date.now();
+        while (Date.now() - start < maxWaitMs) {
+            await new Promise((r) => setTimeout(r, 3000));
+            try {
+                const resp = await axios_1.default.get(`${FIRECRAWL_BASE}/${type}/${jobId}`, {
+                    headers: this.headers,
+                    timeout: 10000,
+                });
+                if (resp.data.status === 'completed') {
+                    return resp.data;
+                }
+                if (resp.data.status === 'failed' || resp.data.status === 'cancelled') {
+                    return { id: jobId, status: resp.data.status, data: [] };
+                }
+            }
+            catch {
+            }
+        }
+        return { id: jobId, status: 'timeout', data: [] };
+    }
+}
+exports.FirecrawlClient = FirecrawlClient;

package/dist/connectors/fmp.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FMPClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const FMP_STABLE_URL = 'https://financialmodelingprep.com/stable';
+class FMPClient {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async request(endpoint, params = {}) {
+        const response = await axios_1.default.get(`${FMP_STABLE_URL}/${endpoint}`, {
+            params: { ...params, apikey: this.apiKey },
+            timeout: 60000,
+        });
+        return response.data;
+    }
+    async getQuote(symbol) {
+        return this.request('quote', { symbol });
+    }
+    async getCompanyProfile(symbol) {
+        return this.request('profile', { symbol });
+    }
+    async getIncomeStatement(symbol, period = 'annual', limit = 10) {
+        return this.request('income-statement', { symbol, period, limit });
+    }
+    async getBalanceSheet(symbol, period = 'annual', limit = 10) {
+        return this.request('balance-sheet-statement', { symbol, period, limit });
+    }
+    async getCashFlow(symbol, period = 'annual', limit = 10) {
+        return this.request('cash-flow-statement', { symbol, period, limit });
+    }
+    async getKeyMetrics(symbol, period = 'annual', limit = 10) {
+        return this.request('key-metrics', { symbol, period, limit });
+    }
+    async getFinancialRatios(symbol, period = 'annual', limit = 10) {
+        return this.request('ratios', { symbol, period, limit });
+    }
+    async getHistoricalPrices(symbol, fromDate, toDate) {
+        const params = { symbol };
+        if (fromDate)
+            params.from = fromDate;
+        if (toDate)
+            params.to = toDate;
+        return this.request('historical-price-eod/full', params);
+    }
+    async getStockList() {
+        return this.request('stock-list');
+    }
+    async getMarketGainers() {
+        return this.request('stock-market/gainers');
+    }
+    async getMarketLosers() {
+        return this.request('stock-market/losers');
+    }
+    async getRSI(symbol, period = 'daily', timePeriod = 14) {
+        return this.request('technical-indicator/rsi', { symbol, period, timePeriod });
+    }
+    async getMACD(symbol, period = 'daily') {
+        return this.request('technical-indicator/macd', { symbol, period });
+    }
+    async getEMA(symbol, period = 'daily', timePeriod = 20) {
+        return this.request('technical-indicator/ema', { symbol, period, timePeriod });
+    }
+    async getSMA(symbol, period = 'daily', timePeriod = 20) {
+        return this.request('technical-indicator/sma', { symbol, period, timePeriod });
+    }
+    async getSECFilings(symbol, type, limit = 10) {
+        const params = { symbol, limit };
+        if (type)
+            params.type = type;
+        return this.request('sec-filings', params);
+    }
+    async getEconomicCalendar(from, to) {
+        const params = {};
+        if (from)
+            params.from = from;
+        if (to)
+            params.to = to;
+        return this.request('economic-calendar', params);
+    }
+    async getTreasuryRates() {
+        return this.request('treasury');
+    }
+    async search(query, limit = 10) {
+        return this.request('search', { query, limit });
+    }
+    async getStockNews(symbol, limit = 50) {
+        return this.request('stock-news', { tickers: symbol, limit });
+    }
+    async getESGScore(symbol) {
+        return this.request('esg-environmental-social-governance-data', { symbol });
+    }
+    async getInsiderTrading(symbol, limit = 100) {
+        return this.request('insider-trading', { symbol, limit });
+    }
+    async getInstitutionalHolders(symbol) {
+        return this.request('institutional-holder', { symbol });
+    }
+    async getForexQuote(pair) {
+        return this.request('quote', { symbol: pair });
+    }
+    async getCommodityPrices() {
+        return this.request('commodities-list');
+    }
+    async getDCF(symbol) {
+        return this.request('discounted-cash-flow', { symbol });
+    }
+    async getEnterpriseValue(symbol, period = 'annual', limit = 10) {
+        return this.request('enterprise-values', { symbol, period, limit });
+    }
+}
+exports.FMPClient = FMPClient;

package/dist/connectors/fred.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FREDClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const FRED_BASE = 'https://api.stlouisfed.org/fred';
+class FREDClient {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async request(endpoint, params = {}) {
+        const response = await axios_1.default.get(`${FRED_BASE}/${endpoint}`, {
+            params: {
+                ...params,
+                api_key: this.apiKey,
+                file_type: 'json',
+            },
+            timeout: 30000,
+        });
+        return response.data;
+    }
+    async getSeries(seriesId) {
+        const data = await this.request('series', { series_id: seriesId });
+        return data.seriess[0];
+    }
+    async getObservations(seriesId, options) {
+        const params = { series_id: seriesId };
+        if (options?.observationStart)
+            params.observation_start = options.observationStart;
+        if (options?.observationEnd)
+            params.observation_end = options.observationEnd;
+        if (options?.units)
+            params.units = options.units;
+        if (options?.frequency)
+            params.frequency = options.frequency;
+        if (options?.aggregationMethod)
+            params.aggregation_method = options.aggregationMethod;
+        const data = await this.request('series/observations', params);
+        return data.observations;
+    }
+    async searchSeries(searchText, limit = 20) {
+        const data = await this.request('series/search', {
+            search_text: searchText,
+            limit,
+        });
+        return data.seriess || [];
+    }
+    async getCategory(categoryId) {
+        return this.request('category', { category_id: categoryId });
+    }
+    async getCategorySeries(categoryId, limit = 20) {
+        const data = await this.request('category/series', {
+            category_id: categoryId,
+            limit,
+        });
+        return data.seriess || [];
+    }
+    async getRelatedTags(seriesId) {
+        return this.request('series/tags', { series_id: seriesId });
+    }
+    async getGDP(start, end) {
+        return this.getObservations('GDP', { observationStart: start, observationEnd: end });
+    }
+    async getCPI(start, end) {
+        return this.getObservations('CPIAUCSL', { observationStart: start, observationEnd: end });
+    }
+    async getUnemploymentRate(start, end) {
+        return this.getObservations('UNRATE', { observationStart: start, observationEnd: end });
+    }
+    async getFedFundsRate(start, end) {
+        return this.getObservations('FEDFUNDS', { observationStart: start, observationEnd: end });
+    }
+    async getVIX(start, end) {
+        return this.getObservations('VIXCLS', { observationStart: start, observationEnd: end });
+    }
+    async getSP500(start, end) {
+        return this.getObservations('SP500', { observationStart: start, observationEnd: end });
+    }
+}
+exports.FREDClient = FREDClient;