@invezgo/sdk 1.3.1 → 2.0.1

package/dist/index.mjs

@@ -0,0 +1,775 @@
+class AnalysisResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    getStockList(options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/list/stock', cache: 'default' }, options);
+    }
+    getBrokerList(options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/list/broker', cache: 'default' }, options);
+    }
+    getIndexList(options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/list/index', cache: 'default' }, options);
+    }
+    getUma(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/uma', cache: 'default', query: params }, options);
+    }
+    getSuspend(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/suspend', cache: 'default', query: params }, options);
+    }
+    getNotation(options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/notation', cache: 'default' }, options);
+    }
+    getInformation(code, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/information/{code}', cache: 'default', pathParams: { code } }, options);
+    }
+    getTopChange(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/top/change', cache: 'default', query: params }, options);
+    }
+    getTopForeign(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/top/foreign', cache: 'default', query: params }, options);
+    }
+    getTopAccumulation(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/top/accumulation', cache: 'default', query: params }, options);
+    }
+    getTopRitel(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/top/ritel', cache: 'default', query: params }, options);
+    }
+    getStockRunningTrade(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/running-trade/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getIntradayChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/intraday/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getOrderBook(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/order-book/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getOrderQueue(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/queue/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getIntradayData(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/intraday-data/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getIntradayIndex(code, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/intraday-index/{code}', cache: 'realtime', pathParams: { code } }, options);
+    }
+    getAdvanceChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/chart/stock/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getIndexChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/chart/index/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getMultiTimeChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/chart/multi-time/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getIndicatorChart(indicator, code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/chart/stock/{indicator}/{code}', cache: 'default', pathParams: { indicator, code }, query: params }, options);
+    }
+    getShareholderDetail(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder-detail', cache: 'default', query: params }, options);
+    }
+    getShareholderOneDetail(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder-detail-one', cache: 'default', query: params }, options);
+    }
+    getShareholderHigh(options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder/high', cache: 'default' }, options);
+    }
+    getShareholderNumber(code, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder/number/{code}', cache: 'default', pathParams: { code } }, options);
+    }
+    getShareholderRelation(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder/relation', cache: 'default', query: params }, options);
+    }
+    getShareholder(code, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder/{code}', cache: 'default', pathParams: { code } }, options);
+    }
+    getShareholderKSEI(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder/ksei/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getShareholderClassification(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder/classification/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getShareholderClassifyTable(code, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder/classify-table/{code}', cache: 'default', pathParams: { code } }, options);
+    }
+    getSummaryStock(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/summary/stock/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getSummaryBroker(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/summary/broker/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getSectorStalker(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/stalker/sector', cache: 'realtime', query: params }, options);
+    }
+    getSectorRotation(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/sector/rotation', cache: 'realtime', query: params }, options);
+    }
+    getBrokerStalker(broker, stock, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/stalker/broker/{broker}/{stock}', cache: 'default', pathParams: { broker, stock }, query: params }, options);
+    }
+    getBrokerStalkerList(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/stalker/list/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getSummaryStockChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/summary-chart/stock/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getSummaryBrokerChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/summary-chart/broker/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getInventoryStockChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/inventory-chart/stock/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getInventoryBrokerChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/inventory-chart/broker/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getMomentumChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/momentum-chart/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getIntradayInventoryChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/intraday-inventory-chart/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getSankeyChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/sankey-chart/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getPriceTable(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/price-table/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getTimeTable(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/time-table/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getPriceDiary(code, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/price-diary/{code}', cache: 'default', pathParams: { code } }, options);
+    }
+    getPriceSeasonality(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/price-seasonality/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getShareholderAbove(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder-above', cache: 'default', query: params }, options);
+    }
+    getShareholderAboveChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder-above-chart/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getShareholderOne(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder-one', cache: 'default', query: params }, options);
+    }
+    getShareholderOneChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder-one-chart/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getInsider(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/shareholder-insider', cache: 'default', query: params }, options);
+    }
+    getInsiderChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/insider-chart/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getFinancialStatement(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/financial-statement/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getFinancialStatementChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/financial-statement-chart/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getKeystat(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/keystat/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getKeystatChart(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/keystat-chart/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    getCalendar(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/calendar', cache: 'default', query: params }, options);
+    }
+    getNews(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/news', cache: 'default', query: params }, options);
+    }
+    getDisclosure(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/disclosure', cache: 'default', query: params }, options);
+    }
+}
+class BatchResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    getOrderBook(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/batch/order-book/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getIntradayData(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/batch/intraday-data/{code}', cache: 'realtime', pathParams: { code }, query: params }, options);
+    }
+    getIntradayIndex(code, options) {
+        return this.transport.request({ method: 'GET', route: '/batch/intraday-index/{code}', cache: 'realtime', pathParams: { code } }, options);
+    }
+}
+class SearchResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    search(params, options) {
+        return this.transport.request({ method: 'GET', route: '/search', cache: 'default', query: params }, options);
+    }
+    searchStock(params, options) {
+        return this.transport.request({ method: 'GET', route: '/search/stock', cache: 'default', query: params }, options);
+    }
+    searchUser(params, options) {
+        return this.transport.request({ method: 'GET', route: '/search/user', cache: 'default', query: params }, options);
+    }
+}
+class ScreenerResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    screen(body, options) {
+        return this.transport.request({ method: 'POST', route: '/screener/screen', cache: 'none', body }, options);
+    }
+    list(options) {
+        return this.transport.request({ method: 'GET', route: '/screener', cache: 'default' }, options);
+    }
+    save(body, options) {
+        return this.transport.request({ method: 'POST', route: '/screener', cache: 'none', body }, options);
+    }
+    update(id, body, options) {
+        return this.transport.request({ method: 'PUT', route: '/screener/{id}', cache: 'none', pathParams: { id }, body }, options);
+    }
+    delete(id, options) {
+        return this.transport.request({ method: 'DELETE', route: '/screener/{id}', cache: 'none', pathParams: { id } }, options);
+    }
+}
+class UsageResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    getApiUsage(options) {
+        return this.transport.request({ method: 'GET', route: '/usage/api', cache: 'none' }, options);
+    }
+    getLogs(params, options) {
+        return this.transport.request({ method: 'GET', route: '/usage/logs', cache: 'none', query: params }, options);
+    }
+}
+class WatchlistsResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    list(params, options) {
+        return this.transport.request({ method: 'GET', route: '/watchlists', cache: 'default', query: params }, options);
+    }
+    add(body, options) {
+        return this.transport.request({ method: 'POST', route: '/watchlists', cache: 'none', body }, options);
+    }
+    delete(body, options) {
+        return this.transport.request({ method: 'DELETE', route: '/watchlists', cache: 'none', body }, options);
+    }
+    listGroups(options) {
+        return this.transport.request({ method: 'GET', route: '/watchlists/group', cache: 'default' }, options);
+    }
+    addGroup(body, options) {
+        return this.transport.request({ method: 'POST', route: '/watchlists/group', cache: 'none', body }, options);
+    }
+    updateGroup(id, body, options) {
+        return this.transport.request({ method: 'PUT', route: '/watchlists/group/{id}', cache: 'none', pathParams: { id }, body }, options);
+    }
+    deleteGroup(id, options) {
+        return this.transport.request({ method: 'DELETE', route: '/watchlists/group/{id}', cache: 'none', pathParams: { id } }, options);
+    }
+    update(id, body, options) {
+        return this.transport.request({ method: 'PUT', route: '/watchlists/{id}', cache: 'none', pathParams: { id }, body }, options);
+    }
+    updateNote(id, body, options) {
+        return this.transport.request({ method: 'PATCH', route: '/watchlists/{id}', cache: 'none', pathParams: { id }, body }, options);
+    }
+}
+class JournalsResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    add(body, options) {
+        return this.transport.request({ method: 'POST', route: '/journals', cache: 'none', body }, options);
+    }
+    list(params, options) {
+        return this.transport.request({ method: 'GET', route: '/journals', cache: 'default', query: params }, options);
+    }
+    delete(body, options) {
+        return this.transport.request({ method: 'DELETE', route: '/journals', cache: 'none', body }, options);
+    }
+    getSummary(params, options) {
+        return this.transport.request({ method: 'GET', route: '/journals/summary', cache: 'default', query: params }, options);
+    }
+}
+class PortfoliosResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    list(options) {
+        return this.transport.request({ method: 'GET', route: '/portfolios', cache: 'default' }, options);
+    }
+    getSummary(options) {
+        return this.transport.request({ method: 'GET', route: '/portfolios/summary', cache: 'default' }, options);
+    }
+}
+class AlertsResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    create(body, options) {
+        return this.transport.request({ method: 'POST', route: '/alerts', cache: 'none', body }, options);
+    }
+    list(options) {
+        return this.transport.request({ method: 'GET', route: '/alerts', cache: 'default' }, options);
+    }
+    test(body, options) {
+        return this.transport.request({ method: 'POST', route: '/alerts/test', cache: 'none', body }, options);
+    }
+    update(id, body, options) {
+        return this.transport.request({ method: 'PUT', route: '/alerts/{id}', cache: 'none', pathParams: { id }, body }, options);
+    }
+    delete(id, options) {
+        return this.transport.request({ method: 'DELETE', route: '/alerts/{id}', cache: 'none', pathParams: { id } }, options);
+    }
+}
+class PostsResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    list(params, options) {
+        return this.transport.request({ method: 'GET', route: '/posts', cache: 'default', query: params }, options);
+    }
+    listByCategory(category, params, options) {
+        return this.transport.request({ method: 'GET', route: '/posts/category/{category}', cache: 'default', pathParams: { category }, query: params }, options);
+    }
+    listByStock(code, params, options) {
+        return this.transport.request({ method: 'GET', route: '/posts/space/{code}', cache: 'default', pathParams: { code }, query: params }, options);
+    }
+    listByStockCategory(code, category, params, options) {
+        return this.transport.request({ method: 'GET', route: '/posts/space/category/{code}/{category}', cache: 'default', pathParams: { code, category }, query: params }, options);
+    }
+    get(id, options) {
+        return this.transport.request({ method: 'GET', route: '/posts/detail/{id}', cache: 'default', pathParams: { id } }, options);
+    }
+    getComments(id, params, options) {
+        return this.transport.request({ method: 'GET', route: '/posts/comment/{id}', cache: 'default', pathParams: { id }, query: params }, options);
+    }
+    getLikes(params, options) {
+        return this.transport.request({ method: 'GET', route: '/posts/like', cache: 'default', query: params }, options);
+    }
+    getFavorites(params, options) {
+        return this.transport.request({ method: 'GET', route: '/posts/favorite', cache: 'default', query: params }, options);
+    }
+    getVoters(id, options) {
+        return this.transport.request({ method: 'GET', route: '/posts/vote/{id}', cache: 'default', pathParams: { id } }, options);
+    }
+}
+class TradesResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    list(params, options) {
+        return this.transport.request({ method: 'GET', route: '/trades', cache: 'default', query: params }, options);
+    }
+    delete(body, options) {
+        return this.transport.request({ method: 'DELETE', route: '/trades', cache: 'none', body }, options);
+    }
+    getSummary(params, options) {
+        return this.transport.request({ method: 'GET', route: '/trades/summary', cache: 'default', query: params }, options);
+    }
+    getSummaryChart(params, options) {
+        return this.transport.request({ method: 'GET', route: '/trades/summary-chart', cache: 'default', query: params }, options);
+    }
+    updateNote(id, body, options) {
+        return this.transport.request({ method: 'PATCH', route: '/trades/{id}', cache: 'none', pathParams: { id }, body }, options);
+    }
+}
+class InvezgoResources {
+    analysis;
+    batch;
+    search;
+    screener;
+    usage;
+    watchlists;
+    journals;
+    portfolios;
+    alerts;
+    posts;
+    trades;
+    constructor(transport) {
+        this.analysis = new AnalysisResource(transport);
+        this.batch = new BatchResource(transport);
+        this.search = new SearchResource(transport);
+        this.screener = new ScreenerResource(transport);
+        this.usage = new UsageResource(transport);
+        this.watchlists = new WatchlistsResource(transport);
+        this.journals = new JournalsResource(transport);
+        this.portfolios = new PortfoliosResource(transport);
+        this.alerts = new AlertsResource(transport);
+        this.posts = new PostsResource(transport);
+        this.trades = new TradesResource(transport);
+    }
+}
+
+const encoder = new TextEncoder();
+class LruCache {
+    maxEntries;
+    maxBytes;
+    now;
+    map = new Map();
+    totalBytes = 0;
+    constructor(maxEntries, maxBytes, now = () => performance.now()) {
+        this.maxEntries = maxEntries;
+        this.maxBytes = maxBytes;
+        this.now = now;
+    }
+    get size() {
+        return this.map.size;
+    }
+    get bytes() {
+        return this.totalBytes;
+    }
+    get(key) {
+        const entry = this.map.get(key);
+        if (!entry)
+            return undefined;
+        this.map.delete(key);
+        if (entry.expiresAt <= this.now()) {
+            this.totalBytes -= entry.size;
+            return undefined;
+        }
+        this.map.set(key, entry);
+        return entry.body;
+    }
+    set(key, body, ttlMs) {
+        const size = encoder.encode(body).length;
+        this.delete(key);
+        if (ttlMs <= 0 || size > this.maxBytes || this.maxEntries <= 0)
+            return;
+        this.map.set(key, { body, size, expiresAt: this.now() + ttlMs });
+        this.totalBytes += size;
+        for (const [oldest, entry] of this.map) {
+            if (this.map.size <= this.maxEntries && this.totalBytes <= this.maxBytes)
+                break;
+            this.map.delete(oldest);
+            this.totalBytes -= entry.size;
+        }
+    }
+    delete(key) {
+        const entry = this.map.get(key);
+        if (entry) {
+            this.map.delete(key);
+            this.totalBytes -= entry.size;
+        }
+    }
+    deleteWhere(predicate) {
+        for (const key of [...this.map.keys()])
+            if (predicate(key))
+                this.delete(key);
+    }
+    clear() {
+        this.map.clear();
+        this.totalBytes = 0;
+    }
+}
+
+class InvezgoError extends Error {
+    status;
+    error;
+    requestId;
+    path;
+    body;
+    constructor(init) {
+        super(init.message, init.cause === undefined ? undefined : { cause: init.cause });
+        this.name = new.target.name;
+        this.status = init.status;
+        this.error = init.error;
+        this.requestId = init.requestId;
+        this.path = init.path;
+        this.body = init.body;
+    }
+}
+class ValidationError extends InvezgoError {
+}
+class AuthenticationError extends InvezgoError {
+}
+class PaymentRequiredError extends InvezgoError {
+}
+class NotFoundError extends InvezgoError {
+}
+class ServerError extends InvezgoError {
+}
+class RateLimitError extends InvezgoError {
+    retryAfter;
+    limit;
+    remaining;
+    reset;
+    quotaExceeded;
+    constructor(init) {
+        super(init);
+        this.retryAfter = init.retryAfter;
+        this.limit = init.limit;
+        this.remaining = init.remaining;
+        this.reset = init.reset;
+        this.quotaExceeded = init.quotaExceeded;
+    }
+}
+class ConnectionError extends InvezgoError {
+}
+class TimeoutError extends ConnectionError {
+}
+function errorClassFor(status) {
+    if (status === 400 || status === 422)
+        return ValidationError;
+    if (status === 401)
+        return AuthenticationError;
+    if (status === 402)
+        return PaymentRequiredError;
+    if (status === 404)
+        return NotFoundError;
+    if (status >= 500)
+        return ServerError;
+    return InvezgoError;
+}
+
+const VERSION = '2.0.0';
+const DEFAULT_BASE_URL = 'https://api.invezgo.com';
+const PERSONAL_SEGMENTS = new Set(['watchlists', 'journals', 'portfolios', 'trades', 'alerts', 'screener']);
+const QUOTA_MESSAGE = /quota|kuota|monthly|bulanan/i;
+class Transport {
+    keys;
+    baseUrl;
+    timeout;
+    fetchImpl;
+    cache;
+    ttlMs = 0;
+    realtimeTtlMs = 0;
+    blocks = new Map();
+    constructor(config) {
+        if (!config || typeof config.apiKey !== 'string' || !config.apiKey.trim()) {
+            throw new TypeError('Invezgo: `apiKey` is required');
+        }
+        this.keys = [...new Set([config.apiKey, ...(config.additionalApiKeys ?? [])].filter((k) => !!k && !!k.trim()))];
+        this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.timeout = config.timeout ?? 30_000;
+        const f = config.fetch ?? globalThis.fetch;
+        if (typeof f !== 'function')
+            throw new TypeError('Invezgo: global fetch is unavailable; pass `fetch` in the config (Node >= 18)');
+        this.fetchImpl = f;
+        if (config.cache !== false) {
+            const o = config.cache === true || config.cache === undefined ? {} : config.cache;
+            this.cache = new LruCache(o.maxEntries ?? 1000, o.maxBytes ?? 32 * 1024 * 1024);
+            this.ttlMs = (o.ttl ?? 60) * 1000;
+            this.realtimeTtlMs = (o.realtimeTtl ?? 5) * 1000;
+        }
+    }
+    clearCache() {
+        this.cache?.clear();
+    }
+    async request(spec, options) {
+        const path = spec.route.replace(/\{(\w+)\}/g, (_, name) => {
+            const value = spec.pathParams?.[name];
+            if (value === undefined || value === null || value === '')
+                throw new TypeError(`Invezgo: path parameter \`${name}\` is required`);
+            return encodeURIComponent(String(value));
+        });
+        const qs = canonicalQuery(spec.query);
+        const target = qs ? `${path}?${qs}` : path;
+        const ttl = spec.method !== 'GET' ? 0 : spec.cache === 'realtime' ? this.realtimeTtlMs : spec.cache === 'default' ? this.ttlMs : 0;
+        if (this.cache && ttl > 0) {
+            const hit = this.cache.get(target);
+            if (hit !== undefined)
+                return parseBody(hit);
+        }
+        const tried = new Set();
+        let last;
+        for (;;) {
+            const index = this.pickKey(spec.route, tried);
+            if (index < 0)
+                throw this.allKeysBlocked(spec.route, last);
+            tried.add(index);
+            const res = await this.send(index, spec, target, options);
+            const text = await res.text();
+            if (res.status === 429) {
+                last = this.rateLimited(index, spec.route, res, text);
+                continue;
+            }
+            if (!res.ok)
+                throw buildError(res, text);
+            let data;
+            try {
+                data = parseBody(text);
+            }
+            catch (cause) {
+                throw new InvezgoError({ status: res.status, message: 'Invezgo: response is not valid JSON', body: text, path, cause });
+            }
+            if (this.cache) {
+                if (ttl > 0)
+                    this.cache.set(target, text, ttl);
+                else if (spec.method !== 'GET')
+                    this.cache.deleteWhere((key) => PERSONAL_SEGMENTS.has(key.split(/[/?]/)[1]));
+            }
+            return data;
+        }
+    }
+    async send(index, spec, target, options) {
+        const headers = {
+            Authorization: `Bearer ${this.keys[index]}`,
+            Accept: 'application/json',
+            'User-Agent': `invezgo-js-sdk/${VERSION}`,
+        };
+        let body;
+        if (spec.body !== undefined) {
+            headers['Content-Type'] = 'application/json';
+            body = JSON.stringify(spec.body);
+        }
+        const controller = new AbortController();
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, this.timeout);
+        const signal = options?.signal;
+        const onAbort = () => controller.abort(signal?.reason);
+        if (signal?.aborted)
+            onAbort();
+        else
+            signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            return await this.fetchImpl(this.baseUrl + target, { method: spec.method, headers, body, signal: controller.signal });
+        }
+        catch (cause) {
+            if (signal?.aborted)
+                throw cause;
+            if (timedOut)
+                throw new TimeoutError({ status: 0, message: `Invezgo: request timed out after ${this.timeout} ms`, path: target, cause });
+            throw new ConnectionError({ status: 0, message: `Invezgo: network error: ${cause?.message ?? cause}`, path: target, cause });
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+        }
+    }
+    blockedFor(index, route, now) {
+        let ms = 0;
+        let quota = false;
+        for (const [id, isQuota] of [[`${index}`, true], [`${index} ${route}`, false]]) {
+            const b = this.blocks.get(id);
+            if (!b)
+                continue;
+            if (b.until <= now)
+                this.blocks.delete(id);
+            else if (b.until - now > ms) {
+                ms = b.until - now;
+                quota = isQuota;
+            }
+        }
+        return { ms, quota };
+    }
+    pickKey(route, tried) {
+        const now = performance.now();
+        for (let i = 0; i < this.keys.length; i++) {
+            if (!tried.has(i) && this.blockedFor(i, route, now).ms === 0)
+                return i;
+        }
+        return -1;
+    }
+    rateLimited(index, route, res, text) {
+        const err = buildError(res, text);
+        const retryAfter = num(res.headers.get('retry-after'));
+        const reset = num(res.headers.get('x-ratelimit-reset'));
+        let wait = 60;
+        if (retryAfter !== undefined && retryAfter > 0)
+            wait = retryAfter;
+        else if (reset !== undefined && reset - Date.now() / 1000 > 0)
+            wait = reset - Date.now() / 1000;
+        const quota = QUOTA_MESSAGE.test(err.message);
+        this.blocks.set(quota ? `${index}` : `${index} ${route}`, { until: performance.now() + wait * 1000, quota });
+        return new RateLimitError({
+            status: 429,
+            message: err.message,
+            error: err.error,
+            requestId: err.requestId,
+            path: err.path,
+            body: err.body,
+            retryAfter: Math.ceil(wait),
+            limit: num(res.headers.get('x-ratelimit-limit')),
+            remaining: num(res.headers.get('x-ratelimit-remaining')),
+            reset,
+            quotaExceeded: quota,
+        });
+    }
+    allKeysBlocked(route, last) {
+        const now = performance.now();
+        let min = Infinity;
+        let allQuota = true;
+        for (let i = 0; i < this.keys.length; i++) {
+            const b = this.blockedFor(i, route, now);
+            min = Math.min(min, b.ms);
+            allQuota &&= b.quota;
+        }
+        const retryAfter = Math.max(0, Math.ceil((Number.isFinite(min) ? min : 0) / 1000));
+        if (last) {
+            return new RateLimitError({ ...last, message: last.message, retryAfter, quotaExceeded: last.quotaExceeded });
+        }
+        return new RateLimitError({
+            status: 429,
+            message: `Invezgo: all API keys are rate limited; retry in ${retryAfter}s`,
+            retryAfter,
+            quotaExceeded: allQuota,
+        });
+    }
+}
+function canonicalQuery(query) {
+    if (!query)
+        return '';
+    const entries = Object.entries(query)
+        .filter(([, v]) => v !== undefined && v !== null)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([k, v]) => [k, String(v)]);
+    return new URLSearchParams(entries).toString();
+}
+function parseBody(text) {
+    return text.trim() === '' ? null : JSON.parse(text);
+}
+function num(value) {
+    if (value === null || value.trim() === '')
+        return undefined;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : undefined;
+}
+function buildError(res, text) {
+    let body = text;
+    try {
+        body = text ? JSON.parse(text) : undefined;
+    }
+    catch {
+    }
+    const b = (typeof body === 'object' && body !== null ? body : {});
+    const msg = Array.isArray(b.message) ? b.message.join('; ') : typeof b.message === 'string' ? b.message : '';
+    const Cls = errorClassFor(res.status);
+    return new Cls({
+        status: res.status,
+        message: msg || res.statusText || `HTTP ${res.status}`,
+        error: typeof b.error === 'string' ? b.error : undefined,
+        requestId: typeof b.requestId === 'string' ? b.requestId : (res.headers.get('request-id') ?? undefined),
+        path: typeof b.path === 'string' ? b.path : undefined,
+        body,
+    });
+}
+
+class Invezgo extends InvezgoResources {
+    #transport;
+    constructor(config) {
+        const transport = new Transport(config);
+        super(transport);
+        this.#transport = transport;
+    }
+    clearCache() {
+        this.#transport.clearCache();
+    }
+}
+
+export { AlertsResource, AnalysisResource, AuthenticationError, BatchResource, ConnectionError, DEFAULT_BASE_URL, Invezgo, Invezgo as InvezgoClient, InvezgoError, InvezgoResources, JournalsResource, NotFoundError, PaymentRequiredError, PortfoliosResource, PostsResource, RateLimitError, ScreenerResource, SearchResource, ServerError, TimeoutError, TradesResource, UsageResource, VERSION, ValidationError, WatchlistsResource, Invezgo as default };
+//# sourceMappingURL=index.mjs.map