@veroq/sdk 1.0.0

package/dist/cjs/client.js

@@ -0,0 +1,800 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolarisClient = exports.VeroqClient = void 0;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const errors_js_1 = require("./errors.js");
+function readCredentials() {
+    // Check VEROQ_API_KEY first, then fall back to POLARIS_API_KEY
+    const envKey = process.env.VEROQ_API_KEY || process.env.POLARIS_API_KEY;
+    if (envKey)
+        return envKey;
+    // Check ~/.veroq/credentials first, then fall back to ~/.polaris/credentials
+    try {
+        const key = (0, fs_1.readFileSync)((0, path_1.join)((0, os_1.homedir)(), ".veroq", "credentials"), "utf-8").trim();
+        if (key)
+            return key;
+    }
+    catch { /* ignore */ }
+    try {
+        const key = (0, fs_1.readFileSync)((0, path_1.join)((0, os_1.homedir)(), ".polaris", "credentials"), "utf-8").trim();
+        return key || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const DEFAULT_BASE_URL = "https://api.thepolarisreport.com";
+function toSnakeCase(str) {
+    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function toSnakeParams(params) {
+    const result = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null) {
+            result[toSnakeCase(key)] = String(value);
+        }
+    }
+    return result;
+}
+/* -- Parsers: snake_case API -> camelCase SDK -- */
+function parseSource(raw) {
+    return {
+        name: (raw.name || ""),
+        url: (raw.url || ""),
+        trustLevel: raw.trust_level,
+        verified: raw.verified,
+    };
+}
+function parseEntity(raw) {
+    return {
+        name: (raw.name || ""),
+        type: raw.type,
+        sentiment: raw.sentiment,
+        mentionCount: (raw.mention_count ?? raw.mentions_24h),
+        ticker: raw.ticker,
+        role: raw.role,
+    };
+}
+function parseProvenance(raw) {
+    return {
+        reviewStatus: raw.review_status,
+        aiContributionPct: raw.ai_contribution_pct,
+        humanContributionPct: raw.human_contribution_pct,
+        confidenceScore: raw.confidence_score,
+        biasScore: raw.bias_score,
+        agentsInvolved: raw.agents_involved,
+    };
+}
+function parseBrief(raw) {
+    const prov = raw.provenance
+        ? parseProvenance(raw.provenance)
+        : undefined;
+    return {
+        id: raw.id,
+        headline: (raw.headline || ""),
+        summary: raw.summary,
+        body: raw.body,
+        confidence: raw.confidence ?? prov?.confidenceScore,
+        biasScore: raw.bias_score ?? prov?.biasScore,
+        sentiment: raw.sentiment,
+        counterArgument: raw.counter_argument,
+        category: raw.category,
+        tags: raw.tags,
+        sources: raw.sources
+            ? raw.sources.map(parseSource)
+            : undefined,
+        entitiesEnriched: raw.entities_enriched
+            ? raw.entities_enriched.map(parseEntity)
+            : undefined,
+        structuredData: raw.structured_data,
+        publishedAt: raw.published_at,
+        reviewStatus: raw.review_status,
+        provenance: prov,
+        briefType: raw.brief_type,
+        trending: raw.trending,
+        topics: raw.topics,
+        entities: raw.entities,
+        impactScore: raw.impact_score,
+        readTimeSeconds: raw.read_time_seconds,
+        sourceCount: raw.source_count,
+        correctionsCount: raw.corrections_count,
+        biasAnalysis: raw.bias_analysis,
+        fullSources: raw.full_sources,
+    };
+}
+function parseSourceAnalysis(raw) {
+    return {
+        outlet: raw.outlet,
+        headline: raw.headline,
+        framing: raw.framing,
+        politicalLean: raw.political_lean,
+        loadedLanguage: raw.loaded_language,
+        emphasis: raw.emphasis,
+        omissions: raw.omissions,
+        sentiment: raw.sentiment,
+        rawExcerpt: raw.raw_excerpt,
+    };
+}
+class VeroqClient {
+    constructor(options = {}) {
+        this.apiKey = options.apiKey ?? readCredentials();
+        this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    }
+    async request(method, path, params, body) {
+        let url = `${this.baseUrl}${path}`;
+        if (params) {
+            const snaked = toSnakeParams(params);
+            const qs = new URLSearchParams(snaked).toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        const headers = { "Content-Type": "application/json" };
+        if (this.apiKey) {
+            headers["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        const init = { method, headers };
+        if (body !== undefined) {
+            init.body = JSON.stringify(body);
+        }
+        const resp = await fetch(url, init);
+        if (!resp.ok) {
+            await this.throwError(resp);
+        }
+        return resp.json();
+    }
+    async throwError(resp) {
+        let body;
+        try {
+            body = await resp.json();
+        }
+        catch {
+            body = await resp.text();
+        }
+        const msg = (body && typeof body === "object" && "error" in body)
+            ? String(body.error)
+            : String(body);
+        if (resp.status === 401) {
+            throw new errors_js_1.AuthenticationError(msg, body);
+        }
+        if (resp.status === 404) {
+            throw new errors_js_1.NotFoundError(msg, body);
+        }
+        if (resp.status === 429) {
+            const retryAfter = resp.headers.get("Retry-After") || resp.headers.get("RateLimit-Reset");
+            const parsed = retryAfter ? (isNaN(Number(retryAfter)) ? retryAfter : Number(retryAfter)) : null;
+            throw new errors_js_1.RateLimitError(msg, body, parsed);
+        }
+        throw new errors_js_1.APIError(msg, resp.status, body);
+    }
+    async feed(options = {}) {
+        const params = { ...options };
+        if (params.limit !== undefined) {
+            params.perPage = params.limit;
+            delete params.limit;
+        }
+        const data = await this.request("GET", "/api/v1/feed", params);
+        const meta = (data.meta || {});
+        return {
+            briefs: (data.briefs || []).map(parseBrief),
+            total: (meta.total || data.total || 0),
+            page: (meta.page || data.page || 1),
+            perPage: (meta.per_page || data.per_page || 20),
+            generatedAt: data.generated_at,
+            agentVersion: data.agent_version,
+            sourcesScanned24h: (meta.sources_scanned_24h || data.sources_scanned_24h),
+        };
+    }
+    async brief(id, options = {}) {
+        const params = {};
+        if (options.includeFullText !== undefined) {
+            params.includeFullText = options.includeFullText;
+        }
+        const data = await this.request("GET", `/api/v1/brief/${id}`, params);
+        return parseBrief((data.brief || data));
+    }
+    async timeline(id) {
+        return this.request("GET", `/api/v1/brief/${id}/timeline`);
+    }
+    async search(query, options = {}) {
+        const params = { q: query, ...options };
+        const data = await this.request("GET", "/api/v1/search", params);
+        const dm = data.depth_metadata;
+        return {
+            briefs: (data.briefs || []).map(parseBrief),
+            total: (data.total || 0),
+            facets: data.facets,
+            relatedQueries: data.related_queries,
+            didYouMean: data.did_you_mean,
+            tookMs: data.took_ms,
+            meta: data.meta,
+            depthMetadata: dm ? {
+                depth: dm.depth,
+                searchMs: dm.search_ms,
+                crossRefMs: dm.cross_ref_ms,
+                verificationMs: dm.verification_ms,
+                totalMs: dm.total_ms,
+            } : undefined,
+        };
+    }
+    /** Get search autocomplete suggestions. */
+    async searchSuggest(q) {
+        const params = { q };
+        return this.request("GET", "/api/v1/search/suggest", params);
+    }
+    async generate(topic, category) {
+        const body = { topic };
+        if (category)
+            body.category = category;
+        const data = await this.request("POST", "/api/v1/generate/brief", undefined, body);
+        return parseBrief((data.brief || data));
+    }
+    async entities(options = {}) {
+        const data = await this.request("GET", "/api/v1/entities", options);
+        return {
+            entities: (data.entities || []).map(parseEntity),
+        };
+    }
+    async entityBriefs(name, options = {}) {
+        const data = await this.request("GET", `/api/v1/entities/${encodeURIComponent(name)}/briefs`, options);
+        return (data.briefs || []).map(parseBrief);
+    }
+    async trendingEntities(limit) {
+        const params = {};
+        if (limit !== undefined)
+            params.limit = limit;
+        const data = await this.request("GET", "/api/v1/entities/trending", params);
+        return {
+            entities: (data.entities || []).map(parseEntity),
+        };
+    }
+    async similar(id, options = {}) {
+        const data = await this.request("GET", `/api/v1/similar/${id}`, options);
+        return (data.briefs || []).map(parseBrief);
+    }
+    async clusters(options = {}) {
+        const data = await this.request("GET", "/api/v1/clusters", options);
+        return {
+            clusters: (data.clusters || []),
+            period: data.period,
+        };
+    }
+    async data(options = {}) {
+        const data = await this.request("GET", "/api/v1/data", options);
+        return { data: (data.data || []) };
+    }
+    async agentFeed(options = {}) {
+        const data = await this.request("GET", "/api/v1/agent-feed", options);
+        return {
+            briefs: (data.briefs || []).map(parseBrief),
+            total: (data.total || 0),
+            page: (data.page || 1),
+            perPage: (data.per_page || 20),
+            generatedAt: data.generated_at,
+            agentVersion: data.agent_version,
+            sourcesScanned24h: data.sources_scanned_24h,
+        };
+    }
+    async compareSources(briefId) {
+        const data = await this.request("GET", "/api/v1/compare/sources", { briefId });
+        const rawBrief = data.polaris_brief;
+        const rawAnalyses = data.source_analyses;
+        return {
+            topic: data.topic,
+            shareId: data.share_id,
+            polarisBrief: rawBrief ? parseBrief(rawBrief) : undefined,
+            sourceAnalyses: rawAnalyses ? rawAnalyses.map(parseSourceAnalysis) : undefined,
+            polarisAnalysis: data.polaris_analysis,
+            generatedAt: data.generated_at,
+        };
+    }
+    async research(query, options = {}) {
+        const body = { query };
+        if (options.maxSources !== undefined)
+            body.max_sources = options.maxSources;
+        if (options.depth !== undefined)
+            body.depth = options.depth;
+        if (options.category !== undefined)
+            body.category = options.category;
+        if (options.includeSources !== undefined)
+            body.include_sources = options.includeSources;
+        if (options.excludeSources !== undefined)
+            body.exclude_sources = options.excludeSources;
+        if (options.outputSchema !== undefined)
+            body.output_schema = options.outputSchema;
+        const data = await this.request("POST", "/api/v1/research", undefined, body);
+        const sourcesUsed = (data.sources_used || []).map((s) => ({
+            briefId: s.brief_id,
+            headline: s.headline,
+            confidence: s.confidence,
+            category: s.category,
+        }));
+        const entityMap = (data.entity_map || []).map((e) => ({
+            name: e.name,
+            type: e.type,
+            mentions: e.mentions,
+            coOccursWith: (e.co_occurs_with || []).map((c) => ({
+                entity: c.entity,
+                count: c.count,
+            })),
+        }));
+        const meta = data.metadata;
+        return {
+            query: data.query,
+            report: data.report,
+            sourcesUsed,
+            entityMap,
+            subQueries: data.sub_queries,
+            metadata: meta ? {
+                briefsAnalyzed: (meta.briefs_analyzed || 0),
+                uniqueSources: (meta.unique_sources || 0),
+                processingTimeMs: meta.processing_time_ms,
+                modelsUsed: meta.models_used,
+            } : undefined,
+            structuredOutput: data.structured_output,
+            structuredOutputError: data.structured_output_error,
+        };
+    }
+    async extract(urls, includeMetadata) {
+        const body = { urls };
+        if (includeMetadata !== undefined)
+            body.include_metadata = includeMetadata;
+        const data = await this.request("POST", "/api/v1/extract", undefined, body);
+        return {
+            results: (data.results || []).map((r) => ({
+                url: r.url,
+                title: r.title,
+                text: r.text,
+                wordCount: r.word_count,
+                language: r.language,
+                publishedDate: r.published_date,
+                domain: r.domain,
+                success: r.success,
+                error: r.error,
+            })),
+            creditsUsed: (data.credits_used || 0),
+        };
+    }
+    async verify(claim, options = {}) {
+        const body = { claim };
+        if (options.context !== undefined)
+            body.context = options.context;
+        const data = await this.request("POST", "/api/v1/verify", undefined, body);
+        const mapBrief = (b) => ({
+            id: b.id,
+            headline: b.headline,
+            confidence: b.confidence,
+            relevance: (b.relevance ?? null),
+        });
+        return {
+            claim: data.claim,
+            verdict: data.verdict,
+            confidence: (data.confidence || 0),
+            summary: (data.summary || ""),
+            supportingBriefs: (data.supporting_briefs || []).map(mapBrief),
+            contradictingBriefs: (data.contradicting_briefs || []).map(mapBrief),
+            nuances: (data.nuances ?? null),
+            sourcesAnalyzed: (data.sources_analyzed || 0),
+            briefsMatched: (data.briefs_matched || 0),
+            creditsUsed: (data.credits_used || 0),
+            cached: (data.cached || false),
+            processingTimeMs: (data.processing_time_ms || 0),
+            modelUsed: (data.model_used ?? null),
+        };
+    }
+    async trending(options = {}) {
+        const data = await this.request("GET", "/api/v1/trending", options);
+        return (data.briefs || []).map(parseBrief);
+    }
+    async forecast(topic, options = {}) {
+        const body = {
+            topic,
+            depth: options.depth ?? "standard",
+            period: options.period ?? "30d",
+            timeframe: options.timeframe ?? "30d",
+        };
+        return this.request("POST", "/api/v1/forecast", undefined, body);
+    }
+    async diff(id, since) {
+        const params = {};
+        if (since !== undefined)
+            params.since = since;
+        return this.request("GET", `/api/v1/brief/${id}/diff`, params);
+    }
+    async contradictions(options = {}) {
+        const params = { limit: options.limit ?? 20 };
+        if (options.severity !== undefined)
+            params.severity = options.severity;
+        if (options.category !== undefined)
+            params.category = options.category;
+        return this.request("GET", "/api/v1/contradictions", params);
+    }
+    async events(options = {}) {
+        const params = {
+            period: options.period ?? "30d",
+            limit: options.limit ?? 30,
+        };
+        if (options.type !== undefined)
+            params.type = options.type;
+        if (options.subject !== undefined)
+            params.subject = options.subject;
+        if (options.category !== undefined)
+            params.category = options.category;
+        return this.request("GET", "/api/v1/events", params);
+    }
+    async subscribeBrief(id) {
+        return this.request("POST", `/api/v1/brief/${id}/subscribe`, undefined, {});
+    }
+    async unsubscribeBrief(id) {
+        return this.request("DELETE", `/api/v1/brief/${id}/subscribe`);
+    }
+    async watchlists() {
+        return this.request("GET", "/api/v1/watchlists");
+    }
+    async createWatchlist(name, options = {}) {
+        const body = { name, ...options };
+        return this.request("POST", "/api/v1/watchlists", undefined, body);
+    }
+    async addWatchItem(watchlistId, type, options = {}) {
+        const body = { type, ...options };
+        return this.request("POST", `/api/v1/watchlists/${watchlistId}/items`, undefined, body);
+    }
+    /** Get matches for a watchlist. */
+    async watchlistMatches(watchlistId) {
+        return this.request("GET", `/api/v1/watchlists/${encodeURIComponent(watchlistId)}/matches`);
+    }
+    async createMonitor(options) {
+        return this.request("POST", "/api/v1/monitor", undefined, options);
+    }
+    async monitors() {
+        return this.request("GET", "/api/v1/monitors");
+    }
+    async createSession(name, metadata) {
+        const body = { name: name ?? "default" };
+        if (metadata !== undefined)
+            body.metadata = metadata;
+        return this.request("POST", "/api/v1/agent/session", undefined, body);
+    }
+    async sessions() {
+        return this.request("GET", "/api/v1/agent/sessions");
+    }
+    async markRead(sessionName, briefIds) {
+        const body = { brief_ids: briefIds };
+        return this.request("POST", `/api/v1/agent/session/${sessionName}/read`, undefined, body);
+    }
+    async agentFeedFiltered(options = {}) {
+        const params = {
+            session: options.session ?? "default",
+            limit: options.limit ?? 20,
+        };
+        if (options.category !== undefined)
+            params.category = options.category;
+        return this.request("GET", "/api/v1/agent/feed", params);
+    }
+    async webSearch(q, options) {
+        const params = { q, ...options };
+        return this.request("GET", "/api/v1/web-search", params);
+    }
+    async crawl(url, options) {
+        const body = { url, ...options };
+        return this.request("POST", "/api/v1/crawl", undefined, body);
+    }
+    // -- Trading --
+    async tickerResolve(symbols) {
+        const params = { q: symbols.join(",") };
+        return this.request("GET", "/api/v1/ticker/resolve", params);
+    }
+    async ticker(symbol) {
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}`);
+    }
+    async tickerHistory(symbol, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/history`, params);
+    }
+    async tickerSignals(symbol, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/signals`, params);
+    }
+    async tickerCorrelations(symbol, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/correlations`, params);
+    }
+    async tickerScore(symbol) {
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/score`);
+    }
+    /** Get live prices for one or more ticker symbols. */
+    async tickerPrices(symbols, paid) {
+        const params = { symbols: symbols.join(",") };
+        if (paid !== undefined)
+            params.paid = paid;
+        return this.request("GET", "/api/v1/ticker/prices", params);
+    }
+    /** Get sentiment analysis for a ticker symbol. */
+    async tickerSentiment(symbol, period) {
+        const params = {};
+        if (period !== undefined)
+            params.period = period;
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/sentiment`, params);
+    }
+    /** Get full analysis for a ticker symbol. */
+    async tickerAnalysis(symbol) {
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/analysis`);
+    }
+    /** Get recent news for a ticker symbol. */
+    async tickerNews(symbol, limit) {
+        const params = {};
+        if (limit !== undefined)
+            params.limit = limit;
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/news`, params);
+    }
+    async sectors(options = {}) {
+        const params = { ...options };
+        return this.request("GET", "/api/v1/sectors", params);
+    }
+    async sectorTickers(sector, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/sectors/${encodeURIComponent(sector)}/tickers`, params);
+    }
+    async eventsCalendar(options = {}) {
+        const params = { ...options };
+        return this.request("GET", "/api/v1/events/calendar", params);
+    }
+    /** Get IPO calendar, optionally filtered by status. */
+    async ipoCalendar(status) {
+        const params = {};
+        if (status !== undefined)
+            params.status = status;
+        return this.request("GET", "/api/v1/ipo/calendar", params);
+    }
+    async portfolioFeed(holdings, options = {}) {
+        const body = { holdings, ...options };
+        return this.request("POST", "/api/v1/portfolio/feed", undefined, body);
+    }
+    // -- AV Parity --
+    async candles(symbol, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/candles`, params);
+    }
+    async financials(symbol) {
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/financials`);
+    }
+    async earnings(symbol) {
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/earnings`);
+    }
+    async indicators(symbol, type, options = {}) {
+        const params = { type, ...options };
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/indicators`, params);
+    }
+    async technicals(symbol, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/technicals`, params);
+    }
+    async marketMovers() {
+        return this.request("GET", "/api/v1/market/movers");
+    }
+    async marketSummary() {
+        return this.request("GET", "/api/v1/market/summary");
+    }
+    async marketEarnings(options = {}) {
+        const params = { ...options };
+        return this.request("GET", "/api/v1/market/earnings", params);
+    }
+    async forex(pair) {
+        if (pair) {
+            return this.request("GET", `/api/v1/forex/${encodeURIComponent(pair)}`);
+        }
+        return this.request("GET", "/api/v1/forex");
+    }
+    async forexCandles(pair, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/forex/${encodeURIComponent(pair)}/candles`, params);
+    }
+    async commodities(symbol) {
+        if (symbol) {
+            return this.request("GET", `/api/v1/commodities/${encodeURIComponent(symbol)}`);
+        }
+        return this.request("GET", "/api/v1/commodities");
+    }
+    async commodityCandles(symbol, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/commodities/${encodeURIComponent(symbol)}/candles`, params);
+    }
+    async economy(indicator, options = {}) {
+        if (indicator) {
+            const params = { ...options };
+            return this.request("GET", `/api/v1/economy/${encodeURIComponent(indicator)}`, params);
+        }
+        return this.request("GET", "/api/v1/economy");
+    }
+    async economyYields() {
+        return this.request("GET", "/api/v1/economy/yields");
+    }
+    /** Get a specific economic indicator by name. */
+    async economyIndicator(indicator) {
+        return this.request("GET", `/api/v1/economy/${encodeURIComponent(indicator)}`);
+    }
+    // -- Crypto --
+    async crypto(symbol) {
+        if (symbol) {
+            return this.request("GET", `/api/v1/crypto/${encodeURIComponent(symbol)}`);
+        }
+        return this.request("GET", "/api/v1/crypto");
+    }
+    async cryptoTop(options = {}) {
+        const params = { ...options };
+        return this.request("GET", "/api/v1/crypto/top", params);
+    }
+    async cryptoChart(symbol, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/crypto/${encodeURIComponent(symbol)}/chart`, params);
+    }
+    async cryptoDefi(protocol) {
+        if (protocol) {
+            return this.request("GET", `/api/v1/crypto/defi/${encodeURIComponent(protocol)}`);
+        }
+        return this.request("GET", "/api/v1/crypto/defi");
+    }
+    /** Get details for a specific DeFi protocol. */
+    async defiProtocol(protocol) {
+        return this.request("GET", `/api/v1/crypto/defi/${encodeURIComponent(protocol)}`);
+    }
+    // -- Screener --
+    async screener(filters) {
+        return this.request("POST", "/api/v1/screener", undefined, filters);
+    }
+    async screenerNatural(query, options = {}) {
+        const body = { query };
+        if (options.limit !== undefined)
+            body.limit = options.limit;
+        return this.request("POST", "/api/v1/screener/natural", undefined, body);
+    }
+    async screenerPresets() {
+        return this.request("GET", "/api/v1/screener/presets");
+    }
+    async screenerPreset(id, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/screener/presets/${encodeURIComponent(id)}`, params);
+    }
+    // -- Alerts --
+    async createAlert(ticker, alertType, threshold, options = {}) {
+        const body = { ticker, alert_type: alertType, threshold };
+        if (options.callbackUrl !== undefined)
+            body.callback_url = options.callbackUrl;
+        return this.request("POST", "/api/v1/alerts", undefined, body);
+    }
+    async listAlerts(status) {
+        const params = {};
+        if (status !== undefined)
+            params.status = status;
+        return this.request("GET", "/api/v1/alerts", params);
+    }
+    async deleteAlert(id) {
+        return this.request("DELETE", `/api/v1/alerts/${encodeURIComponent(id)}`);
+    }
+    async triggeredAlerts(options = {}) {
+        const params = { ...options };
+        return this.request("GET", "/api/v1/alerts/triggered", params);
+    }
+    // -- Backtest --
+    async backtest(strategy, options = {}) {
+        const body = { strategy, period: options.period ?? "1y", ...options };
+        delete body.period;
+        body.period = options.period ?? "1y";
+        return this.request("POST", "/api/v1/backtest", undefined, body);
+    }
+    // -- Correlation --
+    async correlation(tickers, options = {}) {
+        const body = { tickers, days: options.days ?? 30 };
+        return this.request("POST", "/api/v1/correlation", undefined, body);
+    }
+    // -- Ticker Intelligence --
+    async newsImpact(symbol) {
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/impact`);
+    }
+    async competitors(symbol) {
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/competitors`);
+    }
+    async transcripts(symbol, options = {}) {
+        const params = { ...options };
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/transcripts`, params);
+    }
+    // -- Social --
+    /** Get social media sentiment for a ticker symbol. */
+    async socialSentiment(symbol) {
+        return this.request("GET", `/api/v1/ticker/${encodeURIComponent(symbol)}/social`);
+    }
+    /** Get trending topics across social media. */
+    async socialTrending() {
+        return this.request("GET", "/api/v1/social/trending");
+    }
+    /** Get social sentiment for a named entity. */
+    async socialEntity(entity) {
+        return this.request("GET", `/api/v1/social/sentiment/${encodeURIComponent(entity)}`);
+    }
+    // -- Reports --
+    /** Generate an AI report for a ticker. */
+    async generateReport(ticker, tier) {
+        const body = { ticker, tier: tier || "quick" };
+        return this.request("POST", "/api/v1/reports/generate", undefined, body);
+    }
+    /** Get a previously generated report by ID. */
+    async getReport(reportId) {
+        return this.request("GET", `/api/v1/reports/${encodeURIComponent(reportId)}`);
+    }
+    /** List recent reports. */
+    async listReports(limit) {
+        const params = { limit: limit ?? 20 };
+        return this.request("GET", "/api/v1/reports", params);
+    }
+    /** Upload a CLI-generated report. */
+    async uploadReport(ticker, markdown, tier) {
+        const body = { ticker, markdown, tier: tier || "cli" };
+        return this.request("POST", "/api/v1/reports/upload", undefined, body);
+    }
+    stream(options = {}) {
+        let controller = null;
+        return {
+            start: (onBrief, onError) => {
+                controller = new AbortController();
+                const params = {};
+                if (options.categories)
+                    params.categories = options.categories;
+                let url = `${this.baseUrl}/api/v1/stream`;
+                const snaked = toSnakeParams(params);
+                const qs = new URLSearchParams(snaked).toString();
+                if (qs)
+                    url += `?${qs}`;
+                const headers = { Accept: "text/event-stream" };
+                if (this.apiKey)
+                    headers["Authorization"] = `Bearer ${this.apiKey}`;
+                fetch(url, { headers, signal: controller.signal })
+                    .then(async (resp) => {
+                    if (!resp.ok) {
+                        await this.throwError(resp);
+                    }
+                    const reader = resp.body?.getReader();
+                    if (!reader)
+                        return;
+                    const decoder = new TextDecoder();
+                    let buffer = "";
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split("\n");
+                        buffer = lines.pop() || "";
+                        for (const line of lines) {
+                            if (line.startsWith("data:")) {
+                                const payload = line.slice(5).trim();
+                                if (payload && payload !== "[DONE]") {
+                                    try {
+                                        const data = JSON.parse(payload);
+                                        onBrief(parseBrief(data));
+                                    }
+                                    catch {
+                                        // skip malformed JSON
+                                    }
+                                }
+                            }
+                        }
+                    }
+                })
+                    .catch((err) => {
+                    if (err.name !== "AbortError") {
+                        onError?.(err);
+                    }
+                });
+            },
+            stop: () => {
+                controller?.abort();
+                controller = null;
+            },
+        };
+    }
+}
+exports.VeroqClient = VeroqClient;
+/** @deprecated Use VeroqClient instead */
+exports.PolarisClient = VeroqClient;
+//# sourceMappingURL=client.js.map