@axionquant/sdk 1.0.3 → 1.1.3

package/dist/index.d.ts

@@ -1,68 +1,87 @@
 import { ApiResponse } from './models';
-export declare class Axion {
-    private client;
-    private apiKey?;
-    constructor(apiKey?: string);
-    private _request;
-    searchCredit(query: string): Promise<ApiResponse>;
-    getCreditRatings(entityId: string): Promise<ApiResponse>;
-    getEsgData(ticker: string): Promise<ApiResponse>;
-    getEtfFundData(ticker: string): Promise<ApiResponse>;
-    getEtfHoldings(ticker: string): Promise<ApiResponse>;
-    getEtfExposure(ticker: string): Promise<ApiResponse>;
-    getSupplyChainCustomers(ticker: string): Promise<ApiResponse>;
-    getSupplyChainPeers(ticker: string): Promise<ApiResponse>;
-    getSupplyChainSuppliers(ticker: string): Promise<ApiResponse>;
-    getStockTickers(params?: {
+declare class BaseAPI {
+    protected client: Axion;
+    constructor(client: Axion);
+    protected _request(method: string, path: string, params?: Record<string, any>, data?: Record<string, any>, authRequired?: boolean): Promise<ApiResponse>;
+}
+declare class CreditAPI extends BaseAPI {
+    search(query: string): Promise<ApiResponse>;
+    ratings(entityId: string): Promise<ApiResponse>;
+}
+declare class ESGAPI extends BaseAPI {
+    data(ticker: string): Promise<ApiResponse>;
+}
+declare class ETFAPI extends BaseAPI {
+    fund(ticker: string): Promise<ApiResponse>;
+    holdings(ticker: string): Promise<ApiResponse>;
+    exposure(ticker: string): Promise<ApiResponse>;
+}
+declare class SupplyChainAPI extends BaseAPI {
+    customers(ticker: string): Promise<ApiResponse>;
+    peers(ticker: string): Promise<ApiResponse>;
+    suppliers(ticker: string): Promise<ApiResponse>;
+}
+declare class StocksAPI extends BaseAPI {
+    tickers(params?: {
         country?: string;
         exchange?: string;
     }): Promise<ApiResponse>;
-    getStockTickerBySymbol(ticker: string): Promise<ApiResponse>;
-    getStockPrices(ticker: string, params?: {
+    ticker(ticker: string): Promise<ApiResponse>;
+    prices(ticker: string, params?: {
         from?: string;
         to?: string;
         frame?: string;
     }): Promise<ApiResponse>;
-    getCryptoTickers(params?: {
+}
+declare class CryptoAPI extends BaseAPI {
+    tickers(params?: {
         type?: string;
     }): Promise<ApiResponse>;
-    getCryptoTickerBySymbol(ticker: string): Promise<ApiResponse>;
-    getCryptoPrices(ticker: string, params?: {
+    ticker(ticker: string): Promise<ApiResponse>;
+    prices(ticker: string, params?: {
         from?: string;
         to?: string;
         frame?: string;
     }): Promise<ApiResponse>;
-    getForexTickers(params?: {
+}
+declare class ForexAPI extends BaseAPI {
+    tickers(params?: {
         country?: string;
         exchange?: string;
     }): Promise<ApiResponse>;
-    getForexTickerBySymbol(ticker: string): Promise<ApiResponse>;
-    getForexPrices(ticker: string, params?: {
+    ticker(ticker: string): Promise<ApiResponse>;
+    prices(ticker: string, params?: {
         from?: string;
         to?: string;
         frame?: string;
     }): Promise<ApiResponse>;
-    getFuturesTickers(params?: {
+}
+declare class FuturesAPI extends BaseAPI {
+    tickers(params?: {
         exchange?: string;
     }): Promise<ApiResponse>;
-    getFuturesTickerBySymbol(ticker: string): Promise<ApiResponse>;
-    getFuturesPrices(ticker: string, params?: {
+    ticker(ticker: string): Promise<ApiResponse>;
+    prices(ticker: string, params?: {
         from?: string;
         to?: string;
         frame?: string;
     }): Promise<ApiResponse>;
-    getIndexTickers(params?: {
+}
+declare class IndicesAPI extends BaseAPI {
+    tickers(params?: {
         exchange?: string;
     }): Promise<ApiResponse>;
-    getIndexTickerBySymbol(ticker: string): Promise<ApiResponse>;
-    getIndexPrices(ticker: string, params?: {
+    ticker(ticker: string): Promise<ApiResponse>;
+    prices(ticker: string, params?: {
         from?: string;
         to?: string;
         frame?: string;
     }): Promise<ApiResponse>;
-    searchEcon(query: string): Promise<ApiResponse>;
-    getEconDataset(seriesId: string): Promise<ApiResponse>;
-    getEconCalendar(params?: {
+}
+declare class EconAPI extends BaseAPI {
+    search(query: string): Promise<ApiResponse>;
+    dataset(seriesId: string): Promise<ApiResponse>;
+    calendar(params?: {
         from?: string;
         to?: string;
         country?: string;
@@ -70,92 +89,127 @@ export declare class Axion {
         currency?: string;
         category?: string;
     }): Promise<ApiResponse>;
-    /**
-     * Get asset profile information for a stock
-     */
-    getStockAsset(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get recommendation trend for a stock
-     */
-    getStockRecommendation(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get cash flow statement history for a stock
-     */
-    getStockCashflow(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get index trend estimates for a stock
-     */
-    getStockTrendIndex(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get key statistics for a stock
-     */
-    getStockStatistics(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get income statement history for a stock
-     */
-    getStockIncome(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get fund ownership data for a stock
-     */
-    getStockFund(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get summary detail for a stock
-     */
-    getStockSummary(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get insider holders for a stock
-     */
-    getStockInsiders(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get calendar events for a stock
-     */
-    getStockCalendar(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get balance sheet history for a stock
-     */
-    getStockBalancesheet(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get earnings trend estimates for a stock
-     */
-    getStockTrendEarnings(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get institution ownership for a stock
-     */
-    getStockInstitution(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get major holders breakdown for a stock
-     */
-    getStockOwnership(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get earnings history for a stock
-     */
-    getStockEarnings(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get summary profile information for a stock
-     */
-    getStockInfo(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get net share purchase activity for a stock
-     */
-    getStockActivity(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get insider transactions for a stock
-     */
-    getStockTransactions(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get financial data for a stock
-     */
-    getStockFinancials(ticker: string): Promise<ApiResponse>;
-    /**
-     * Get web traffic data for a company
-     */
-    getStockTraffic(ticker: string): Promise<ApiResponse>;
-    getNews(): Promise<ApiResponse>;
-    getCompanyNews(ticker: string): Promise<ApiResponse>;
-    getCountryNews(country: string): Promise<ApiResponse>;
-    getCategoryNews(category: string): Promise<ApiResponse>;
-    getSentimentAll(ticker: string): Promise<ApiResponse>;
-    getSentimentSocial(ticker: string): Promise<ApiResponse>;
-    getSentimentNews(ticker: string): Promise<ApiResponse>;
-    getSentimentAnalyst(ticker: string): Promise<ApiResponse>;
 }
+declare class NewsAPI extends BaseAPI {
+    general(): Promise<ApiResponse>;
+    company(ticker: string): Promise<ApiResponse>;
+    country(country: string): Promise<ApiResponse>;
+    category(category: string): Promise<ApiResponse>;
+}
+declare class SentimentAPI extends BaseAPI {
+    all(ticker: string): Promise<ApiResponse>;
+    social(ticker: string): Promise<ApiResponse>;
+    news(ticker: string): Promise<ApiResponse>;
+    analyst(ticker: string): Promise<ApiResponse>;
+}
+declare class ProfilesAPI extends BaseAPI {
+    profile(ticker: string): Promise<ApiResponse>;
+    recommendation(ticker: string): Promise<ApiResponse>;
+    statistics(ticker: string): Promise<ApiResponse>;
+    summary(ticker: string): Promise<ApiResponse>;
+    calendar(ticker: string): Promise<ApiResponse>;
+    info(ticker: string): Promise<ApiResponse>;
+}
+declare class EarningsAPI extends BaseAPI {
+    history(ticker: string): Promise<ApiResponse>;
+    trend(ticker: string): Promise<ApiResponse>;
+    index(ticker: string): Promise<ApiResponse>;
+    report(ticker: string, params: {
+        year: string;
+        quarter: string;
+    }): Promise<ApiResponse>;
+}
+declare class FilingsAPI extends BaseAPI {
+    filings(ticker: string, params?: {
+        limit?: number;
+        form?: string;
+    }): Promise<ApiResponse>;
+    forms(ticker: string, formType: string, params?: {
+        year?: string;
+        quarter?: string;
+        limit?: number;
+    }): Promise<ApiResponse>;
+    descForms(): Promise<ApiResponse>;
+    search(params: {
+        year: string;
+        quarter: string;
+        form?: string;
+        ticker?: string;
+    }): Promise<ApiResponse>;
+}
+declare class FinancialsAPI extends BaseAPI {
+    revenue(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    netIncome(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    totalAssets(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    totalLiabilities(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    stockholdersEquity(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    currentAssets(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    currentLiabilities(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    operatingCashFlow(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    capitalExpenditures(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    freeCashFlow(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    sharesOutstandingBasic(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    sharesOutstandingDiluted(ticker: string, params?: {
+        periods?: number;
+    }): Promise<ApiResponse>;
+    metrics(ticker: string): Promise<ApiResponse>;
+    snapshot(ticker: string): Promise<ApiResponse>;
+}
+declare class InsidersAPI extends BaseAPI {
+    funds(ticker: string): Promise<ApiResponse>;
+    individuals(ticker: string): Promise<ApiResponse>;
+    institutions(ticker: string): Promise<ApiResponse>;
+    ownership(ticker: string): Promise<ApiResponse>;
+    activity(ticker: string): Promise<ApiResponse>;
+    transactions(ticker: string): Promise<ApiResponse>;
+}
+declare class WebTrafficAPI extends BaseAPI {
+    traffic(ticker: string): Promise<ApiResponse>;
+}
+export declare class Axion {
+    private client;
+    private apiKey?;
+    credit: CreditAPI;
+    esg: ESGAPI;
+    etfs: ETFAPI;
+    supplyChain: SupplyChainAPI;
+    stocks: StocksAPI;
+    crypto: CryptoAPI;
+    forex: ForexAPI;
+    futures: FuturesAPI;
+    indices: IndicesAPI;
+    econ: EconAPI;
+    news: NewsAPI;
+    sentiment: SentimentAPI;
+    profiles: ProfilesAPI;
+    earnings: EarningsAPI;
+    filings: FilingsAPI;
+    financials: FinancialsAPI;
+    insiders: InsidersAPI;
+    webTraffic: WebTrafficAPI;
+    constructor(apiKey?: string);
+    _request(method: string, path: string, params?: Record<string, any>, data?: Record<string, any>, authRequired?: boolean): Promise<ApiResponse>;
+}
+export {};

package/dist/index.js

@@ -5,292 +5,358 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Axion = void 0;
 const axios_1 = __importDefault(require("axios"));
-const BASE_URL = "http://localhost:3001";
-class Axion {
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-        this.client = axios_1.default.create({
-            baseURL: BASE_URL,
-            headers: {
-                "Content-Type": "application/json",
-            }
-        });
-        if (apiKey) {
-            this.client.defaults.headers.common["Authorization"] = `Bearer ${this.apiKey}`;
-        }
+const BASE_URL = "https://api.axionquant.com";
+class BaseAPI {
+    constructor(client) {
+        this.client = client;
     }
     async _request(method, path, params = {}, data = {}, authRequired = true) {
-        const config = {
-            method,
-            url: path,
-            params,
-            data,
-            headers: { ...this.client.defaults.headers.common }
-        };
-        if (!authRequired) {
-            delete config.headers["Authorization"];
-        }
-        else if (authRequired && !this.apiKey) {
-            throw new Error("Authentication required but no API key provided to client.");
-        }
-        try {
-            const response = await this.client.request(config);
-            // The python version has a normalize function, which seems to coerce strings to numbers/booleans.
-            // This is generally not needed in JS/TS as JSON parsing handles types correctly.
-            // If the API returns numbers as strings, a normalization step would be needed here.
-            return response.data;
-        }
-        catch (error) {
-            const axiosError = error;
-            if (axiosError.response) {
-                const errorData = axiosError.response.data;
-                throw new Error(`HTTP Error ${axiosError.response.status}: ${errorData?.message || 'Unknown HTTP error'}`);
-            }
-            else if (axiosError.request) {
-                throw new Error(`Connection Error: Could not connect to ${BASE_URL}`);
-            }
-            else {
-                throw new Error(`Request Error: ${axiosError.message}`);
-            }
-        }
+        return this.client._request(method, path, params, data, authRequired);
     }
-    // --- Credit API ---
-    searchCredit(query) {
+}
+class CreditAPI extends BaseAPI {
+    search(query) {
         return this._request("GET", "credit/search", { query });
     }
-    getCreditRatings(entityId) {
+    ratings(entityId) {
         return this._request("GET", `credit/ratings/${entityId}`);
     }
-    // --- ESG API ---
-    getEsgData(ticker) {
+}
+class ESGAPI extends BaseAPI {
+    data(ticker) {
         return this._request("GET", `esg/${ticker}`);
     }
-    // --- ETF API ---
-    getEtfFundData(ticker) {
+}
+class ETFAPI extends BaseAPI {
+    fund(ticker) {
         return this._request("GET", `etfs/${ticker}/fund`);
     }
-    getEtfHoldings(ticker) {
+    holdings(ticker) {
         return this._request("GET", `etfs/${ticker}/holdings`);
     }
-    getEtfExposure(ticker) {
+    exposure(ticker) {
         return this._request("GET", `etfs/${ticker}/exposure`);
     }
-    // --- Supply Chain API ---
-    getSupplyChainCustomers(ticker) {
+}
+class SupplyChainAPI extends BaseAPI {
+    customers(ticker) {
         return this._request("GET", `supply-chain/${ticker}/customers`);
     }
-    getSupplyChainPeers(ticker) {
+    peers(ticker) {
         return this._request("GET", `supply-chain/${ticker}/peers`);
     }
-    getSupplyChainSuppliers(ticker) {
+    suppliers(ticker) {
         return this._request("GET", `supply-chain/${ticker}/suppliers`);
     }
-    // --- Stocks API ---
-    getStockTickers(params = {}) {
+}
+class StocksAPI extends BaseAPI {
+    tickers(params = {}) {
         return this._request("GET", "stocks/tickers", params);
     }
-    getStockTickerBySymbol(ticker) {
+    ticker(ticker) {
         return this._request("GET", `stocks/${ticker}`);
     }
-    getStockPrices(ticker, params = {}) {
+    prices(ticker, params = {}) {
         return this._request("GET", `stocks/${ticker}/prices`, params);
     }
-    // --- Crypto API ---
-    getCryptoTickers(params = {}) {
+}
+class CryptoAPI extends BaseAPI {
+    tickers(params = {}) {
         return this._request("GET", "crypto/tickers", params);
     }
-    getCryptoTickerBySymbol(ticker) {
+    ticker(ticker) {
         return this._request("GET", `crypto/${ticker}`);
     }
-    getCryptoPrices(ticker, params = {}) {
+    prices(ticker, params = {}) {
         return this._request("GET", `crypto/${ticker}/prices`, params);
     }
-    // --- Forex API ---
-    getForexTickers(params = {}) {
+}
+class ForexAPI extends BaseAPI {
+    tickers(params = {}) {
         return this._request("GET", "forex/tickers", params);
     }
-    getForexTickerBySymbol(ticker) {
+    ticker(ticker) {
         return this._request("GET", `forex/${ticker}`);
     }
-    getForexPrices(ticker, params = {}) {
+    prices(ticker, params = {}) {
         return this._request("GET", `forex/${ticker}/prices`, params);
     }
-    // --- Futures API ---
-    getFuturesTickers(params = {}) {
+}
+class FuturesAPI extends BaseAPI {
+    tickers(params = {}) {
         return this._request("GET", "futures/tickers", params);
     }
-    getFuturesTickerBySymbol(ticker) {
+    ticker(ticker) {
         return this._request("GET", `futures/${ticker}`);
     }
-    getFuturesPrices(ticker, params = {}) {
+    prices(ticker, params = {}) {
         return this._request("GET", `futures/${ticker}/prices`, params);
     }
-    // --- Indices API ---
-    getIndexTickers(params = {}) {
+}
+class IndicesAPI extends BaseAPI {
+    tickers(params = {}) {
         return this._request("GET", "indices/tickers", params);
     }
-    getIndexTickerBySymbol(ticker) {
+    ticker(ticker) {
         return this._request("GET", `indices/${ticker}`);
     }
-    getIndexPrices(ticker, params = {}) {
+    prices(ticker, params = {}) {
         return this._request("GET", `indices/${ticker}/prices`, params);
     }
-    // --- Economic API ---
-    searchEcon(query) {
+}
+class EconAPI extends BaseAPI {
+    search(query) {
         return this._request("GET", "econ/search", { query });
     }
-    getEconDataset(seriesId) {
+    dataset(seriesId) {
         return this._request("GET", `econ/dataset/${seriesId}`);
     }
-    getEconCalendar(params = {}) {
+    calendar(params = {}) {
         return this._request("GET", "econ/calendar", params);
     }
-    // --- Profiles API ---
-    /**
-     * Get asset profile information for a stock
-     */
-    getStockAsset(ticker) {
-        return this._request("GET", `profiles/${ticker}/asset`);
-    }
-    /**
-     * Get recommendation trend for a stock
-     */
-    getStockRecommendation(ticker) {
+}
+class NewsAPI extends BaseAPI {
+    general() {
+        return this._request("GET", "news");
+    }
+    company(ticker) {
+        return this._request("GET", `news/${ticker}`);
+    }
+    country(country) {
+        return this._request("GET", `news/country/${country}`);
+    }
+    category(category) {
+        return this._request("GET", `news/category/${category}`);
+    }
+}
+class SentimentAPI extends BaseAPI {
+    all(ticker) {
+        return this._request("GET", `sentiment/${ticker}/all`);
+    }
+    social(ticker) {
+        return this._request("GET", `sentiment/${ticker}/social`);
+    }
+    news(ticker) {
+        return this._request("GET", `sentiment/${ticker}/news`);
+    }
+    analyst(ticker) {
+        return this._request("GET", `sentiment/${ticker}/analyst`);
+    }
+}
+class ProfilesAPI extends BaseAPI {
+    // GET /:ticker - Returns asset profile
+    profile(ticker) {
+        return this._request("GET", `profiles/${ticker}`);
+    }
+    // GET /:ticker/recommendation - Returns recommendation trend
+    recommendation(ticker) {
         return this._request("GET", `profiles/${ticker}/recommendation`);
     }
-    /**
-     * Get cash flow statement history for a stock
-     */
-    getStockCashflow(ticker) {
-        return this._request("GET", `profiles/${ticker}/cashflow`);
-    }
-    /**
-     * Get index trend estimates for a stock
-     */
-    getStockTrendIndex(ticker) {
-        return this._request("GET", `profiles/${ticker}/trend/index`);
-    }
-    /**
-     * Get key statistics for a stock
-     */
-    getStockStatistics(ticker) {
+    // GET /:ticker/statistics - Returns key statistics
+    statistics(ticker) {
         return this._request("GET", `profiles/${ticker}/statistics`);
     }
-    /**
-     * Get income statement history for a stock
-     */
-    getStockIncome(ticker) {
-        return this._request("GET", `profiles/${ticker}/income`);
-    }
-    /**
-     * Get fund ownership data for a stock
-     */
-    getStockFund(ticker) {
-        return this._request("GET", `profiles/${ticker}/fund`);
-    }
-    /**
-     * Get summary detail for a stock
-     */
-    getStockSummary(ticker) {
+    // GET /:ticker/summary - Returns summary detail
+    summary(ticker) {
         return this._request("GET", `profiles/${ticker}/summary`);
     }
-    /**
-     * Get insider holders for a stock
-     */
-    getStockInsiders(ticker) {
-        return this._request("GET", `profiles/${ticker}/insiders`);
-    }
-    /**
-     * Get calendar events for a stock
-     */
-    getStockCalendar(ticker) {
+    // GET /:ticker/calendar - Returns calendar events (earnings, dividends)
+    calendar(ticker) {
         return this._request("GET", `profiles/${ticker}/calendar`);
     }
-    /**
-     * Get balance sheet history for a stock
-     */
-    getStockBalancesheet(ticker) {
-        return this._request("GET", `profiles/${ticker}/balancesheet`);
-    }
-    /**
-     * Get earnings trend estimates for a stock
-     */
-    getStockTrendEarnings(ticker) {
-        return this._request("GET", `profiles/${ticker}/trend/earnings`);
-    }
-    /**
-     * Get institution ownership for a stock
-     */
-    getStockInstitution(ticker) {
-        return this._request("GET", `profiles/${ticker}/institution`);
-    }
-    /**
-     * Get major holders breakdown for a stock
-     */
-    getStockOwnership(ticker) {
-        return this._request("GET", `profiles/${ticker}/ownership`);
-    }
-    /**
-     * Get earnings history for a stock
-     */
-    getStockEarnings(ticker) {
-        return this._request("GET", `profiles/${ticker}/earnings`);
-    }
-    /**
-     * Get summary profile information for a stock
-     */
-    getStockInfo(ticker) {
+    // GET /:ticker/info - Returns company info (summary profile)
+    info(ticker) {
         return this._request("GET", `profiles/${ticker}/info`);
     }
-    /**
-     * Get net share purchase activity for a stock
-     */
-    getStockActivity(ticker) {
-        return this._request("GET", `profiles/${ticker}/activity`);
-    }
-    /**
-     * Get insider transactions for a stock
-     */
-    getStockTransactions(ticker) {
-        return this._request("GET", `profiles/${ticker}/transactions`);
-    }
-    /**
-     * Get financial data for a stock
-     */
-    getStockFinancials(ticker) {
-        return this._request("GET", `profiles/${ticker}/financials`);
-    }
-    /**
-     * Get web traffic data for a company
-     */
-    getStockTraffic(ticker) {
-        return this._request("GET", `profiles/${ticker}/traffic`);
-    }
-    // --- News API ---
-    getNews() {
-        return this._request("GET", "news");
+}
+class EarningsAPI extends BaseAPI {
+    // GET /:ticker/history - Returns earnings history
+    history(ticker) {
+        return this._request("GET", `earnings/${ticker}/history`);
     }
-    getCompanyNews(ticker) {
-        return this._request("GET", `news/${ticker}`);
+    // GET /:ticker/trend - Returns earnings trend
+    trend(ticker) {
+        return this._request("GET", `earnings/${ticker}/trend`);
     }
-    getCountryNews(country) {
-        return this._request("GET", `news/country/${country}`);
+    // GET /:ticker/index - Returns index trend
+    index(ticker) {
+        return this._request("GET", `earnings/${ticker}/index`);
     }
-    getCategoryNews(category) {
-        return this._request("GET", `news/category/${category}`);
+    // GET /:ticker/report - Returns earnings report (requires year and quarter query params)
+    report(ticker, params) {
+        return this._request("GET", `earnings/${ticker}/report`, params);
     }
-    // --- Sentiment API ---
-    getSentimentAll(ticker) {
-        return this._request("GET", `sentiment/${ticker}/all`);
+}
+class FilingsAPI extends BaseAPI {
+    // GET /:ticker - Get recent filings for a company
+    filings(ticker, params = {}) {
+        return this._request("GET", `filings/${ticker}`, params);
     }
-    getSentimentSocial(ticker) {
-        return this._request("GET", `sentiment/${ticker}/social`);
+    // GET /:ticker/forms/:formType - Get specific form type filings
+    forms(ticker, formType, params = {}) {
+        return this._request("GET", `filings/${ticker}/forms/${formType}`, params);
     }
-    getSentimentNews(ticker) {
-        return this._request("GET", `sentiment/${ticker}/news`);
+    // GET /desc/forms - List available form types and their descriptions
+    descForms() {
+        return this._request("GET", "filings/desc/forms");
     }
-    getSentimentAnalyst(ticker) {
-        return this._request("GET", `sentiment/${ticker}/analyst`);
+    // GET /search - Search filings by year/quarter
+    search(params) {
+        return this._request("GET", "filings/search", params);
+    }
+}
+class FinancialsAPI extends BaseAPI {
+    // GET /:ticker/revenue - Get revenue data
+    revenue(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/revenue`, params);
+    }
+    // GET /:ticker/netincome - Get net income data
+    netIncome(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/netincome`, params);
+    }
+    // GET /:ticker/total/assets - Get total assets data
+    totalAssets(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/total/assets`, params);
+    }
+    // GET /:ticker/total/liabilities - Get total liabilities data
+    totalLiabilities(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/total/liabilities`, params);
+    }
+    // GET /:ticker/stockholdersequity - Get stockholders equity data
+    stockholdersEquity(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/stockholdersequity`, params);
+    }
+    // GET /:ticker/current/assets - Get current assets data
+    currentAssets(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/current/assets`, params);
+    }
+    // GET /:ticker/current/liabilities - Get current liabilities data
+    currentLiabilities(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/current/liabilities`, params);
+    }
+    // GET /:ticker/cashflow/operating - Get operating cash flow data
+    operatingCashFlow(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/cashflow/operating`, params);
+    }
+    // GET /:ticker/capitalexpenditures - Get capital expenditures data
+    capitalExpenditures(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/capitalexpenditures`, params);
+    }
+    // GET /:ticker/cashflow/free - Get free cash flow data
+    freeCashFlow(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/cashflow/free`, params);
+    }
+    // GET /:ticker/sharesoutstanding/basic - Get basic shares outstanding data
+    sharesOutstandingBasic(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/sharesoutstanding/basic`, params);
+    }
+    // GET /:ticker/sharesoutstanding/diluted - Get diluted shares outstanding data
+    sharesOutstandingDiluted(ticker, params = {}) {
+        return this._request("GET", `financials/${ticker}/sharesoutstanding/diluted`, params);
+    }
+    // GET /:ticker/metrics - Get calculated financial metrics
+    metrics(ticker) {
+        return this._request("GET", `financials/${ticker}/metrics`);
+    }
+    // GET /:ticker/snapshot - Get financial data snapshot
+    snapshot(ticker) {
+        return this._request("GET", `financials/${ticker}/snapshot`);
+    }
+}
+class InsidersAPI extends BaseAPI {
+    // GET /:ticker/funds - Get fund ownership data
+    funds(ticker) {
+        return this._request("GET", `insiders/${ticker}/funds`);
+    }
+    // GET /:ticker/individuals - Get insider holders (individuals)
+    individuals(ticker) {
+        return this._request("GET", `insiders/${ticker}/individuals`);
+    }
+    // GET /:ticker/institutions - Get institutional ownership data
+    institutions(ticker) {
+        return this._request("GET", `insiders/${ticker}/institutions`);
+    }
+    // GET /:ticker/ownership - Get major holders breakdown
+    ownership(ticker) {
+        return this._request("GET", `insiders/${ticker}/ownership`);
+    }
+    // GET /:ticker/activity - Get net share purchase activity
+    activity(ticker) {
+        return this._request("GET", `insiders/${ticker}/activity`);
+    }
+    // GET /:ticker/transactions - Get insider transactions
+    transactions(ticker) {
+        return this._request("GET", `insiders/${ticker}/transactions`);
+    }
+}
+class WebTrafficAPI extends BaseAPI {
+    // GET /:ticker/traffic - Get web traffic data for a company's website
+    traffic(ticker) {
+        return this._request("GET", `webtraffic/${ticker}/traffic`);
+    }
+}
+class Axion {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        this.client = axios_1.default.create({
+            baseURL: BASE_URL,
+            headers: {
+                "Content-Type": "application/json",
+            }
+        });
+        if (apiKey) {
+            this.client.defaults.headers.common["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        this.credit = new CreditAPI(this);
+        this.esg = new ESGAPI(this);
+        this.etfs = new ETFAPI(this);
+        this.supplyChain = new SupplyChainAPI(this);
+        this.stocks = new StocksAPI(this);
+        this.crypto = new CryptoAPI(this);
+        this.forex = new ForexAPI(this);
+        this.futures = new FuturesAPI(this);
+        this.indices = new IndicesAPI(this);
+        this.econ = new EconAPI(this);
+        this.news = new NewsAPI(this);
+        this.sentiment = new SentimentAPI(this);
+        this.profiles = new ProfilesAPI(this);
+        this.earnings = new EarningsAPI(this);
+        this.filings = new FilingsAPI(this);
+        this.financials = new FinancialsAPI(this);
+        this.insiders = new InsidersAPI(this);
+        this.webTraffic = new WebTrafficAPI(this);
+    }
+    async _request(method, path, params = {}, data = {}, authRequired = true) {
+        const config = {
+            method,
+            url: path,
+            params,
+            data,
+            headers: { ...this.client.defaults.headers.common }
+        };
+        if (!authRequired) {
+            delete config.headers["Authorization"];
+        }
+        else if (authRequired && !this.apiKey) {
+            throw new Error("Authentication required but no API key provided to client.");
+        }
+        try {
+            const response = await this.client.request(config);
+            return response.data;
+        }
+        catch (error) {
+            const axiosError = error;
+            if (axiosError.response) {
+                const errorData = axiosError.response.data;
+                throw new Error(`HTTP Error ${axiosError.response.status}: ${errorData?.message || 'Unknown HTTP error'}`);
+            }
+            else if (axiosError.request) {
+                throw new Error(`Connection Error: Could not connect to ${BASE_URL}`);
+            }
+            else {
+                throw new Error(`Request Error: ${axiosError.message}`);
+            }
+        }
     }
 }
 exports.Axion = Axion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axionquant/sdk",
-  "version": "1.0.3",
+  "version": "1.1.3",
   "description": "Axion SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/readme.md

@@ -1,6 +1,6 @@
 # Axion SDK
 
-A TypeScript/JavaScript SDK for the Axion financial data API.
+A TypeScript/JavaScript SDK for the [Axion](https://axionquant.com) financial data API.
 
 ## Installation
 
@@ -10,167 +10,170 @@ npm install @axionquant/sdk
 
 ## Quick Start
 
-```typescript
-import { Axion } from '@axionquant/sdk';
+[Get your free API key](https://axionquant.com/dashboard/api-keys)
+
+```js
+const { Axion } = require('@axionquant/sdk');
 
-// Initialize with API key
 const client = new Axion('your-api-key');
 
-// Get stock price data
+// Get stock tickers
+const tickers = await client.stocks.tickers({ country: 'US', exchange: 'NASDAQ' });
+
+// Get historical prices
 const prices = await client.stocks.prices('AAPL', {
   from: '2024-01-01',
-  to: '2024-12-31'
+  to: '2024-12-31',
+  frame: '1d'
 });
 ```
 
 ## Authentication
 
-Some endpoints require authentication. Provide your API key when initializing the client:
+Most endpoints require an API key. Pass it when initializing the client:
 
-```typescript
+```js
 const client = new Axion('your-api-key');
 ```
 
-For endpoints that don't require authentication, you can initialize without an API key:
-
-```typescript
-const client = new Axion();
-```
-
 ## API Reference
 
-### Credit
-
-```typescript
-// Search for credit entities
-await client.credit.search('Apple Inc');
+### Stocks
 
-// Get credit ratings for an entity
-await client.credit.ratings('entity-id');
-```
+```js
+// Get all stock tickers
+await client.stocks.tickers({ country: 'US', exchange: 'NASDAQ' });
 
-### ESG
+// Get ticker info
+await client.stocks.ticker('AAPL');
 
-```typescript
-// Get ESG data for a stock
-await client.esg.data('AAPL');
+// Get historical prices
+await client.stocks.prices('AAPL', { from: '2024-01-01', to: '2024-12-31', frame: '1d' });
 ```
 
-### ETFs
-
-```typescript
-// Get ETF fund data
-await client.etfs.fund('SPY');
-
-// Get ETF holdings
-await client.etfs.holdings('SPY');
+### Crypto
 
-// Get ETF exposure data
-await client.etfs.exposure('SPY');
+```js
+await client.crypto.tickers({ type: 'coin' });
+await client.crypto.ticker('BTC');
+await client.crypto.prices('BTC', { from: '2024-01-01', to: '2024-12-31', frame: '1h' });
 ```
 
-### Supply Chain
-
-```typescript
-// Get company customers
-await client.supplyChain.customers('AAPL');
-
-// Get company peers
-await client.supplyChain.peers('AAPL');
+### Forex
 
-// Get company suppliers
-await client.supplyChain.suppliers('AAPL');
+```js
+await client.forex.tickers({ country: 'US' });
+await client.forex.ticker('EURUSD');
+await client.forex.prices('EURUSD', { from: '2024-01-01', to: '2024-12-31' });
 ```
 
-### Stocks
+### Futures
 
-```typescript
-// Get all stock tickers
-await client.stocks.tickers({ country: 'US', exchange: 'NASDAQ' });
+```js
+await client.futures.tickers({ exchange: 'CME' });
+await client.futures.ticker('ES');
+await client.futures.prices('ES', { from: '2024-01-01', to: '2024-12-31' });
+```
 
-// Get ticker information
-await client.stocks.ticker('AAPL');
+### Indices
 
-// Get historical prices
-await client.stocks.prices('AAPL', {
-  from: '2024-01-01',
-  to: '2024-12-31',
-  frame: '1d' // daily
-});
+```js
+await client.indices.tickers({ exchange: 'NYSE' });
+await client.indices.ticker('SPX');
+await client.indices.prices('SPX', { from: '2024-01-01', to: '2024-12-31' });
 ```
 
-### Crypto
+### Financials
 
-```typescript
-// Get all crypto tickers
-await client.crypto.tickers({ type: 'coin' });
+```js
+await client.financials.revenue('AAPL', { periods: 8 });
+await client.financials.netIncome('AAPL');
+await client.financials.totalAssets('AAPL');
+await client.financials.totalLiabilities('AAPL');
+await client.financials.stockholdersEquity('AAPL');
+await client.financials.currentAssets('AAPL');
+await client.financials.currentLiabilities('AAPL');
+await client.financials.operatingCashFlow('AAPL');
+await client.financials.capitalExpenditures('AAPL');
+await client.financials.freeCashFlow('AAPL');
+await client.financials.sharesOutstandingBasic('AAPL');
+await client.financials.sharesOutstandingDiluted('AAPL');
+await client.financials.metrics('AAPL');
+await client.financials.snapshot('AAPL');
+```
 
-// Get crypto ticker information
-await client.crypto.ticker('BTC');
+### Earnings
 
-// Get crypto prices
-await client.crypto.prices('BTC', {
-  from: '2024-01-01',
-  to: '2024-12-31',
-  frame: '1h'
-});
+```js
+await client.earnings.history('AAPL');
+await client.earnings.trend('AAPL');
+await client.earnings.index('AAPL');
+await client.earnings.report('AAPL', { year: '2024', quarter: 'Q1' });
 ```
 
-### Forex
+### Filings
 
-```typescript
-// Get forex tickers
-await client.forex.tickers({ country: 'US' });
+```js
+// Get recent filings
+await client.filings.filings('AAPL', { limit: 10, form: '10-K' });
 
-// Get forex ticker information
-await client.forex.ticker('EURUSD');
+// Get specific form type
+await client.filings.forms('AAPL', '10-K', { year: '2024', quarter: 'Q1' });
 
-// Get forex prices
-await client.forex.prices('EURUSD', {
-  from: '2024-01-01',
-  to: '2024-12-31'
-});
+// List available form types
+await client.filings.descForms();
+
+// Search filings by year/quarter
+await client.filings.search({ year: '2024', quarter: 'Q1', form: '10-Q', ticker: 'AAPL' });
 ```
 
-### Futures
+### Insiders
 
-```typescript
-// Get futures tickers
-await client.futures.tickers({ exchange: 'CME' });
+```js
+await client.insiders.funds('AAPL');
+await client.insiders.individuals('AAPL');
+await client.insiders.institutions('AAPL');
+await client.insiders.ownership('AAPL');
+await client.insiders.activity('AAPL');
+await client.insiders.transactions('AAPL');
+```
 
-// Get futures ticker information
-await client.futures.ticker('ES');
+### Company Profiles
 
-// Get futures prices
-await client.futures.prices('ES', {
-  from: '2024-01-01',
-  to: '2024-12-31'
-});
+```js
+await client.profiles.profile('AAPL');
+await client.profiles.recommendation('AAPL');
+await client.profiles.statistics('AAPL');
+await client.profiles.summary('AAPL');
+await client.profiles.info('AAPL');
+await client.profiles.calendar('AAPL');
 ```
 
-### Indices
+### Sentiment
 
-```typescript
-// Get index tickers
-await client.indices.tickers({ exchange: 'NYSE' });
+```js
+await client.sentiment.all('AAPL');
+await client.sentiment.social('AAPL');
+await client.sentiment.news('AAPL');
+await client.sentiment.analyst('AAPL');
+```
 
-// Get index ticker information
-await client.indices.ticker('SPX');
+### News
 
-// Get index prices
-await client.indices.prices('SPX', {
-  from: '2024-01-01',
-  to: '2024-12-31'
-});
+```js
+await client.news.general();
+await client.news.company('AAPL');
+await client.news.country('US');
+await client.news.category('technology');
 ```
 
 ### Economic Data
 
-```typescript
-// Search for economic datasets
+```js
+// Search datasets
 await client.econ.search('unemployment rate');
 
-// Get economic dataset
+// Get a dataset
 await client.econ.dataset('UNRATE');
 
 // Get economic calendar
@@ -184,101 +187,56 @@ await client.econ.calendar({
 });
 ```
 
-### News
-
-```typescript
-// Get latest general news
-await client.news.general();
-
-// Get company-specific news
-await client.news.company('AAPL');
-
-// Get country news
-await client.news.country('US');
+### Credit
 
-// Get category news
-await client.news.category('technology');
+```js
+await client.credit.search('Apple Inc');
+await client.credit.ratings('entity-id');
 ```
 
-### Sentiment
-
-```typescript
-// Get all sentiment data
-await client.sentiment.all('AAPL');
-
-// Get social media sentiment
-await client.sentiment.social('AAPL');
-
-// Get news sentiment
-await client.sentiment.news('AAPL');
+### ESG
 
-// Get analyst sentiment
-await client.sentiment.analyst('AAPL');
+```js
+await client.esg.data('AAPL');
 ```
 
-### Company Profiles
-
-```typescript
-// Asset profile
-await client.profiles.asset('AAPL');
-
-// Recommendations
-await client.profiles.recommendation('AAPL');
-
-// Financial statements
-await client.profiles.cashflow('AAPL');
-await client.profiles.income('AAPL');
-await client.profiles.balancesheet('AAPL');
-await client.profiles.financials('AAPL');
-
-// Company statistics
-await client.profiles.statistics('AAPL');
-await client.profiles.summary('AAPL');
-await client.profiles.info('AAPL');
+### ETFs
 
-// Ownership and holders
-await client.profiles.fund('AAPL');
-await client.profiles.insiders('AAPL');
-await client.profiles.institutionOwnership('AAPL');
-await client.profiles.ownership('AAPL');
+```js
+await client.etfs.fund('SPY');
+await client.etfs.holdings('SPY');
+await client.etfs.exposure('SPY');
+```
 
-// Earnings and trends
-await client.profiles.earnings('AAPL');
-await client.profiles.earningsTrend('AAPL');
-await client.profiles.indexTrend('AAPL');
+### Supply Chain
 
-// Insider activity
-await client.profiles.activity('AAPL');
-await client.profiles.transactions('AAPL');
+```js
+await client.supplyChain.customers('AAPL');
+await client.supplyChain.peers('AAPL');
+await client.supplyChain.suppliers('AAPL');
+```
 
-// Calendar events
-await client.profiles.calendar('AAPL');
+### Web Traffic
 
-// Web traffic
-await client.profiles.traffic('AAPL');
+```js
+await client.webTraffic.traffic('AAPL');
 ```
 
 ## Error Handling
 
-The SDK throws errors for failed requests. Use try-catch blocks to handle them:
-
-```typescript
+```js
 try {
   const data = await client.stocks.prices('AAPL');
   console.log(data);
 } catch (error) {
-  console.error('Error fetching data:', error.message);
+  console.error('Error:', error.message);
 }
 ```
 
-## TypeScript Support
+## Get Started
 
-This SDK is written in TypeScript and includes type definitions. Import types as needed:
-
-```typescript
-import { Axion, ApiResponse } from '@axionquant/sdk';
-```
+For detailed API documentation, support, or to obtain an API key, visit the [Axion](https://axionquant.com) website.
 
-## Base URL
+## License
 
-By default, the SDK connects to `https://api.axionquant.com`. To use a different base URL, modify the `BASE_URL` constant in the source code.
+MIT