@invezgo/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,944 @@
+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);
+    }
+}
+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');
+        }
+    }
+    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);
+        }
+    }
+    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);
+        }
+    }
+    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);
+        }
+    }
+    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);
+        }
+    }
+    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);
+    }
+}
+
+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 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 accumulation and distribution (bandarmologi)
+     */
+    async getTopAccumulation(date) {
+        return this.client.get('/analysis/top/accumulation', { date });
+    }
+    /**
+     * Get intraday chart data
+     */
+    async getIntradayChart(code, market = 'RG') {
+        return this.client.get(`/analysis/intraday/${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 stock chart with technical indicator
+     */
+    async getIndicatorChart(code, indicator, params) {
+        return this.client.get(`/analysis/chart/stock/${indicator}/${code}`, params);
+    }
+    /**
+     * Get shareholder detail (ownership)
+     */
+    async getShareholderDetail(code) {
+        return this.client.get(`/analysis/shareholder-detail/${code}`);
+    }
+    /**
+     * Get number of shareholders
+     */
+    async getShareholderNumber(code) {
+        return this.client.get(`/analysis/shareholder/number/${code}`);
+    }
+    /**
+     * 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),
+        });
+    }
+    /**
+     * 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 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) {
+        const requestParams = { ...params };
+        if (params.filter) {
+            requestParams.filter = params.filter;
+        }
+        return this.client.get(`/analysis/inventory-chart/stock/${code}`, requestParams);
+    }
+    /**
+     * Get inventory chart for a broker
+     */
+    async getInventoryChartBroker(code, params) {
+        const requestParams = { ...params };
+        if (params.filter) {
+            requestParams.filter = params.filter;
+        }
+        return this.client.get(`/analysis/inventory-chart/broker/${code}`, requestParams);
+    }
+    /**
+     * 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 sankey/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),
+        });
+    }
+    /**
+     * 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 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(Number(params.limit), 20).toString() });
+    }
+    /**
+     * Get key statistics
+     */
+    async getKeyStat(code, params) {
+        return this.client.get(`/analysis/keystat/${code}`, {
+            ...params,
+            limit: Math.min(params.limit, 20),
+        });
+    }
+    /**
+     * Get key statistics chart
+     */
+    async getKeyStatChart(code, params) {
+        return this.client.get(`/analysis/keystat-chart/${code}`, params);
+    }
+}
+
+class WatchlistsEndpoints {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get list of watchlists
+     */
+    async list(group) {
+        return this.client.get('/watchlists', { group: group || 'null' });
+    }
+    /**
+     * Add stock to watchlist
+     */
+    async add(dto) {
+        return this.client.post('/watchlists', dto);
+    }
+    /**
+     * Delete watchlist
+     */
+    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
+     */
+    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 JournalsEndpoints {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Extract journal from file
+     * Note: This method may need special handling depending on your environment
+     */
+    async extractFromFile(file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        // Note: When using FormData, don't set Content-Type header
+        // Browser/Node will set it automatically with boundary
+        const controller = new AbortController();
+        const url = `${this.client.baseURL}/journals/file`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.client.apiKey}`,
+            },
+            body: formData,
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const data = await response.json().catch(() => ({}));
+            throw new Error(data?.message || 'Failed to extract journal from file');
+        }
+        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
+     */
+    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 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 AiEndpoints {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * AI analysis of KSEI shareholder data
+     */
+    async analyzeShareholderKSEI(code) {
+        return this.client.get(`/ai/shareholder/ksei/${code}`);
+    }
+    /**
+     * AI analysis of inventory chart
+     */
+    async analyzeInventoryChart(code, params) {
+        return this.client.get(`/ai/inventory-chart/stock/${code}`, params);
+    }
+    /**
+     * AI analysis of stock news
+     */
+    async analyzeNews(code) {
+        return this.client.get(`/ai/news/${code}`);
+    }
+    /**
+     * AI analysis of broker summary
+     */
+    async analyzeBrokerSummary(code, params) {
+        return this.client.get(`/ai/summary/stock/${code}`, params);
+    }
+    /**
+     * AI analysis of insider trading
+     */
+    async analyzeInsider(params) {
+        return this.client.get('/ai/shareholder-insider', params);
+    }
+    /**
+     * AI analysis of shareholders above 5%
+     */
+    async analyzeShareholderAbove(params) {
+        return this.client.get('/ai/shareholder-above', params);
+    }
+    /**
+     * AI analysis of intraday inventory chart
+     */
+    async analyzeIntradayInventory(code, params) {
+        return this.client.get(`/ai/intraday-inventory-chart/${code}`, params);
+    }
+    /**
+     * AI analysis of sankey/crossing chart
+     */
+    async analyzeSankeyChart(code, params) {
+        return this.client.get(`/ai/sankey-chart/${code}`, params);
+    }
+    /**
+     * AI analysis of shareholder table
+     */
+    async analyzeShareholder(code) {
+        return this.client.get(`/ai/shareholder/${code}`);
+    }
+    /**
+     * AI analysis of financial statement
+     */
+    async analyzeFinancialStatement(code, params) {
+        return this.client.get(`/ai/financial-statement/${code}`, params);
+    }
+    /**
+     * AI analysis of key statistics
+     */
+    async analyzeKeyStat(code, params) {
+        return this.client.get(`/ai/keystat/${code}`, params);
+    }
+}
+
+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 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 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 scope
+     */
+    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 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 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 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);
+    }
+    /**
+     * Run screener
+     */
+    async screen(dto) {
+        return this.client.post('/screener/screen', dto);
+    }
+}
+
+class HealthEndpoints {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Check API status
+     */
+    async check() {
+        return this.client.get('/health');
+    }
+    /**
+     * Check database status
+     */
+    async checkDatabase() {
+        return this.client.get('/health/database');
+    }
+    /**
+     * Full health check (API and database)
+     */
+    async fullCheck() {
+        return this.client.get('/health/full');
+    }
+}
+
+class Invezgo {
+    constructor(config) {
+        this.client = new HttpClient(config);
+        // Initialize all endpoint modules
+        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.ai = new AiEndpoints(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.trades = new TradesEndpoints(this.client);
+        this.screener = new ScreenerEndpoints(this.client);
+        this.health = new HealthEndpoints(this.client);
+    }
+    /**
+     * Update API key
+     */
+    setApiKey(apiKey) {
+        this.client.apiKey = apiKey;
+    }
+    /**
+     * Get current API key (without exposing it)
+     */
+    hasApiKey() {
+        return !!this.client.apiKey;
+    }
+}
+
+/**
+ * Invezgo SDK for JavaScript and TypeScript
+ *
+ * Official SDK for accessing Invezgo API - Indonesia Stock Market Data
+ *
+ * @packageDocumentation
+ */
+
+export { Invezgo, InvezgoError, JournalsEndpoints, MembershipEndpoints, ScreenerEndpoints, TradesEndpoints, WatchlistsEndpoints, Invezgo as default };
+//# sourceMappingURL=index.js.map