@invezgo/sdk 1.3.1 → 2.0.1

package/dist/index.js

@@ -1,1054 +1,804 @@
-class InvezgoError extends Error {
-    constructor(statusCode, message, error, response) {
-        super(message);
-        this.statusCode = statusCode;
-        this.message = message;
-        this.error = error;
-        this.response = response;
-        this.name = 'InvezgoError';
-        Object.setPrototypeOf(this, InvezgoError.prototype);
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class AnalysisResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
     }
-}
-class HttpClient {
-    constructor(config) {
-        // Ensure baseURL doesn't have trailing slash since paths start with /
-        const baseURL = config.baseURL || 'https://api.invezgo.com';
-        this.baseURL = baseURL.endsWith('/') ? baseURL.slice(0, -1) : baseURL;
-        this.apiKey = config.apiKey;
-        this.timeout = config.timeout || 30000;
-        if (!this.apiKey) {
-            throw new Error('API Key is required');
-        }
+    getStockList(options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/list/stock', cache: 'default' }, options);
     }
-    async request(method, path, options = {}) {
-        const url = `${this.baseURL}${path}`;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), options.timeout || this.timeout);
-        try {
-            const headers = {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-                ...options.headers,
-            };
-            const response = await fetch(url, {
-                method,
-                headers,
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            // Handle 204 No Content
-            if (response.status === 204) {
-                return [];
-            }
-            const data = await response.json().catch(() => ({}));
-            // Handle error responses
-            if (!response.ok) {
-                throw new InvezgoError(response.status, data?.message || response.statusText, data?.error, data);
-            }
-            return data;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error.name === 'AbortError') {
-                throw new InvezgoError(408, 'Request timeout', 'Timeout');
-            }
-            if (error instanceof InvezgoError) {
-                throw error;
-            }
-            throw new InvezgoError(500, error.message || 'Unknown error occurred', 'InternalError', error);
-        }
+    getBrokerList(options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/list/broker', cache: 'default' }, options);
     }
-    async get(path, params, options) {
-        let url = path;
-        if (params && Object.keys(params).length > 0) {
-            const searchParams = new URLSearchParams();
-            Object.entries(params).forEach(([key, value]) => {
-                if (value !== undefined && value !== null) {
-                    if (Array.isArray(value)) {
-                        value.forEach(v => searchParams.append(key, String(v)));
-                    }
-                    else {
-                        searchParams.append(key, String(value));
-                    }
-                }
-            });
-            url = `${path}?${searchParams.toString()}`;
-        }
-        return this.request('GET', url, options);
-    }
-    async post(path, body, options) {
-        const requestOptions = {
-            ...options,
-            headers: {
-                ...options?.headers,
-            },
-        };
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), requestOptions.timeout || this.timeout);
-        try {
-            const url = `${this.baseURL}${path}`;
-            const headers = {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-                ...requestOptions.headers,
-            };
-            const response = await fetch(url, {
-                method: 'POST',
-                headers,
-                body: body ? JSON.stringify(body) : undefined,
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (response.status === 204) {
-                return {};
-            }
-            const data = await response.json().catch(() => ({}));
-            if (!response.ok) {
-                throw new InvezgoError(response.status, data?.message || response.statusText, data?.error, data);
-            }
-            return data;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error.name === 'AbortError') {
-                throw new InvezgoError(408, 'Request timeout', 'Timeout');
-            }
-            if (error instanceof InvezgoError) {
-                throw error;
-            }
-            throw new InvezgoError(500, error.message || 'Unknown error occurred', 'InternalError', error);
-        }
+    getIndexList(options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/list/index', cache: 'default' }, options);
     }
-    async put(path, body, options) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), options?.timeout || this.timeout);
-        try {
-            const url = `${this.baseURL}${path}`;
-            const headers = {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-                ...options?.headers,
-            };
-            const response = await fetch(url, {
-                method: 'PUT',
-                headers,
-                body: body ? JSON.stringify(body) : undefined,
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (response.status === 204) {
-                return {};
-            }
-            const data = await response.json().catch(() => ({}));
-            if (!response.ok) {
-                throw new InvezgoError(response.status, data?.message || response.statusText, data?.error, data);
-            }
-            return data;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error.name === 'AbortError') {
-                throw new InvezgoError(408, 'Request timeout', 'Timeout');
-            }
-            if (error instanceof InvezgoError) {
-                throw error;
-            }
-            throw new InvezgoError(500, error.message || 'Unknown error occurred', 'InternalError', error);
-        }
+    getUma(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/uma', cache: 'default', query: params }, options);
     }
-    async patch(path, body, options) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), options?.timeout || this.timeout);
-        try {
-            const url = `${this.baseURL}${path}`;
-            const headers = {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-                ...options?.headers,
-            };
-            const response = await fetch(url, {
-                method: 'PATCH',
-                headers,
-                body: body ? JSON.stringify(body) : undefined,
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (response.status === 204) {
-                return {};
-            }
-            const data = await response.json().catch(() => ({}));
-            if (!response.ok) {
-                throw new InvezgoError(response.status, data?.message || response.statusText, data?.error, data);
-            }
-            return data;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error.name === 'AbortError') {
-                throw new InvezgoError(408, 'Request timeout', 'Timeout');
-            }
-            if (error instanceof InvezgoError) {
-                throw error;
-            }
-            throw new InvezgoError(500, error.message || 'Unknown error occurred', 'InternalError', error);
-        }
+    getSuspend(params, options) {
+        return this.transport.request({ method: 'GET', route: '/analysis/suspend', cache: 'default', query: params }, options);
     }
-    async delete(path, params, options) {
-        let url = path;
-        if (params && Object.keys(params).length > 0) {
-            const searchParams = new URLSearchParams();
-            Object.entries(params).forEach(([key, value]) => {
-                if (value !== undefined && value !== null) {
-                    if (Array.isArray(value)) {
-                        value.forEach(v => searchParams.append(key, String(v)));
-                    }
-                    else {
-                        searchParams.append(key, String(value));
-                    }
-                }
-            });
-            url = `${path}?${searchParams.toString()}`;
-        }
-        return this.request('DELETE', url, 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 AlertsEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get list of alerts.
-     */
-    async list() {
-        return this.client.get('/alerts');
-    }
-    /**
-     * Create alert.
-     */
-    async add(dto) {
-        return this.client.post('/alerts', dto);
-    }
-    /**
-     * Update alert.
-     */
-    async update(id, dto) {
-        return this.client.put(`/alerts/${id}`, dto);
-    }
-    /**
-     * Delete alert.
-     */
-    async delete(id) {
-        return this.client.delete(`/alerts/${id}`);
-    }
-    /**
-     * Test alert formula.
-     */
-    async test(dto) {
-        return this.client.post('/alerts/test', dto);
+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 AnalysisEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get list of all stocks listed on BEI.
-     */
-    async getStockList() {
-        return this.client.get('/analysis/list/stock');
-    }
-    /**
-     * Get list of all brokers/securities on BEI.
-     */
-    async getBrokerList() {
-        return this.client.get('/analysis/list/broker');
-    }
-    /**
-     * Get list of all supported IDX indexes.
-     */
-    async getIndexList() {
-        return this.client.get('/analysis/list/index');
-    }
-    /**
-     * Get complete company information.
-     */
-    async getInformation(code) {
-        return this.client.get(`/analysis/information/${code}`);
-    }
-    /**
-     * Get top gainer and loser stocks for a specific date.
-     */
-    async getTopChange(date) {
-        return this.client.get('/analysis/top/change', { date });
-    }
-    /**
-     * Get top foreign accumulation and distribution.
-     */
-    async getTopForeign(date) {
-        return this.client.get('/analysis/top/foreign', { date });
-    }
-    /**
-     * Get top bandarmology accumulation and distribution.
-     */
-    async getTopAccumulation(date) {
-        return this.client.get('/analysis/top/accumulation', { date });
-    }
-    /**
-     * Get top retail accumulation and distribution.
-     */
-    async getTopRitel(date) {
-        return this.client.get('/analysis/top/ritel', { date });
-    }
-    /**
-     * Alias for getTopRitel.
-     */
-    async getTopRetail(date) {
-        return this.getTopRitel(date);
-    }
-    /**
-     * Get intraday chart data.
-     */
-    async getIntradayChart(code, market = 'RG') {
-        return this.client.get(`/analysis/intraday/${code}`, { market });
-    }
-    /**
-     * Get intraday stock summary data.
-     */
-    async getIntradayData(code, market = 'RG') {
-        return this.client.get(`/analysis/intraday-data/${code}`, { market });
-    }
-    /**
-     * Get intraday index summary data.
-     */
-    async getIntradayIndex(code, market = 'RG') {
-        return this.client.get(`/analysis/intraday-index/${code}`, { market });
-    }
-    /**
-     * Get order book data.
-     */
-    async getOrderBook(code, market = 'RG') {
-        return this.client.get(`/analysis/order-book/${code}`, { market });
-    }
-    /**
-     * Get complete stock chart data.
-     */
-    async getChart(code, params) {
-        return this.client.get(`/analysis/chart/stock/${code}`, params);
-    }
-    /**
-     * Get historical index chart data.
-     */
-    async getIndexChart(code, params) {
-        return this.client.get(`/analysis/chart/index/${code}`, params);
-    }
-    /**
-     * Get stock chart with technical indicator.
-     */
-    async getIndicatorChart(code, indicator, params) {
-        return this.client.get(`/analysis/chart/stock/${indicator}/${code}`, params);
-    }
-    /**
-     * Get shareholder detail above 5%.
-     */
-    async getShareholderDetail(code) {
-        return this.client.get(`/analysis/shareholder-detail/${code}`);
-    }
-    /**
-     * Get shareholder detail above 1% for a specific holder.
-     */
-    async getShareholderDetailOne(params) {
-        return this.client.get('/analysis/shareholder-detail-one', params);
-    }
-    /**
-     * Get number of shareholders.
-     */
-    async getShareholderNumber(code) {
-        return this.client.get(`/analysis/shareholder/number/${code}`);
-    }
-    /**
-     * Get shareholder relation graph.
-     */
-    async getShareholderRelation(params) {
-        return this.client.get('/analysis/shareholder/relation', params);
-    }
-    /**
-     * Get shareholder composition.
-     */
-    async getShareholder(code) {
-        return this.client.get(`/analysis/shareholder/${code}`);
-    }
-    /**
-     * Get KSEI shareholder data.
-     */
-    async getShareholderKSEI(code, range) {
-        return this.client.get(`/analysis/shareholder/ksei/${code}`, {
-            range: Math.min(range, 12),
-        });
+class SearchResource {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
     }
-    /**
-     * Get broker summary for a stock.
-     */
-    async getBrokerSummaryStock(code, params) {
-        return this.client.get(`/analysis/summary/stock/${code}`, params);
-    }
-    /**
-     * Get broker summary for a broker.
-     */
-    async getBrokerSummaryBroker(code, params) {
-        return this.client.get(`/analysis/summary/broker/${code}`, params);
-    }
-    /**
-     * Get sector stalker data.
-     */
-    async getStalkerSector(params) {
-        return this.client.get('/analysis/stalker/sector', params);
-    }
-    /**
-     * Get sector rotation chart.
-     */
-    async getSectorRotation(params) {
-        return this.client.get('/analysis/sector/rotation', params);
-    }
-    /**
-     * Get broker stalker data for a stock.
-     */
-    async getBrokerStalker(broker, stock, params) {
-        return this.client.get(`/analysis/stalker/broker/${broker}/${stock}`, params);
-    }
-    /**
-     * Get broker stalker list.
-     */
-    async getBrokerStalkerList(code, params) {
-        return this.client.get(`/analysis/stalker/list/${code}`, params);
-    }
-    /**
-     * Get broker summary chart for a stock.
-     */
-    async getBrokerSummaryChartStock(code, params) {
-        return this.client.get(`/analysis/summary-chart/stock/${code}`, params);
-    }
-    /**
-     * Get broker summary chart for a broker.
-     */
-    async getBrokerSummaryChartBroker(code, params) {
-        return this.client.get(`/analysis/summary-chart/broker/${code}`, params);
-    }
-    /**
-     * Get inventory chart for a stock.
-     */
-    async getInventoryChartStock(code, params) {
-        return this.client.get(`/analysis/inventory-chart/stock/${code}`, params);
-    }
-    /**
-     * Get inventory chart for a broker.
-     */
-    async getInventoryChartBroker(code, params) {
-        return this.client.get(`/analysis/inventory-chart/broker/${code}`, params);
-    }
-    /**
-     * Get momentum chart.
-     */
-    async getMomentumChart(code, params) {
-        return this.client.get(`/analysis/momentum-chart/${code}`, params);
-    }
-    /**
-     * Get intraday inventory chart.
-     */
-    async getIntradayInventoryChart(code, params) {
-        return this.client.get(`/analysis/intraday-inventory-chart/${code}`, params);
-    }
-    /**
-     * Get distribution or crossing chart.
-     */
-    async getSankeyChart(code, params) {
-        return this.client.get(`/analysis/sankey-chart/${code}`, params);
-    }
-    /**
-     * Get price table.
-     */
-    async getPriceTable(code, date) {
-        return this.client.get(`/analysis/price-table/${code}`, { date });
-    }
-    /**
-     * Get time table.
-     */
-    async getTimeTable(code, params) {
-        return this.client.get(`/analysis/time-table/${code}`, params);
-    }
-    /**
-     * Get price diary.
-     */
-    async getPriceDiary(code) {
-        return this.client.get(`/analysis/price-diary/${code}`);
-    }
-    /**
-     * Get price seasonality.
-     */
-    async getPriceSeasonality(code, range) {
-        return this.client.get(`/analysis/price-seasonality/${code}`, {
-            range: Math.min(range, 60),
-        });
+    search(params, options) {
+        return this.transport.request({ method: 'GET', route: '/search', cache: 'default', query: params }, options);
     }
-    /**
-     * Get shareholders above 5%.
-     */
-    async getShareholderAbove(params) {
-        return this.client.get('/analysis/shareholder-above', params);
-    }
-    /**
-     * Get shareholder above 5% chart.
-     */
-    async getShareholderAboveChart(code, params) {
-        return this.client.get(`/analysis/shareholder-above-chart/${code}`, params);
-    }
-    /**
-     * Get shareholders above 1%.
-     */
-    async getShareholderOne(params) {
-        return this.client.get('/analysis/shareholder-one', params);
-    }
-    /**
-     * Get shareholder above 1% chart.
-     */
-    async getShareholderOneChart(code, params) {
-        return this.client.get(`/analysis/shareholder-one-chart/${code}`, params);
-    }
-    /**
-     * Get insider trading data.
-     */
-    async getInsiderTrading(params) {
-        return this.client.get('/analysis/shareholder-insider', params);
-    }
-    /**
-     * Get insider chart.
-     */
-    async getInsiderChart(code, params) {
-        return this.client.get(`/analysis/insider-chart/${code}`, params);
-    }
-    /**
-     * Get financial statement.
-     */
-    async getFinancialStatement(code, params) {
-        return this.client.get(`/analysis/financial-statement/${code}`, { ...params, limit: Math.min(params.limit, 20) });
-    }
-    /**
-     * Get financial statement chart.
-     */
-    async getFinancialStatementChart(code, params) {
-        return this.client.get(`/analysis/financial-statement-chart/${code}`, { ...params, limit: Math.min(params.limit, 20) });
-    }
-    /**
-     * Get key statistics.
-     */
-    async getKeyStat(code, params) {
-        return this.client.get(`/analysis/keystat/${code}`, {
-            ...params,
-            limit: Math.min(params.limit, 20),
-        });
+    searchStock(params, options) {
+        return this.transport.request({ method: 'GET', route: '/search/stock', cache: 'default', query: params }, options);
     }
-    /**
-     * Get key statistics chart.
-     */
-    async getKeyStatChart(code, params) {
-        return this.client.get(`/analysis/keystat-chart/${code}`, {
-            ...params,
-            limit: Math.min(params.limit, 20),
-        });
+    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);
     }
-    /**
-     * Get corporate action calendar.
-     */
-    async getCalendar(params) {
-        return this.client.get('/analysis/calendar', params);
-    }
-    /**
-     * Alias for getCalendar.
-     */
-    async getCorporateActionCalendar(params) {
-        return this.getCalendar(params);
-    }
-    /**
-     * Get multi-timeframe chart data for stocks or indexes.
-     */
-    async getMultiTimeChart(code, params) {
-        return this.client.get(`/analysis/chart/multi-time/${code}`, params);
-    }
-    /**
-     * Get high concentration stock ownership data for all issuers.
-     */
-    async getShareholderHigh() {
-        return this.client.get('/analysis/shareholder/high');
-    }
-    /**
-     * Get complete shareholder data with all investor classifications for a specific period.
-     */
-    async getShareholderClassification(code, range) {
-        return this.client.get(`/analysis/shareholder/classification/${code}`, { range: Math.min(range, 36) });
-    }
-    /**
-     * Get latest shareholder data with investor classifications in table format.
-     */
-    async getShareholderClassifyTable(code) {
-        return this.client.get(`/analysis/shareholder/classify-table/${code}`);
-    }
-    /**
-     * Get order queue (order tracking) for a stock at a specific price, side, page, and limit.
-     */
-    async getOrderQueue(code, params) {
-        return this.client.get(`/analysis/queue/${code}`, params);
+    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 WatchlistsEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get list of watchlists.
-     */
-    async list(group = 'null') {
-        return this.client.get('/watchlists', { group });
-    }
-    /**
-     * Add stock to watchlist.
-     */
-    async add(dto) {
-        return this.client.post('/watchlists', dto);
-    }
-    /**
-     * Delete watchlist entries.
-     *
-     * The current OpenAPI spec does not describe delete filters,
-     * but the SDK keeps optional query params for batch deletion support.
-     */
-    async delete(params) {
-        return this.client.delete('/watchlists', params);
-    }
-    /**
-     * Get list of watchlist groups.
-     */
-    async listGroups() {
-        return this.client.get('/watchlists/group');
-    }
-    /**
-     * Add new watchlist group.
-     */
-    async addGroup(dto) {
-        return this.client.post('/watchlists/group', dto);
-    }
-    /**
-     * Update watchlist group.
-     */
-    async updateGroup(id, dto) {
-        return this.client.put(`/watchlists/group/${id}`, dto);
-    }
-    /**
-     * Delete watchlist group.
-     */
-    async deleteGroup(id) {
-        return this.client.delete(`/watchlists/group/${id}`);
-    }
-    /**
-     * Update watchlist.
-     */
-    async update(id, dto) {
-        return this.client.put(`/watchlists/${id}`, dto);
-    }
-    /**
-     * Update watchlist note.
-     */
-    async updateNote(id, dto) {
-        return this.client.patch(`/watchlists/${id}`, dto);
+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 JournalsEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Extract journal transactions from uploaded file.
-     */
-    async extractFromFile(file) {
-        const formData = new FormData();
-        formData.append('file', file);
-        const url = `${this.client.baseURL}/journals/file`;
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.client.apiKey}`,
-            },
-            body: formData,
-        });
-        if (!response.ok) {
-            const data = (await response.json().catch(() => ({})));
-            throw new InvezgoError(response.status, data.message || 'Failed to extract journal from file', data.error, data);
-        }
-        return response.json().catch(() => ({}));
-    }
-    /**
-     * Add new journal transaction.
-     */
-    async add(dto) {
-        return this.client.post('/journals', dto);
-    }
-    /**
-     * List journal transactions.
-     */
-    async list() {
-        return this.client.get('/journals');
-    }
-    /**
-     * Delete journal entries.
-     *
-     * The current OpenAPI spec does not describe delete filters,
-     * but the SDK keeps optional query params for batch deletion support.
-     */
-    async delete(params) {
-        return this.client.delete('/journals', params);
-    }
-    /**
-     * Get journal transactions summary.
-     */
-    async getSummary() {
-        return this.client.get('/journals/summary');
-    }
-    /**
-     * Update journal transaction note.
-     */
-    async updateNote(id, dto) {
-        return this.client.patch(`/journals/${id}`, dto);
+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 PortfoliosEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get list of portfolios
-     */
-    async list() {
-        return this.client.get('/portfolios');
-    }
-    /**
-     * Get portfolio summary
-     */
-    async getSummary() {
-        return this.client.get('/portfolios/summary');
+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 SearchEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Search for stocks or users
-     */
-    async search(query) {
-        return this.client.get('/search', { query });
-    }
-    /**
-     * Search for stocks
-     */
-    async searchStock(query, cursor) {
-        return this.client.get('/search/stock', { query, cursor });
-    }
-    /**
-     * Search for users
-     */
-    async searchUser(query, cursor) {
-        return this.client.get('/search/user', { query, cursor });
+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 ProfileEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get user profile details
-     */
-    async getUserDetails(username) {
-        return this.client.get(`/profile/detail/${username}`);
-    }
-    /**
-     * Get user posts
-     */
-    async getUserPosts(username, page, limit) {
-        return this.client.get(`/profile/posts/${username}`, { page, limit });
-    }
-    /**
-     * Get user posts by category
-     */
-    async getCategoryPosts(username, category, page, limit) {
-        return this.client.get(`/profile/posts/${username}/${category}`, { page, limit });
-    }
-    /**
-     * Get user watchlist
-     */
-    async getUserWatchlist(username) {
-        return this.client.get(`/profile/watchlist/${username}`);
-    }
-    /**
-     * Get user followers
-     */
-    async getFollowers(username) {
-        return this.client.get(`/profile/follow/${username}`);
-    }
-    /**
-     * Get users being followed
-     */
-    async getFollowing(username) {
-        return this.client.get(`/profile/following/${username}`);
-    }
-    /**
-     * Get user memberships
-     */
-    async getMemberships(username) {
-        return this.client.get(`/profile/membership/${username}`);
+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 MembershipEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get list of memberships.
-     */
-    async list() {
-        return this.client.get('/membership');
-    }
-    /**
-     * Add new membership.
-     */
-    async add(dto) {
-        return this.client.post('/membership', dto);
-    }
-    /**
-     * Get membership scopes.
-     */
-    async getScope() {
-        return this.client.get('/membership/scope');
-    }
-    /**
-     * Get membership transactions.
-     */
-    async getTransactions() {
-        return this.client.get('/membership/list');
-    }
-    /**
-     * Update membership.
-     */
-    async update(id, dto) {
-        return this.client.put(`/membership/${id}`, dto);
-    }
-    /**
-     * Delete membership.
-     */
-    async delete(id) {
-        return this.client.delete(`/membership/${id}`);
+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 PostsEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get all posts
-     */
-    async getAll() {
-        return this.client.get('/posts');
-    }
-    /**
-     * Get posts by category
-     */
-    async getByCategory(category) {
-        return this.client.get(`/posts/category/${category}`);
-    }
-    /**
-     * Get posts for a stock
-     */
-    async getStockPosts(code) {
-        return this.client.get(`/posts/space/${code}`);
-    }
-    /**
-     * Get stock posts by category
-     */
-    async getStockCategoryPosts(code, category) {
-        return this.client.get(`/posts/space/category/${code}/${category}`);
-    }
-    /**
-     * Get post details
-     */
-    async getPostById(id) {
-        return this.client.get(`/posts/detail/${id}`);
-    }
-    /**
-     * Get post comments
-     */
-    async getComments(id) {
-        return this.client.get(`/posts/comment/${id}`);
-    }
-    /**
-     * Get liked posts
-     */
-    async getLiked() {
-        return this.client.get('/posts/like');
-    }
-    /**
-     * Get favorite posts
-     */
-    async getFavorites() {
-        return this.client.get('/posts/favorite');
-    }
-    /**
-     * Get post voters
-     */
-    async getVoters(id) {
-        return this.client.get(`/posts/vote/${id}`);
+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);
     }
 }
 
-class RecommendationEndpoints {
-    constructor(client) {
-        this.client = client;
+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);
     }
-    /**
-     * Get user recommendations.
-     */
-    async getUserRecommendations() {
-        return this.client.get('/recommendation/user');
+    clear() {
+        this.map.clear();
+        this.totalBytes = 0;
     }
 }
 
-class TradesEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get list of realized trades
-     */
-    async list() {
-        return this.client.get('/trades');
-    }
-    /**
-     * Delete trades
-     */
-    async delete(params) {
-        return this.client.delete('/trades', params);
-    }
-    /**
-     * Get trades summary
-     */
-    async getSummary() {
-        return this.client.get('/trades/summary');
-    }
-    /**
-     * Get trades summary chart
-     */
-    async getSummaryChart() {
-        return this.client.get('/trades/summary-chart');
-    }
-    /**
-     * Update trade note
-     */
-    async updateNote(id, dto) {
-        return this.client.patch(`/trades/${id}`, dto);
+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 ScreenerEndpoints {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get list of preset screeners.
-     */
-    async list() {
-        return this.client.get('/screener');
-    }
-    /**
-     * Save preset screener.
-     */
-    async save(dto) {
-        return this.client.post('/screener', dto);
-    }
-    /**
-     * Update preset screener.
-     */
-    async update(id, dto) {
-        return this.client.put(`/screener/${id}`, dto);
-    }
-    /**
-     * Delete preset screener.
-     */
-    async delete(id) {
-        return this.client.delete(`/screener/${id}`);
-    }
-    /**
-     * Run screener.
-     */
-    async screen(dto) {
-        return this.client.post('/screener/screen', dto);
+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;
+}
 
-class UsageEndpoints {
-    constructor(client) {
-        this.client = client;
+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;
+        }
     }
-    /**
-     * Get API usage statistics for the configured API key.
-     */
-    async getApiUsage() {
-        return this.client.get('/usage/api');
+    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 {
+class Invezgo extends InvezgoResources {
+    #transport;
     constructor(config) {
-        this.client = new HttpClient(config);
-        this.alerts = new AlertsEndpoints(this.client);
-        this.analysis = new AnalysisEndpoints(this.client);
-        this.watchlists = new WatchlistsEndpoints(this.client);
-        this.journals = new JournalsEndpoints(this.client);
-        this.portfolios = new PortfoliosEndpoints(this.client);
-        this.search = new SearchEndpoints(this.client);
-        this.profile = new ProfileEndpoints(this.client);
-        this.membership = new MembershipEndpoints(this.client);
-        this.posts = new PostsEndpoints(this.client);
-        this.recommendation = new RecommendationEndpoints(this.client);
-        this.trades = new TradesEndpoints(this.client);
-        this.screener = new ScreenerEndpoints(this.client);
-        this.usage = new UsageEndpoints(this.client);
-    }
-    /**
-     * Update API key.
-     */
-    setApiKey(apiKey) {
-        this.client.apiKey = apiKey;
-    }
-    /**
-     * Check whether an API key is currently configured.
-     */
-    hasApiKey() {
-        return !!this.client.apiKey;
+        const transport = new Transport(config);
+        super(transport);
+        this.#transport = transport;
+    }
+    clearCache() {
+        this.#transport.clearCache();
     }
 }
 
-/**
- * Invezgo SDK for JavaScript and TypeScript.
- *
- * Official SDK for accessing Invezgo API.
- *
- * @packageDocumentation
- */
-
-export { AlertsEndpoints, Invezgo, InvezgoError, JournalsEndpoints, MembershipEndpoints, RecommendationEndpoints, ScreenerEndpoints, TradesEndpoints, UsageEndpoints, WatchlistsEndpoints, Invezgo as default };
+exports.AlertsResource = AlertsResource;
+exports.AnalysisResource = AnalysisResource;
+exports.AuthenticationError = AuthenticationError;
+exports.BatchResource = BatchResource;
+exports.ConnectionError = ConnectionError;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.Invezgo = Invezgo;
+exports.InvezgoClient = Invezgo;
+exports.InvezgoError = InvezgoError;
+exports.InvezgoResources = InvezgoResources;
+exports.JournalsResource = JournalsResource;
+exports.NotFoundError = NotFoundError;
+exports.PaymentRequiredError = PaymentRequiredError;
+exports.PortfoliosResource = PortfoliosResource;
+exports.PostsResource = PostsResource;
+exports.RateLimitError = RateLimitError;
+exports.ScreenerResource = ScreenerResource;
+exports.SearchResource = SearchResource;
+exports.ServerError = ServerError;
+exports.TimeoutError = TimeoutError;
+exports.TradesResource = TradesResource;
+exports.UsageResource = UsageResource;
+exports.VERSION = VERSION;
+exports.ValidationError = ValidationError;
+exports.WatchlistsResource = WatchlistsResource;
+exports.default = Invezgo;
 //# sourceMappingURL=index.js.map