tradytics 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,16 @@
+MIT License
+
+Copyright (c) 2026 Tradytics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,58 @@
-# Temporary Holding Version
+# Tradytics for JavaScript
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The official JavaScript and TypeScript client for the [Tradytics API](https://tradytics.com/docs): live and historical options flow, dark pool prints ranked against a year, dealer gamma, delta, vanna and charm, the options market, research on every symbol, the scanner, Signals, Kalshi and Polymarket, and the AI Fund. One method per endpoint, typed, no dependencies. Node 18+, Bun, Deno and edge runtimes.
+
+```bash
+npm install tradytics
+```
+
+The API is part of Tradytics Pro. Make a key at [tradytics.com/developer/keys](https://tradytics.com/developer/keys) and export it:
+
+```bash
+export TRADYTICS_API_KEY="tdy_..."
+```
+
+## Quickstart
+
+```js
+import Tradytics from 'tradytics'
+
+const client = new Tradytics() // reads TRADYTICS_API_KEY
+
+const flow = await client.options.flow({ symbol: 'NVDA', min_premium: 1_000_000, opening: true })
+for (const p of flow.data) console.log(p.time, p.symbol, p.type, p.strike, p.expiry, p.premium)
+
+const bars = await client.symbols.bars('SPY', { timeframe: '5m', limit: 500 })
+const gamma = await client.options.exposure('SPY', { greek: 'gamma' })
+const prints = await client.darkpool.prints({ symbol: 'AAPL', min_value: 5_000_000 })
+```
+
+Objects come back as `{ data, as_of }`, lists as `{ data, count, next_cursor }`, the same JSON the API returns.
+
+## Resources
+
+`client.symbols`, `client.market`, `client.options`, `client.darkpool`, `client.research`, `client.scanner`, `client.signals`, `client.probabilities`, `client.fund` and `client.account`, one method per endpoint, with every parameter typed and described. [The docs](https://tradytics.com/docs) have every field.
+
+## Every page
+
+```js
+for await (const p of client.paginate(client.options.flow_history, { symbol: 'TSLA', min_premium: 500_000 })) {
+  // ...
+}
+```
+
+## New prints as they happen
+
+```js
+for await (const p of client.stream(client.options.flow, { min_premium: 250_000 })) {
+  console.log(p.symbol, p.type, p.strike, p.premium)
+}
+```
+
+`client.stream` works with `client.options.flow` and `client.darkpool.prints`, and yields each print once.
+
+## Errors and limits
+
+Calls that fail throw `TradyticsError` with `status`, `code` (e.g. `missing_scope`, `invalid_parameter`), `message` and `requestId`. Rate limits (300 calls a minute, 50,000 a day per key) and brief outages are retried for you, honoring `Retry-After`. `new Tradytics({ apiKey, timeout: 30_000, maxRetries: 3 })` changes the defaults. Keep the key on a server: anyone holding it uses your quota.
+
+Docs: [tradytics.com/docs](https://tradytics.com/docs). MCP server for Claude, ChatGPT and Cursor: [tradytics.com/docs/mcp](https://tradytics.com/docs/mcp).

package/base.d.ts

@@ -0,0 +1,10 @@
+/** An object answer: the record in `data`, when it was computed in `as_of`. */
+export interface Item<T = any> { data: T; as_of?: string; [key: string]: unknown }
+/** A list answer: rows in `data`; pass `next_cursor` back as `cursor` for the next page (null on the last). */
+export interface List<T = any> { data: T[]; count: number; next_cursor: string | null; [key: string]: unknown }
+export declare class Resource { protected constructor(transport: unknown) }
+export declare class TradyticsError extends Error {
+  status: number
+  code: string
+  requestId?: string
+}

package/base.js

@@ -0,0 +1,49 @@
+// The HTTP layer: one GET with the key in the header, retries on rate limits and blips, and one error type that
+// carries the API's code, message and request id.
+const RETRY = new Set([429, 500, 502, 503, 504])
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+export const enc = (v) => encodeURIComponent(String(v))
+
+export class TradyticsError extends Error {
+  constructor(status, code, message, requestId) {
+    super(`${status} ${code}: ${message}${requestId ? ` (request ${requestId})` : ''}`)
+    Object.assign(this, { name: 'TradyticsError', status, code, requestId })
+  }
+}
+
+export class Transport {
+  constructor({ apiKey, baseUrl, timeout, maxRetries, userAgent }) {
+    Object.assign(this, { apiKey, baseUrl: baseUrl.replace(/\/$/, ''), timeout, maxRetries, userAgent })
+  }
+
+  async get(path, params = {}) {
+    const query = new URLSearchParams(Object.entries(params).filter(([, v]) => v !== undefined && v !== null).map(([k, v]) => [k, String(v)])).toString()
+    const url = this.baseUrl + path + (query ? `?${query}` : '')
+    const headers = { Authorization: `Bearer ${this.apiKey}`, Accept: 'application/json', ...(typeof window === 'undefined' ? { 'User-Agent': this.userAgent } : {}) }
+    for (let attempt = 0; ; attempt++) {
+      let res
+      try {
+        res = await fetch(url, { headers, signal: AbortSignal.timeout(this.timeout) })
+      } catch (e) {
+        if (attempt < this.maxRetries) { await sleep(1000 * 2 ** attempt); continue }
+        throw new TradyticsError(0, 'network_error', String(e?.message ?? e))
+      }
+      if (res.ok) return res.json()
+      const wait = Number(res.headers.get('retry-after') ?? 2 ** attempt)
+      if (RETRY.has(res.status) && attempt < this.maxRetries && wait <= 60) { await sleep(wait * 1000); continue }
+      const body = await res.json().catch(() => ({}))
+      throw new TradyticsError(res.status, body.error?.code ?? 'error', body.error?.message ?? res.statusText, body.request_id)
+    }
+  }
+}
+
+// A resource's methods come bound, so client.options.flow can be handed to paginate and stream.
+export class Resource {
+  constructor(transport) {
+    this._t = transport
+    for (const k of Object.getOwnPropertyNames(Object.getPrototypeOf(this))) if (k !== 'constructor') this[k] = this[k].bind(this)
+  }
+
+  _get(path, params) { return this._t.get(path, params) }
+}

package/index.d.ts

@@ -0,0 +1,39 @@
+import type { Item, List } from './base.js'
+import { TradyticsError } from './base.js'
+import type { Account, Darkpool, Fund, Market, Options, Probabilities, Research, Scanner, Signals, Symbols } from './resources.js'
+
+export type { Item, List }
+export { TradyticsError }
+export declare const BASE_URL: string
+export declare const VERSION: string
+
+export interface ClientOptions {
+  /** Defaults to the TRADYTICS_API_KEY environment variable. Make one at https://tradytics.com/developer/keys. */
+  apiKey?: string
+  baseUrl?: string
+  /** Milliseconds. Default 30000. */
+  timeout?: number
+  /** Retries on 429 and 5xx. Default 3. */
+  maxRetries?: number
+}
+
+export declare class Tradytics {
+  constructor(options?: ClientOptions)
+  symbols: Symbols
+  market: Market
+  options: Options
+  darkpool: Darkpool
+  research: Research
+  scanner: Scanner
+  signals: Signals
+  probabilities: Probabilities
+  fund: Fund
+  account: Account
+  /** Any endpoint by its path: client.get('/options/flow', { symbol: 'NVDA' }). */
+  get(path: string, params?: Record<string, unknown>): Promise<Item | List>
+  /** Every row of a list endpoint, page after page: for await (const row of client.paginate(client.options.flow, { symbol: 'SPY' })). */
+  paginate(method: (...args: any[]) => Promise<List>, ...args: any[]): AsyncGenerator<any>
+  /** New prints as they happen, each once, from client.options.flow or client.darkpool.prints. */
+  stream(method: (params?: any) => Promise<List>, filters?: Record<string, unknown>, options?: { interval?: number }): AsyncGenerator<any>
+}
+export default Tradytics

package/index.js

@@ -0,0 +1,43 @@
+// The client: one property per resource (client.options.flow({...}), client.symbols.bars('SPY')), and helpers to walk
+// every page of a list and to stream new prints.
+import { Transport, TradyticsError } from './base.js'
+import { RESOURCES } from './resources.js'
+import { VERSION } from './version.js'
+
+export const BASE_URL = 'https://tradytics.com/api/public/v1'
+export { TradyticsError, VERSION }
+
+export class Tradytics {
+  constructor({ apiKey = globalThis.process?.env?.TRADYTICS_API_KEY, baseUrl = BASE_URL, timeout = 30_000, maxRetries = 3 } = {}) {
+    if (!apiKey) throw new TradyticsError(401, 'missing_key', 'Pass apiKey or set TRADYTICS_API_KEY. Make a key at https://tradytics.com/developer/keys.')
+    this._t = new Transport({ apiKey, baseUrl, timeout, maxRetries, userAgent: `tradytics-node/${VERSION}` })
+    for (const [name, Resource] of Object.entries(RESOURCES)) this[name] = new Resource(this._t)
+  }
+
+  get(path, params = {}) { return this._t.get(path, params) }
+
+  async *paginate(method, ...args) {
+    const params = { ...(typeof args.at(-1) === 'object' ? args.pop() : {}) }
+    const cursor = method.name.endsWith('bars') ? 'before' : 'cursor'
+    for (;;) {
+      const page = await method(...args, params)
+      yield* page.data ?? []
+      if (!page.next_cursor) return
+      params[cursor] = page.next_cursor
+    }
+  }
+
+  async *stream(method, filters = {}, { interval = 2000 } = {}) {
+    const latest = (await method({ ...filters, limit: 1 })).data ?? []
+    let last = latest[0]?.id ?? 0
+    for (;;) {
+      for (const row of (await method({ ...filters, since: last })).data ?? []) {
+        last = Math.max(last, row.id)
+        yield row
+      }
+      await new Promise((r) => setTimeout(r, interval))
+    }
+  }
+}
+
+export default Tradytics

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "tradytics",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "JavaScript and TypeScript client for the Tradytics API: options flow, dark pool prints, dealer exposure and market data.",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "files": [
+    "*.js",
+    "*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "license": "MIT",
+  "author": "Tradytics <hello@tradytics.com>",
+  "homepage": "https://tradytics.com/docs",
+  "keywords": [
+    "options flow",
+    "dark pool",
+    "gamma exposure",
+    "market data",
+    "stocks",
+    "trading",
+    "api",
+    "tradytics"
+  ]
+}

package/resources.d.ts

@@ -0,0 +1,199 @@
+// Generated by web/scripts/sdk.mjs from the docs content. Do not edit.
+import type { Item, List } from './base.js'
+import { Resource } from './base.js'
+
+/** Symbols, quotes, bars and each symbol's news. */
+export declare class Symbols extends Resource {
+  /** The ~6,000 symbols Tradytics tracks, most traded first. Search by ticker or name with q. GET /symbols */
+  list(params?: { /** Matches the start of a ticker or any part of a name. */ q?: string; /** stock, etf or adr. */ kind?: string; /** Rows per page, up to 1000. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+  /** One symbol: its name, kind, sector, industry, market cap and live quote. GET /symbols/{symbol} */
+  get(symbol: string, params?: {  }): Promise<Item>
+  /** Live quotes for up to 100 symbols, or for every tracked symbol (most traded first) when symbols is left out. Refreshed every 30 seconds. GET /quotes */
+  quotes(params?: { /** Comma-separated tickers, up to 100. */ symbols?: string; /** Rows per page, up to 1000. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+  /** OHLCV bars, oldest first, with today's forming bar. Daily, weekly and monthly bars go back to 2004 for every US stock; intraday bars cover two years of the ~3,000 most traded symbols, 1-second bars the last 7 days. Intraday buckets are aligned to New York time and include extended hours. GET /symbols/{symbol}/bars */
+  bars(symbol: string, params?: { /** 1s, 1m, 5m, 15m, 30m, 1h, 4h, 1d, 1w or 1M. */ timeframe?: string; /** Only bars starting before this time, epoch seconds. Pass next_cursor here to page back. */ before?: number; /** Rows per page, up to 5000. */ limit?: number }): Promise<List>
+  /** A symbol's latest 8 stories from the last 60 days. data is a list. GET /symbols/{symbol}/news */
+  news(symbol: string, params?: {  }): Promise<Item>
+}
+
+/** The market overview, news and calendars. */
+export declare class Market extends Resource {
+  /** Fifteen benchmarks in a fixed order: S&P 500, Nasdaq 100, Russell 2000, Dow, VIX, 20Y and 10Y Treasuries, high yield, gold, silver, oil, natural gas, the dollar, Bitcoin and Ethereum (through their ETFs). GET /market/assets */
+  assets(params?: {  }): Promise<Item>
+  /** How many liquid names ($20M+ traded today) are up and down, and how today's moves are spread. GET /market/breadth */
+  breadth(params?: {  }): Promise<Item>
+  /** The 11 sector ETFs with returns over six periods, their best and worst large caps today and how many members are up. GET /market/sectors */
+  sectors(params?: {  }): Promise<Item>
+  /** The 300 largest US stocks by sector and industry with their size and move. GET /market/heatmap */
+  heatmap(params?: {  }): Promise<Item>
+  /** Two dozen investing themes (AI chips, nuclear, crypto miners …) as equal-weight baskets. GET /market/themes */
+  themes(params?: {  }): Promise<Item>
+  /** Today's top 10 gainers, losers, most active and most unusual volume among stocks worth $2B+ trading $20M+. GET /market/movers */
+  movers(params?: {  }): Promise<Item>
+  /** The crypto market and its top 100 coins, with the day's biggest gainers and losers. GET /market/crypto */
+  crypto(params?: {  }): Promise<Item>
+  /** Up to 16 crypto categories by market cap. data is a list. GET /market/crypto/sectors */
+  crypto_sectors(params?: {  }): Promise<Item>
+  /** An AI-written read of the market: what moved and why, and the week's events ahead. Rewritten every 30 minutes in the session. GET /market/digest */
+  digest(params?: {  }): Promise<Item>
+  /** The day's most important stories, newest first. data is a list. GET /news */
+  news(params?: {  }): Promise<Item>
+  /** Companies worth $10B+ reporting in the next 7 days, by date then size, with today's reported EPS as it comes in. GET /calendar/earnings */
+  earnings_calendar(params?: {  }): Promise<Item>
+  /** The latest large open-market insider buys and sells (Form 4), and 20 days of insider money flow. GET /insiders */
+  insiders(params?: {  }): Promise<Item>
+  /** The latest stock trades disclosed by members of Congress, newest disclosure first. GET /congress */
+  congress(params?: {  }): Promise<Item>
+}
+
+/** Options flow, the options market and each symbol's options. */
+export declare class Options extends Resource {
+  /** The latest session's prints as they happen, newest first, and any of the last 7 sessions with date. Pass since to poll for new prints. The response also lists the sessions held in dates. GET /options/flow */
+  flow(params?: { /** One underlying. */ symbol?: string; /** A session in the last 7, YYYY-MM-DD. Default the latest. */ date?: string; /** call or put. */ type?: string; /** sweep, block, split or single. */ kind?: string; /** bought (at or above the ask side) or sold. */ side?: string; /** Only prints of at least this premium, $. */ min_premium?: number; /** One expiration, YYYY-MM-DD. */ expiry?: string; /** Only prints larger than the open interest: new positions. */ opening?: boolean; /** Only prints after this id, oldest first (polling). */ since?: number; /** Rows per page, up to 1000. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+  /** One symbol's prints from the archive, every session since 2025-03-31, newest first. GET /options/flow/history */
+  flow_history(params?: { /** Underlying. */ symbol: string; /** First day, YYYY-MM-DD. Default 30 days before to. */ from?: string; /** Last day. Default today. */ to?: string; /** call or put. */ type?: string; /** sweep, block, split or single. */ kind?: string; /** bought (at or above the ask side) or sold. */ side?: string; /** Only prints of at least this premium, $. */ min_premium?: number; /** One expiration, YYYY-MM-DD. */ expiry?: string; /** Only prints larger than the open interest: new positions. */ opening?: boolean; /** Rows per page, up to 1000. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+  /** Net premium through the day: calls bought minus sold against puts bought minus sold. market is single stocks (indices left out) over 1, 3 or 5 sessions; or one of SPY, QQQ, IWM. GET /market/options/sentiment */
+  sentiment(params?: { /** market, market-3d, market-5d, SPY, QQQ or IWM. */ scope?: string }): Promise<Item>
+  /** Each session's net delta of options flow in stock-equivalent dollars, over 60 sessions, with SPY. GET /market/options/pressure */
+  pressure(params?: {  }): Promise<Item>
+  /** Dealer gamma exposure by strike near spot, with the call wall, put wall and gamma flip. GET /market/options/gamma */
+  index_gamma(params?: { /** SPX, SPY or QQQ. */ symbol?: string }): Promise<Item>
+  /** Today's call and put premium, split between index products and single stocks. GET /market/options/put-call */
+  put_call(params?: {  }): Promise<Item>
+  /** The 10 single stocks with the most bullish and the most bearish net premium today. GET /market/options/leaders */
+  leaders(params?: {  }): Promise<Item>
+  /** Bullish and bearish premium today by sector, most bullish first. GET /market/options/sectors */
+  sectors(params?: {  }): Promise<Item>
+  /** Today's 12 largest prints by premium. GET /market/options/top-prints */
+  top_prints(params?: {  }): Promise<Item>
+  /** The 15 contracts with the most volume today. GET /market/options/contracts */
+  contracts(params?: {  }): Promise<Item>
+  /** Liquid stocks with the highest implied volatility and the biggest IV rises and drops since the last session. GET /market/options/iv */
+  iv(params?: {  }): Promise<Item>
+  /** Same-day expiring premium through the day, bought minus sold. GET /market/options/zero-dte */
+  zero_dte(params?: { /** SPY, QQQ, SPX or IWM. */ symbol?: string }): Promise<Item>
+  /** Dealer gamma from today's same-day expiring prints by strike, updated every 30 seconds. GET /market/options/zero-dte/gamma */
+  zero_dte_gamma(params?: { /** SPX, SPY or QQQ. */ symbol?: string }): Promise<Item>
+  /** The Options page's read of the day: the lean against the last 20 sessions at the same minute, notes, SPY's expected move, dealer gamma and hedging. GET /market/options/read */
+  read(params?: {  }): Promise<Item>
+  /** Single stocks with today's largest net premium against their own usual day, and the same by sector. GET /market/options/bets */
+  bets(params?: {  }): Promise<Item>
+  /** Today's biggest single-stock prints that opened new positions ($250K+, size above open interest, no spreads). GET /market/options/unusual */
+  unusual(params?: {  }): Promise<Item>
+  /** Today's contracts in four lists: most active, cheap (under $1), LEAPs (a year+) and far out of the money. GET /market/options/chains */
+  chains(params?: {  }): Promise<Item>
+  /** What the flow lab proved, computed live every 5 minutes: likely ranges for SPY and QQQ, the gamma regime, IV against realized, the 0DTE share and big-move odds. GET /market/options/evidence */
+  evidence(params?: {  }): Promise<Item>
+  /** Today at a glance from prints of $25K+. GET /symbols/{symbol}/options */
+  overview(symbol: string, params?: {  }): Promise<Item>
+  /** Bullish and bearish premium through today against the price. GET /symbols/{symbol}/options/flow */
+  net_flow(symbol: string, params?: {  }): Promise<Item>
+  /** Dealer gamma by strike near spot with the call wall, put wall and gamma flip. 404 for symbols without dealer data. GET /symbols/{symbol}/options/gamma */
+  gamma(symbol: string, params?: {  }): Promise<Item>
+  /** The at-the-money term structure and the front expiry's smile. GET /symbols/{symbol}/options/volatility */
+  volatility(symbol: string, params?: {  }): Promise<Item>
+  /** Call and put open interest by strike near spot, for all expiries or one. GET /symbols/{symbol}/options/open-interest */
+  open_interest(symbol: string, params?: { /** One expiry, YYYY-MM-DD (from expiries). Default all. */ expiry?: string }): Promise<Item>
+  /** Net premium on the 6 busiest strikes by the 6 busiest expiries, today and over the last 5 sessions. GET /symbols/{symbol}/options/expiries */
+  expiries(symbol: string, params?: {  }): Promise<Item>
+  /** Today's 12 largest orders and 12 most unusual contracts (volume far above open interest). GET /symbols/{symbol}/options/orders */
+  orders(symbol: string, params?: {  }): Promise<Item>
+  /** The last 30 sessions of premium, oldest first. GET /symbols/{symbol}/options/history */
+  history(symbol: string, params?: {  }): Promise<Item>
+  /** Dealer gamma, delta, vanna or charm by strike for about 2,500 stocks and ETFs, recomputed every five minutes, with each strike's change since the session before, a week and two weeks back. GET /symbols/{symbol}/options/exposure */
+  exposure(symbol: string, params?: { /** gamma, delta, vanna or charm. */ greek?: string; /** One expiry, YYYY-MM-DD. Default all. */ expiry?: string }): Promise<Item>
+  /** About 18 months of daily dealer net delta and net gamma against the close, oldest first. GET /symbols/{symbol}/options/exposure/history */
+  exposure_history(symbol: string, params?: { /** First day, YYYY-MM-DD. */ from?: string; /** Last day, YYYY-MM-DD. */ to?: string }): Promise<Item>
+}
+
+/** Dark pool prints, history, levels and ranks. */
+export declare class Darkpool extends Resource {
+  /** The latest session's prints as they happen, newest first, and any of the last 10 sessions with date. Pass since to poll. GET /darkpool/prints */
+  prints(params?: { /** One ticker. */ symbol?: string; /** A session in the last 10, YYYY-MM-DD. */ date?: string; /** dark (off-exchange) or lit (exchange blocks). */ venue?: string; /** Only prints worth at least this, $. */ min_value?: number; /** Only prints after this id, oldest first. */ since?: number; /** Rows per page, up to 1000. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+  /** One symbol's prints from the archive, every session since 2025-06-09, newest first. GET /darkpool/history */
+  history(params?: { /** Ticker. */ symbol: string; /** First day. Default 30 days before to. */ from?: string; /** Last day. Default today. */ to?: string; /** dark or lit. */ venue?: string; /** Minimum value, $. */ min_value?: number; /** Rows per page, up to 1000. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+  /** The price levels with the most dark pool money over the last 10 sessions, and 30 sessions of daily totals. GET /symbols/{symbol}/darkpool */
+  levels(symbol: string, params?: {  }): Promise<Item>
+  /** A year of one stock's prints, each ranked against every print of the same kind in its last 12 months (1 is the largest in a year). Prints are reported after they happen. GET /symbols/{symbol}/darkpool/ranked */
+  ranked(symbol: string, params?: { /** trade (block trades), close or open (the auctions). */ kind?: string; /** big (largest first) or new. */ sort?: string; /** Rows per page, up to 200. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+}
+
+/** Each symbol's fundamentals, analysts and technicals. */
+export declare class Research extends Resource {
+  /** Quote, returns, valuation, margins, short interest and the company profile. GET /symbols/{symbol}/summary */
+  summary(symbol: string, params?: {  }): Promise<Item>
+  /** Ratings from each firm's latest call in the last year, price targets from the last six months, and recent actions. GET /symbols/{symbol}/analysts */
+  analysts(symbol: string, params?: {  }): Promise<Item>
+  /** The last 8 quarters against estimates, the beat record and the next report. GET /symbols/{symbol}/earnings */
+  earnings(symbol: string, params?: {  }): Promise<Item>
+  /** Twelve quarters and six fiscal years of the income statement, with cash flow. GET /symbols/{symbol}/financials */
+  financials(symbol: string, params?: {  }): Promise<Item>
+  /** An overall technical rating with the signals, moving averages and oscillators behind it, and monthly seasonality. GET /symbols/{symbol}/technicals */
+  technicals(symbol: string, params?: {  }): Promise<Item>
+  /** Recent insider buys and sells, short interest history, float and institutional ownership. GET /symbols/{symbol}/ownership */
+  ownership(symbol: string, params?: {  }): Promise<Item>
+  /** An ETF's sector weights, top 10 holdings and facts. GET /symbols/{symbol}/holdings */
+  holdings(symbol: string, params?: {  }): Promise<Item>
+}
+
+/** The full-market scanner. */
+export declare class Scanner extends Resource {
+  /** Filter on any numeric field with min_<field> and max_<field> (e.g. min_rvol=2&max_rsi=30), require labels, and sort by any field. GET /scanner */
+  scan(params?: { /** Comma-separated fields to return. Default a compact set. */ fields?: string; /** Comma-separated label ids; a row must carry all of them. */ labels?: string; /** One sector, e.g. Technology. */ sector?: string; /** stock, etf or adr. */ kind?: string; /** Field to sort by. */ sort?: string; /** asc or desc. */ order?: string; /** Rows per page, up to 1000. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string; [filter: string]: string | number | boolean | undefined }): Promise<List>
+  /** Every field name, and every label with its group and lean. GET /scanner/fields */
+  fields(params?: {  }): Promise<Item>
+  /** One symbol's full scanner row. GET /symbols/{symbol}/scan */
+  symbol(symbol: string, params?: {  }): Promise<Item>
+}
+
+/** Live orders matching tested flow patterns. */
+export declare class Signals extends Resource {
+  /** Signals newest first, today's live. GET /signals */
+  list(params?: { /** One pattern: repeat-flow, opening-calls, heavy-calls, etf-repeat-calls, itm-puts, burst-calls, index-tide-calls. */ source?: string; /** One ticker. */ symbol?: string; /** open or settled. */ status?: string; /** Fired on this day, YYYY-MM-DD. */ date?: string; /** Rows per page, up to 100. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+  /** One signal with the prints behind it and every mark. GET /signals/{id} */
+  get(id: number, params?: {  }): Promise<Item>
+}
+
+/** Kalshi and Polymarket finance questions. */
+export declare class Probabilities extends Resource {
+  /** Every live question the board shows (books no wider than 10 cents, active in the last day), with its leading outcomes. GET /probabilities */
+  list(params?: { /** close, range, hit or earnings. */ group?: string; /** One underlying, e.g. SPX, NDX, NVDA. */ symbol?: string }): Promise<List>
+  /** One question with every outcome, and for earnings questions the stock's past report-day moves. GET /probabilities/{id} */
+  get(id: string, params?: {  }): Promise<Item>
+  /** One outcome's chance through time, live or settled: the last trade's price in each hour or day. GET /probabilities/markets/{market}/history */
+  history(market: string, params?: { /** hour or day. */ interval?: string; /** First day, YYYY-MM-DD. */ from?: string; /** Last day, YYYY-MM-DD. */ to?: string }): Promise<Item>
+  /** Where Kalshi and Polymarket put the S&P 500 at each date they price, from the next close to year end. GET /probabilities/outlook */
+  outlook(params?: {  }): Promise<Item>
+  /** The S&P 500's and Nasdaq-100's last 30 sessions: where the crowd put the close at 10 AM against where it closed. GET /probabilities/track */
+  track(params?: {  }): Promise<Item>
+  /** Every finance market Kalshi has settled since June 2021, and Polymarket's, the latest to close first. GET /probabilities/settled */
+  settled(params?: { /** kalshi or polymarket. */ source?: string; /** Kalshi series (e.g. KXINXU, the S&P 500 close) or Polymarket event id. */ series?: string; /** Kalshi category (Financials, Economics, Crypto) or Polymarket tag (stocks, economy, fed). */ category?: string; /** Closed on or after, YYYY-MM-DD. Default 30 days back unless series is set. */ from?: string; /** Closed on or before, YYYY-MM-DD. */ to?: string; /** Rows per page, up to 1000. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+}
+
+/** The Tradytics AI Fund. */
+export declare class Fund extends Resource {
+  /** Exposure, open positions and the latest posts. GET /fund */
+  summary(params?: {  }): Promise<Item>
+  /** Every trade, open and closed, newest first. GET /fund/trades */
+  trades(params?: { /** open or closed. */ status?: string; /** One ticker. */ symbol?: string; /** Rows per page, up to 200. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+  /** The portfolio manager's posts (one per trade, add, trim or close) and weekly letters, newest first. GET /fund/posts */
+  posts(params?: { /** post or letter. */ kind?: string; /** Rows per page, up to 100. */ limit?: number; /** next_cursor from the previous page. */ cursor?: string }): Promise<List>
+}
+
+/** Your own backtests, portfolio and dashboards. */
+export declare class Account extends Resource {
+  /** Your backtests, the latest first. GET /backtests */
+  backtests(params?: { /** Only backtests whose title or messages mention this. */ q?: string; /** Rows per page, up to 200. */ limit?: number }): Promise<List>
+  /** One backtest: the conversation and every run it made. GET /backtests/{id} */
+  backtest(id: number, params?: {  }): Promise<Item>
+  /** Your linked brokerage accounts, read-only: holdings, options and recent orders. GET /portfolio */
+  portfolio(params?: {  }): Promise<Item>
+  /** A year of closed round trips, newest first, with dividends and fees. GET /portfolio/trades */
+  portfolio_trades(params?: {  }): Promise<Item>
+  /** Risk by source, beta, value at risk and tracking error, and returns split into market, sectors, styles and stock picking. 404 not_connected before a brokerage is linked. GET /portfolio/factors */
+  portfolio_factors(params?: {  }): Promise<Item>
+  /** Your dashboards. GET /dashboards */
+  dashboards(params?: {  }): Promise<List>
+  /** One dashboard's layout. GET /dashboards/{id} */
+  dashboard(id: number, params?: {  }): Promise<Item>
+}

package/resources.js

@@ -0,0 +1,112 @@
+// Generated by web/scripts/sdk.mjs from the docs content. Do not edit.
+import { Resource, enc } from './base.js'
+
+export class Symbols extends Resource {
+  list(params = {}) { return this._get('/symbols', params) }
+  get(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}`, params) }
+  quotes(params = {}) { return this._get('/quotes', params) }
+  bars(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/bars`, params) }
+  news(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/news`, params) }
+}
+
+export class Market extends Resource {
+  assets(params = {}) { return this._get('/market/assets', params) }
+  breadth(params = {}) { return this._get('/market/breadth', params) }
+  sectors(params = {}) { return this._get('/market/sectors', params) }
+  heatmap(params = {}) { return this._get('/market/heatmap', params) }
+  themes(params = {}) { return this._get('/market/themes', params) }
+  movers(params = {}) { return this._get('/market/movers', params) }
+  crypto(params = {}) { return this._get('/market/crypto', params) }
+  crypto_sectors(params = {}) { return this._get('/market/crypto/sectors', params) }
+  digest(params = {}) { return this._get('/market/digest', params) }
+  news(params = {}) { return this._get('/news', params) }
+  earnings_calendar(params = {}) { return this._get('/calendar/earnings', params) }
+  insiders(params = {}) { return this._get('/insiders', params) }
+  congress(params = {}) { return this._get('/congress', params) }
+}
+
+export class Options extends Resource {
+  flow(params = {}) { return this._get('/options/flow', params) }
+  flow_history(params = {}) { return this._get('/options/flow/history', params) }
+  sentiment(params = {}) { return this._get('/market/options/sentiment', params) }
+  pressure(params = {}) { return this._get('/market/options/pressure', params) }
+  index_gamma(params = {}) { return this._get('/market/options/gamma', params) }
+  put_call(params = {}) { return this._get('/market/options/put-call', params) }
+  leaders(params = {}) { return this._get('/market/options/leaders', params) }
+  sectors(params = {}) { return this._get('/market/options/sectors', params) }
+  top_prints(params = {}) { return this._get('/market/options/top-prints', params) }
+  contracts(params = {}) { return this._get('/market/options/contracts', params) }
+  iv(params = {}) { return this._get('/market/options/iv', params) }
+  zero_dte(params = {}) { return this._get('/market/options/zero-dte', params) }
+  zero_dte_gamma(params = {}) { return this._get('/market/options/zero-dte/gamma', params) }
+  read(params = {}) { return this._get('/market/options/read', params) }
+  bets(params = {}) { return this._get('/market/options/bets', params) }
+  unusual(params = {}) { return this._get('/market/options/unusual', params) }
+  chains(params = {}) { return this._get('/market/options/chains', params) }
+  evidence(params = {}) { return this._get('/market/options/evidence', params) }
+  overview(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/options`, params) }
+  net_flow(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/options/flow`, params) }
+  gamma(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/options/gamma`, params) }
+  volatility(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/options/volatility`, params) }
+  open_interest(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/options/open-interest`, params) }
+  expiries(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/options/expiries`, params) }
+  orders(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/options/orders`, params) }
+  history(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/options/history`, params) }
+  exposure(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/options/exposure`, params) }
+  exposure_history(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/options/exposure/history`, params) }
+}
+
+export class Darkpool extends Resource {
+  prints(params = {}) { return this._get('/darkpool/prints', params) }
+  history(params = {}) { return this._get('/darkpool/history', params) }
+  levels(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/darkpool`, params) }
+  ranked(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/darkpool/ranked`, params) }
+}
+
+export class Research extends Resource {
+  summary(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/summary`, params) }
+  analysts(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/analysts`, params) }
+  earnings(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/earnings`, params) }
+  financials(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/financials`, params) }
+  technicals(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/technicals`, params) }
+  ownership(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/ownership`, params) }
+  holdings(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/holdings`, params) }
+}
+
+export class Scanner extends Resource {
+  scan(params = {}) { return this._get('/scanner', params) }
+  fields(params = {}) { return this._get('/scanner/fields', params) }
+  symbol(symbol, params = {}) { return this._get(`/symbols/${enc(symbol)}/scan`, params) }
+}
+
+export class Signals extends Resource {
+  list(params = {}) { return this._get('/signals', params) }
+  get(id, params = {}) { return this._get(`/signals/${enc(id)}`, params) }
+}
+
+export class Probabilities extends Resource {
+  list(params = {}) { return this._get('/probabilities', params) }
+  get(id, params = {}) { return this._get(`/probabilities/${enc(id)}`, params) }
+  history(market, params = {}) { return this._get(`/probabilities/markets/${enc(market)}/history`, params) }
+  outlook(params = {}) { return this._get('/probabilities/outlook', params) }
+  track(params = {}) { return this._get('/probabilities/track', params) }
+  settled(params = {}) { return this._get('/probabilities/settled', params) }
+}
+
+export class Fund extends Resource {
+  summary(params = {}) { return this._get('/fund', params) }
+  trades(params = {}) { return this._get('/fund/trades', params) }
+  posts(params = {}) { return this._get('/fund/posts', params) }
+}
+
+export class Account extends Resource {
+  backtests(params = {}) { return this._get('/backtests', params) }
+  backtest(id, params = {}) { return this._get(`/backtests/${enc(id)}`, params) }
+  portfolio(params = {}) { return this._get('/portfolio', params) }
+  portfolio_trades(params = {}) { return this._get('/portfolio/trades', params) }
+  portfolio_factors(params = {}) { return this._get('/portfolio/factors', params) }
+  dashboards(params = {}) { return this._get('/dashboards', params) }
+  dashboard(id, params = {}) { return this._get(`/dashboards/${enc(id)}`, params) }
+}
+
+export const RESOURCES = { symbols: Symbols, market: Market, options: Options, darkpool: Darkpool, research: Research, scanner: Scanner, signals: Signals, probabilities: Probabilities, fund: Fund, account: Account }

package/version.js

@@ -0,0 +1 @@
+export const VERSION = '0.1.0'