@noya-ai/data-server-schemas 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1359 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  alternative: () => schemas_exports,
+  batch: () => schemas_exports2,
+  coingecko: () => schemas_exports3,
+  coinglass: () => schemas_exports4,
+  composite: () => schemas_exports5,
+  cryptonews: () => schemas_exports6,
+  defillama: () => schemas_exports7,
+  geckoterminal: () => schemas_exports8,
+  kaito: () => schemas_exports9,
+  moralis: () => schemas_exports10,
+  noya: () => schemas_exports11
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/alternative/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  FearGreedBody: () => FearGreedBody,
+  FearGreedEntry: () => FearGreedEntry,
+  FearGreedResponse: () => FearGreedResponse
+});
+var import_zod = require("zod");
+var FearGreedBody = import_zod.z.object({
+  limit: import_zod.z.number().int().min(0).default(1).describe("Number of historical Fear & Greed entries to return (most recent first). 1 returns just the latest reading.")
+});
+var FearGreedEntry = import_zod.z.object({
+  value: import_zod.z.number(),
+  classification: import_zod.z.string(),
+  timestamp: import_zod.z.number(),
+  timeUntilUpdate: import_zod.z.number().nullable()
+});
+var FearGreedResponse = import_zod.z.array(FearGreedEntry);
+
+// src/batch/schemas.ts
+var schemas_exports2 = {};
+__export(schemas_exports2, {
+  BatchBody: () => BatchBody,
+  BatchFailure: () => BatchFailure,
+  BatchItem: () => BatchItem,
+  BatchResponse: () => BatchResponse,
+  BatchResult: () => BatchResult,
+  BatchSuccess: () => BatchSuccess
+});
+var import_zod2 = require("zod");
+var BatchItem = import_zod2.z.object({
+  name: import_zod2.z.string().min(1).max(100).describe("Caller-chosen identifier for this sub-request \u2014 used to key the result in the response object. Must be unique within the batch."),
+  method: import_zod2.z.enum(["GET", "POST"]).describe("HTTP method for the sub-request."),
+  path: import_zod2.z.string().startsWith("/").min(2).describe("Server-relative path of the sub-request (e.g. `/coingecko/price`). Nested batch paths are forbidden."),
+  body: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional().describe("JSON body for POST sub-requests. Ignored for GET."),
+  query: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional().describe("Query-string parameters appended to the sub-request URL."),
+  timeoutMs: import_zod2.z.number().int().positive().max(6e4).optional().describe("Per-request timeout override in milliseconds. Falls back to the batch's `defaultTimeoutMs`.")
+}).refine(
+  (item) => !(item.path === "/batch" || item.path.startsWith("/batch/")),
+  { message: "nested batch requests are not allowed" }
+);
+var BatchBody = import_zod2.z.object({
+  requests: import_zod2.z.array(BatchItem).min(1).max(20).describe("Array of sub-requests to dispatch in parallel (1\u201320 items)."),
+  defaultTimeoutMs: import_zod2.z.number().int().positive().max(6e4).optional().default(15e3).describe("Default timeout in milliseconds applied to any sub-request that doesn't set its own `timeoutMs`. Capped at 60s.")
+}).refine(
+  (input) => new Set(input.requests.map((r) => r.name)).size === input.requests.length,
+  { message: "request names must be unique within a batch" }
+);
+var BatchSuccess = import_zod2.z.object({
+  ok: import_zod2.z.literal(true),
+  status: import_zod2.z.number(),
+  data: import_zod2.z.unknown(),
+  cache: import_zod2.z.enum(["HIT", "MISS"]).optional()
+});
+var BatchFailure = import_zod2.z.object({
+  ok: import_zod2.z.literal(false),
+  status: import_zod2.z.number(),
+  error: import_zod2.z.string()
+});
+var BatchResult = import_zod2.z.union([BatchSuccess, BatchFailure]);
+var BatchResponse = import_zod2.z.object({
+  results: import_zod2.z.record(import_zod2.z.string(), BatchResult)
+});
+
+// src/coingecko/schemas.ts
+var schemas_exports3 = {};
+__export(schemas_exports3, {
+  ContractAddress: () => ContractAddress,
+  OhlcvBody: () => OhlcvBody,
+  OhlcvCandle: () => OhlcvCandle,
+  OhlcvResponse: () => OhlcvResponse,
+  PriceAtDateBody: () => PriceAtDateBody,
+  PriceBody: () => PriceBody,
+  PriceHistoryBody: () => PriceHistoryBody,
+  PriceHistoryResponse: () => PriceHistoryResponse,
+  PricePoint: () => PricePoint,
+  PriceResponse: () => PriceResponse,
+  PriceSnapshot: () => PriceSnapshot,
+  SearchBody: () => SearchBody,
+  SearchResponse: () => SearchResponse,
+  SearchResult: () => SearchResult,
+  TokenInfo: () => TokenInfo,
+  TokenInfoBody: () => TokenInfoBody,
+  TokenPrice: () => TokenPrice,
+  TrendingResponse: () => TrendingResponse,
+  TrendingToken: () => TrendingToken
+});
+var import_zod3 = require("zod");
+var PriceBody = import_zod3.z.object({
+  tokenIds: import_zod3.z.array(import_zod3.z.string()).min(1).describe("CoinGecko token IDs to price (e.g. `bitcoin`, `ethereum`). At least one required."),
+  vsCurrencies: import_zod3.z.array(import_zod3.z.string()).optional().describe("Quote currencies (e.g. `usd`, `eur`, `btc`). Defaults to USD when omitted."),
+  include24hrChange: import_zod3.z.boolean().default(true).describe("Include 24-hour percentage price change in the response."),
+  includeMarketCap: import_zod3.z.boolean().default(true).describe("Include market cap in the response."),
+  include24hrVol: import_zod3.z.boolean().default(false).describe("Include 24-hour trading volume in the response.")
+});
+var TokenPrice = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  price: import_zod3.z.number().nullable(),
+  change24h: import_zod3.z.number().nullable(),
+  marketCap: import_zod3.z.number().nullable(),
+  volume24h: import_zod3.z.number().nullable(),
+  currency: import_zod3.z.string()
+});
+var PriceResponse = import_zod3.z.array(TokenPrice);
+var OhlcvBody = import_zod3.z.object({
+  tokenId: import_zod3.z.string().min(1).describe("CoinGecko token ID (e.g. `bitcoin`)."),
+  vsCurrency: import_zod3.z.string().default("usd").describe("Quote currency for the OHLCV candles."),
+  days: import_zod3.z.enum(["1", "7", "14", "30", "90", "180", "365", "max"]).default("7").describe("Lookback window. Use `max` for the full available history."),
+  interval: import_zod3.z.enum(["daily", "hourly"]).optional().describe("Candle resolution. CoinGecko picks a sensible default if omitted (hourly for short windows, daily for long).")
+});
+var OhlcvCandle = import_zod3.z.object({
+  timestamp: import_zod3.z.number(),
+  open: import_zod3.z.number(),
+  high: import_zod3.z.number(),
+  low: import_zod3.z.number(),
+  close: import_zod3.z.number()
+});
+var OhlcvResponse = import_zod3.z.array(OhlcvCandle);
+var TokenInfoBody = import_zod3.z.object({
+  tokenId: import_zod3.z.string().min(1).describe("CoinGecko token ID to fetch metadata for.")
+});
+var ContractAddress = import_zod3.z.object({
+  chain: import_zod3.z.string(),
+  chainId: import_zod3.z.number().nullable(),
+  platformId: import_zod3.z.string(),
+  address: import_zod3.z.string()
+});
+var TokenInfo = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  symbol: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  description: import_zod3.z.string(),
+  categories: import_zod3.z.array(import_zod3.z.string()),
+  links: import_zod3.z.object({
+    homepage: import_zod3.z.array(import_zod3.z.string()),
+    twitter: import_zod3.z.string().nullable(),
+    telegram: import_zod3.z.string().nullable(),
+    github: import_zod3.z.array(import_zod3.z.string()),
+    subreddit: import_zod3.z.string().nullable()
+  }),
+  contracts: import_zod3.z.array(ContractAddress),
+  genesisDate: import_zod3.z.string().nullable(),
+  image: import_zod3.z.string().nullable(),
+  marketCapRank: import_zod3.z.number().nullable()
+});
+var TrendingToken = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  symbol: import_zod3.z.string(),
+  marketCapRank: import_zod3.z.number().nullable(),
+  priceBtc: import_zod3.z.number().nullable(),
+  priceUsd: import_zod3.z.number().nullable(),
+  change24h: import_zod3.z.number().nullable(),
+  thumb: import_zod3.z.string().nullable(),
+  score: import_zod3.z.number().nullable()
+});
+var TrendingResponse = import_zod3.z.array(TrendingToken);
+var SearchBody = import_zod3.z.object({
+  query: import_zod3.z.string().min(1).describe("Free-text search query (token name, symbol, or partial match).")
+});
+var SearchResult = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  symbol: import_zod3.z.string(),
+  marketCapRank: import_zod3.z.number().nullable(),
+  thumb: import_zod3.z.string().nullable()
+});
+var SearchResponse = import_zod3.z.array(SearchResult);
+var PriceHistoryBody = import_zod3.z.object({
+  tokenId: import_zod3.z.string().min(1).describe("CoinGecko token ID."),
+  vsCurrency: import_zod3.z.string().default("usd").describe("Quote currency for the historical prices."),
+  days: import_zod3.z.string().optional().describe("Lookback window in days (e.g. `30`). Mutually exclusive with `from`/`to`."),
+  from: import_zod3.z.string().optional().describe("ISO 8601 start timestamp (UTC). Use with `to` instead of `days`."),
+  to: import_zod3.z.string().optional().describe("ISO 8601 end timestamp (UTC). Use with `from` instead of `days`."),
+  interval: import_zod3.z.enum(["5m", "hourly", "daily"]).optional().describe("Sampling interval. CoinGecko picks one based on the window when omitted.")
+}).refine(
+  (d) => d.days || d.from && d.to,
+  "Provide either 'days' or both 'from' and 'to'"
+);
+var PricePoint = import_zod3.z.object({
+  timestamp: import_zod3.z.number(),
+  price: import_zod3.z.number(),
+  marketCap: import_zod3.z.number().nullable(),
+  volume: import_zod3.z.number().nullable()
+});
+var PriceHistoryResponse = import_zod3.z.array(PricePoint);
+var PriceAtDateBody = import_zod3.z.object({
+  tokenId: import_zod3.z.string().min(1).describe("CoinGecko token ID."),
+  date: import_zod3.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Snapshot date in `YYYY-MM-DD` format (UTC). CoinGecko returns the daily close + cap + volume.")
+});
+var PriceSnapshot = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  symbol: import_zod3.z.string(),
+  date: import_zod3.z.string(),
+  price: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()),
+  marketCap: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()),
+  volume: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number())
+});
+
+// src/coinglass/schemas.ts
+var schemas_exports4 = {};
+__export(schemas_exports4, {
+  ExchangePairItem: () => ExchangePairItem,
+  ExchangePairsBody: () => ExchangePairsBody,
+  ExchangePairsResponse: () => ExchangePairsResponse,
+  FundingRateHistoryBody: () => FundingRateHistoryBody,
+  FundingRateItem: () => FundingRateItem,
+  FundingRatesBody: () => FundingRatesBody,
+  FundingRatesResponse: () => FundingRatesResponse,
+  LiquidationByExchangeItem: () => LiquidationByExchangeItem,
+  LiquidationHistoryBody: () => LiquidationHistoryBody,
+  LiquidationHistoryItem: () => LiquidationHistoryItem,
+  LiquidationHistoryResponse: () => LiquidationHistoryResponse,
+  LiquidationItem: () => LiquidationItem,
+  LiquidationsBody: () => LiquidationsBody,
+  LiquidationsByExchangeBody: () => LiquidationsByExchangeBody,
+  LiquidationsByExchangeResponse: () => LiquidationsByExchangeResponse,
+  LiquidationsResponse: () => LiquidationsResponse,
+  LongShortExchangeItem: () => LongShortExchangeItem,
+  LongShortRatioBody: () => LongShortRatioBody,
+  LongShortRatioHistoryBody: () => LongShortRatioHistoryBody,
+  LongShortRatioHistoryItem: () => LongShortRatioHistoryItem,
+  LongShortRatioHistoryResponse: () => LongShortRatioHistoryResponse,
+  LongShortRatioResponse: () => LongShortRatioResponse,
+  OhlcCandle: () => OhlcCandle,
+  OhlcCandleResponse: () => OhlcCandleResponse,
+  OpenInterestBody: () => OpenInterestBody,
+  OpenInterestHistoryBody: () => OpenInterestHistoryBody,
+  OpenInterestItem: () => OpenInterestItem,
+  OpenInterestResponse: () => OpenInterestResponse,
+  SupportedListResponse: () => SupportedListResponse
+});
+var import_zod4 = require("zod");
+var symbol = import_zod4.z.string().transform((s) => s.toUpperCase()).describe("Coin symbol, uppercased (e.g. `BTC`, `ETH`).");
+var intervalEnum = import_zod4.z.enum(["1m", "3m", "5m", "15m", "30m", "1h", "4h", "6h", "8h", "12h", "1d", "1w"]).default("1d").describe("Candle interval for the historical series.");
+var rangeEnum = import_zod4.z.enum(["4h", "6h", "8h", "12h", "1d", "1w"]).default("4h").describe("Aggregation window for the snapshot.");
+var FundingRatesBody = import_zod4.z.object({
+  symbol: symbol.optional()
+});
+var FundingRateItem = import_zod4.z.object({
+  symbol: import_zod4.z.string(),
+  exchange: import_zod4.z.string(),
+  fundingRate: import_zod4.z.number().nullable(),
+  fundingRateInterval: import_zod4.z.number().nullable(),
+  nextFundingTime: import_zod4.z.number().nullable()
+});
+var FundingRatesResponse = import_zod4.z.array(FundingRateItem);
+var OpenInterestBody = import_zod4.z.object({ symbol });
+var OpenInterestItem = import_zod4.z.object({
+  exchange: import_zod4.z.string(),
+  symbol: import_zod4.z.string(),
+  openInterestUsd: import_zod4.z.number().nullable(),
+  openInterestQuantity: import_zod4.z.number().nullable(),
+  coinMarginUsd: import_zod4.z.number().nullable(),
+  stablecoinMarginUsd: import_zod4.z.number().nullable(),
+  changePercent5m: import_zod4.z.number().nullable(),
+  changePercent15m: import_zod4.z.number().nullable(),
+  changePercent30m: import_zod4.z.number().nullable(),
+  changePercent1h: import_zod4.z.number().nullable(),
+  changePercent4h: import_zod4.z.number().nullable(),
+  changePercent24h: import_zod4.z.number().nullable()
+});
+var OpenInterestResponse = import_zod4.z.array(OpenInterestItem);
+var LiquidationsBody = import_zod4.z.object({
+  symbol: symbol.optional()
+});
+var LiquidationItem = import_zod4.z.object({
+  symbol: import_zod4.z.string(),
+  liquidationUsd24h: import_zod4.z.number().nullable(),
+  longLiquidationUsd24h: import_zod4.z.number().nullable(),
+  shortLiquidationUsd24h: import_zod4.z.number().nullable(),
+  liquidationUsd12h: import_zod4.z.number().nullable(),
+  longLiquidationUsd12h: import_zod4.z.number().nullable(),
+  shortLiquidationUsd12h: import_zod4.z.number().nullable(),
+  liquidationUsd4h: import_zod4.z.number().nullable(),
+  longLiquidationUsd4h: import_zod4.z.number().nullable(),
+  shortLiquidationUsd4h: import_zod4.z.number().nullable(),
+  liquidationUsd1h: import_zod4.z.number().nullable(),
+  longLiquidationUsd1h: import_zod4.z.number().nullable(),
+  shortLiquidationUsd1h: import_zod4.z.number().nullable()
+});
+var LiquidationsResponse = import_zod4.z.array(LiquidationItem);
+var LongShortRatioBody = import_zod4.z.object({
+  symbol: symbol.default("BTC"),
+  range: rangeEnum
+});
+var LongShortExchangeItem = import_zod4.z.object({
+  exchange: import_zod4.z.string(),
+  buyRatio: import_zod4.z.number().nullable(),
+  sellRatio: import_zod4.z.number().nullable(),
+  buyVolUsd: import_zod4.z.number().nullable(),
+  sellVolUsd: import_zod4.z.number().nullable()
+});
+var LongShortRatioResponse = import_zod4.z.object({
+  symbol: import_zod4.z.string(),
+  buyRatio: import_zod4.z.number().nullable(),
+  sellRatio: import_zod4.z.number().nullable(),
+  buyVolUsd: import_zod4.z.number().nullable(),
+  sellVolUsd: import_zod4.z.number().nullable(),
+  exchanges: import_zod4.z.array(LongShortExchangeItem)
+});
+var SupportedListResponse = import_zod4.z.array(import_zod4.z.string());
+var ExchangePairsBody = import_zod4.z.object({
+  symbol: symbol.optional(),
+  exchange: import_zod4.z.string().optional().describe("Filter to a single exchange (e.g. `Binance`). Returns all when omitted.")
+});
+var ExchangePairItem = import_zod4.z.object({
+  exchange: import_zod4.z.string(),
+  instrumentId: import_zod4.z.string(),
+  baseAsset: import_zod4.z.string(),
+  quoteAsset: import_zod4.z.string(),
+  settlementCurrency: import_zod4.z.string(),
+  maxLeverage: import_zod4.z.number().nullable(),
+  fundingInterval: import_zod4.z.number().nullable()
+});
+var ExchangePairsResponse = import_zod4.z.array(ExchangePairItem);
+var LiquidationsByExchangeBody = import_zod4.z.object({
+  symbol: symbol.default("BTC"),
+  range: rangeEnum
+});
+var LiquidationByExchangeItem = import_zod4.z.object({
+  exchange: import_zod4.z.string(),
+  liquidationUsd: import_zod4.z.number().nullable(),
+  longLiquidationUsd: import_zod4.z.number().nullable(),
+  shortLiquidationUsd: import_zod4.z.number().nullable()
+});
+var LiquidationsByExchangeResponse = import_zod4.z.array(LiquidationByExchangeItem);
+var historyBody = import_zod4.z.object({
+  exchange: import_zod4.z.string().default("Binance").describe("Exchange to pull historical data from."),
+  symbol: symbol.default("BTCUSDT"),
+  interval: intervalEnum,
+  limit: import_zod4.z.number().int().min(1).max(4500).default(100).describe("Number of historical points to return (1\u20134500)."),
+  startTime: import_zod4.z.number().optional().describe("Unix epoch ms \u2014 start of the time window. Omit to use `limit` newest points."),
+  endTime: import_zod4.z.number().optional().describe("Unix epoch ms \u2014 end of the time window.")
+});
+var FundingRateHistoryBody = historyBody;
+var OpenInterestHistoryBody = historyBody;
+var LiquidationHistoryBody = historyBody;
+var LongShortRatioHistoryBody = historyBody;
+var OhlcCandle = import_zod4.z.object({
+  time: import_zod4.z.number(),
+  open: import_zod4.z.number(),
+  high: import_zod4.z.number(),
+  low: import_zod4.z.number(),
+  close: import_zod4.z.number()
+});
+var OhlcCandleResponse = import_zod4.z.array(OhlcCandle);
+var LiquidationHistoryItem = import_zod4.z.object({
+  time: import_zod4.z.number(),
+  longLiquidationUsd: import_zod4.z.number(),
+  shortLiquidationUsd: import_zod4.z.number()
+});
+var LiquidationHistoryResponse = import_zod4.z.array(LiquidationHistoryItem);
+var LongShortRatioHistoryItem = import_zod4.z.object({
+  time: import_zod4.z.number(),
+  longPercent: import_zod4.z.number(),
+  shortPercent: import_zod4.z.number(),
+  longShortRatio: import_zod4.z.number()
+});
+var LongShortRatioHistoryResponse = import_zod4.z.array(LongShortRatioHistoryItem);
+
+// src/composite/schemas.ts
+var schemas_exports5 = {};
+__export(schemas_exports5, {
+  AlphaRadarBody: () => AlphaRadarBody,
+  AlphaRadarComponent: () => AlphaRadarComponent,
+  AlphaRadarResponse: () => AlphaRadarResponse,
+  HealthResponse: () => HealthResponse,
+  MarketSnapshotBody: () => MarketSnapshotBody,
+  MarketSnapshotResponse: () => MarketSnapshotResponse,
+  SignalLabel: () => SignalLabel,
+  WalletXrayBody: () => WalletXrayBody,
+  WalletXrayResponse: () => WalletXrayResponse
+});
+var import_zod5 = require("zod");
+var MarketSnapshotBody = import_zod5.z.object({
+  coingeckoId: import_zod5.z.string().min(1).describe("CoinGecko token ID for the price + market-cap component (e.g. `bitcoin`)."),
+  coinglassSymbol: import_zod5.z.string().min(1).describe("CoinGlass coin symbol for the funding + open-interest component (e.g. `BTC`).")
+});
+var MarketSnapshotResponse = import_zod5.z.object({
+  token: import_zod5.z.string(),
+  price: import_zod5.z.object({
+    usd: import_zod5.z.number().nullable(),
+    change24h: import_zod5.z.number().nullable(),
+    marketCap: import_zod5.z.number().nullable(),
+    volume24h: import_zod5.z.number().nullable()
+  }),
+  fearGreed: import_zod5.z.object({
+    value: import_zod5.z.number().nullable(),
+    classification: import_zod5.z.string().nullable()
+  }),
+  funding: import_zod5.z.object({
+    rates: import_zod5.z.array(import_zod5.z.object({ exchange: import_zod5.z.string(), rate: import_zod5.z.number().nullable() }))
+  }).nullable(),
+  openInterest: import_zod5.z.object({
+    totalUsd: import_zod5.z.number().nullable(),
+    byExchange: import_zod5.z.array(import_zod5.z.object({ exchange: import_zod5.z.string(), usd: import_zod5.z.number().nullable() }))
+  }).nullable()
+});
+var AlphaRadarBody = import_zod5.z.object({
+  symbol: import_zod5.z.string().min(1).describe("Coin symbol to score across the alpha-radar signal components (e.g. `BTC`).")
+});
+var SignalLabel = import_zod5.z.enum([
+  "very_bearish",
+  "bearish",
+  "neutral",
+  "bullish",
+  "very_bullish"
+]);
+var AlphaRadarComponent = import_zod5.z.object({
+  score: import_zod5.z.number(),
+  weight: import_zod5.z.number(),
+  signal: SignalLabel
+}).catchall(import_zod5.z.unknown());
+var AlphaRadarResponse = import_zod5.z.object({
+  symbol: import_zod5.z.string(),
+  timestamp: import_zod5.z.string(),
+  score: import_zod5.z.number(),
+  signal: SignalLabel,
+  componentsUsed: import_zod5.z.number(),
+  components: import_zod5.z.record(import_zod5.z.string(), AlphaRadarComponent),
+  errors: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()).optional()
+});
+var WalletXrayBody = import_zod5.z.object({
+  address: import_zod5.z.string().min(1).describe("Wallet address to analyze (EVM `0x\u2026` or chain-native format)."),
+  chain: import_zod5.z.string().optional().describe("Chain name to scope the analysis (e.g. `eth`, `base`, `polygon`). Defaults to Ethereum mainnet.")
+});
+var WalletXrayResponse = import_zod5.z.object({
+  address: import_zod5.z.string(),
+  chain: import_zod5.z.string(),
+  profile: import_zod5.z.object({
+    tag: import_zod5.z.string(),
+    netWorthUsd: import_zod5.z.number(),
+    tokenCount: import_zod5.z.number(),
+    nftCount: import_zod5.z.number(),
+    defiPositionCount: import_zod5.z.number(),
+    recentTransferCount: import_zod5.z.number()
+  }),
+  topHoldings: import_zod5.z.array(import_zod5.z.unknown()),
+  recentActivity: import_zod5.z.object({
+    totalTransfers: import_zod5.z.number(),
+    inflows: import_zod5.z.number(),
+    outflows: import_zod5.z.number(),
+    recentInflows: import_zod5.z.array(import_zod5.z.unknown()),
+    recentOutflows: import_zod5.z.array(import_zod5.z.unknown())
+  }),
+  defiPositions: import_zod5.z.array(import_zod5.z.unknown()),
+  nftSummary: import_zod5.z.object({
+    total: import_zod5.z.number(),
+    topCollections: import_zod5.z.array(import_zod5.z.object({ name: import_zod5.z.string(), count: import_zod5.z.number() }))
+  }),
+  errors: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string().nullable())
+});
+var HealthResponse = import_zod5.z.object({
+  status: import_zod5.z.enum(["ok", "degraded"]),
+  uptime: import_zod5.z.number(),
+  redis: import_zod5.z.boolean(),
+  rateLimit: import_zod5.z.object({
+    limit: import_zod5.z.number(),
+    windowMs: import_zod5.z.number(),
+    used: import_zod5.z.number(),
+    remaining: import_zod5.z.number(),
+    clientIp: import_zod5.z.string()
+  }),
+  services: import_zod5.z.array(
+    import_zod5.z.object({
+      name: import_zod5.z.string(),
+      status: import_zod5.z.enum(["ok", "error"]),
+      latencyMs: import_zod5.z.number(),
+      error: import_zod5.z.string().optional()
+    })
+  )
+});
+
+// src/cryptonews/schemas.ts
+var schemas_exports6 = {};
+__export(schemas_exports6, {
+  NewsArticle: () => NewsArticle,
+  NewsBody: () => NewsBody,
+  NewsResponse: () => NewsResponse,
+  SentimentBody: () => SentimentBody,
+  SentimentItem: () => SentimentItem,
+  SentimentResponse: () => SentimentResponse,
+  TrendingQuery: () => TrendingQuery,
+  TrendingResponse: () => TrendingResponse2,
+  TrendingTicker: () => TrendingTicker
+});
+var import_zod6 = require("zod");
+var NewsBody = import_zod6.z.object({
+  tickers: import_zod6.z.string().optional().describe("Comma-separated tickers to filter by (e.g. `BTC,ETH`). Omit for the full feed."),
+  items: import_zod6.z.number().int().min(1).max(100).optional().default(10).describe("Articles per page (1\u2013100)."),
+  page: import_zod6.z.number().int().min(1).optional().default(1).describe("1-based page number for pagination."),
+  sentiment: import_zod6.z.enum(["positive", "negative", "neutral"]).optional().describe("Filter to articles with this sentiment classification."),
+  topic: import_zod6.z.string().optional().describe("Filter by topic tag (e.g. `regulation`, `mining`, `defi`)."),
+  source: import_zod6.z.string().optional().describe("Filter by news outlet (e.g. `coindesk`, `cointelegraph`)."),
+  date: import_zod6.z.string().optional().describe(
+    "Date filter. Accepts presets (`today`, `last7days`, `last30days`) or `MMDDYYYY-MMDDYYYY` ranges."
+  ),
+  sort: import_zod6.z.enum(["rank", "date"]).optional().describe("Sort order \u2014 `rank` for relevance, `date` for newest first.")
+});
+var NewsArticle = import_zod6.z.object({
+  title: import_zod6.z.string(),
+  text: import_zod6.z.string(),
+  url: import_zod6.z.string(),
+  imageUrl: import_zod6.z.string().nullable(),
+  date: import_zod6.z.string(),
+  source: import_zod6.z.string(),
+  sentiment: import_zod6.z.string(),
+  tickers: import_zod6.z.array(import_zod6.z.string()),
+  topics: import_zod6.z.array(import_zod6.z.string()),
+  type: import_zod6.z.string()
+});
+var NewsResponse = import_zod6.z.object({
+  articles: import_zod6.z.array(NewsArticle),
+  totalPages: import_zod6.z.number().nullable()
+});
+var SentimentBody = import_zod6.z.object({
+  tickers: import_zod6.z.string().min(1).describe("Comma-separated tickers to score (e.g. `BTC,ETH,SOL`)."),
+  date: import_zod6.z.string().default("last30days").refine(
+    (v) => /^(today|yesterday|last7days|last30days|yeartodate)$/.test(v) || /^\d{8}-(\d{8}|today)$/.test(v)
+  ).describe(
+    "Date window. Presets: `today`, `yesterday`, `last7days`, `last30days`, `yeartodate`. Or a custom `MMDDYYYY-MMDDYYYY` range (or `MMDDYYYY-today`)."
+  )
+});
+var SentimentItem = import_zod6.z.object({
+  ticker: import_zod6.z.string(),
+  sentiment: import_zod6.z.string(),
+  sentimentScore: import_zod6.z.number().nullable(),
+  positive: import_zod6.z.number(),
+  negative: import_zod6.z.number(),
+  neutral: import_zod6.z.number()
+});
+var SentimentResponse = import_zod6.z.array(SentimentItem);
+var TrendingQuery = import_zod6.z.object({
+  date: import_zod6.z.string().optional().describe("Date window \u2014 same format as the sentiment endpoint. Defaults to today.")
+});
+var TrendingTicker = import_zod6.z.object({
+  ticker: import_zod6.z.string(),
+  name: import_zod6.z.string(),
+  totalMentions: import_zod6.z.number(),
+  positiveMentions: import_zod6.z.number(),
+  negativeMentions: import_zod6.z.number(),
+  neutralMentions: import_zod6.z.number(),
+  sentimentScore: import_zod6.z.number().nullable()
+});
+var TrendingResponse2 = import_zod6.z.array(TrendingTicker);
+
+// src/defillama/schemas.ts
+var schemas_exports7 = {};
+__export(schemas_exports7, {
+  BridgeItem: () => BridgeItem,
+  BridgesBody: () => BridgesBody,
+  BridgesListResponse: () => BridgesListResponse,
+  BridgesResponse: () => BridgesResponse,
+  DexVolumesBody: () => DexVolumesBody,
+  DexVolumesResponse: () => DexVolumesResponse,
+  ProtocolFeesBody: () => ProtocolFeesBody,
+  ProtocolFeesResponse: () => ProtocolFeesResponse,
+  StablecoinsBody: () => StablecoinsBody,
+  StablecoinsResponse: () => StablecoinsResponse,
+  TvlBody: () => TvlBody,
+  TvlDataPoint: () => TvlDataPoint,
+  TvlResponse: () => TvlResponse,
+  YieldPoolItem: () => YieldPoolItem,
+  YieldsBody: () => YieldsBody,
+  YieldsResponse: () => YieldsResponse
+});
+var import_zod7 = require("zod");
+var TvlBody = import_zod7.z.object({
+  protocol: import_zod7.z.string().optional().describe("DeFiLlama protocol slug (e.g. `aave-v3`). Mutually exclusive with `chain`."),
+  chain: import_zod7.z.string().optional().describe("Chain name (e.g. `Ethereum`, `Base`). Returns the chain's aggregate TVL."),
+  historical: import_zod7.z.boolean().default(false).describe("Include the full daily TVL time-series in the response.")
+}).refine((d) => d.protocol || d.chain, "Provide either 'protocol' or 'chain'");
+var TvlDataPoint = import_zod7.z.object({ date: import_zod7.z.number(), tvl: import_zod7.z.number() });
+var TvlResponse = import_zod7.z.object({
+  type: import_zod7.z.enum(["protocol", "chain"]),
+  name: import_zod7.z.string(),
+  currentTvl: import_zod7.z.number().nullable(),
+  history: import_zod7.z.array(TvlDataPoint).nullable()
+});
+var YieldsBody = import_zod7.z.object({
+  chain: import_zod7.z.string().optional().describe("Filter pools to a single chain."),
+  token: import_zod7.z.string().optional().describe("Filter pools that include this token symbol (e.g. `USDC`)."),
+  protocol: import_zod7.z.string().optional().describe("Filter pools by protocol slug (e.g. `aave-v3`)."),
+  minTvl: import_zod7.z.number().optional().describe("Minimum pool TVL in USD \u2014 drop dust pools below this threshold."),
+  poolId: import_zod7.z.string().optional().describe("Specific DeFiLlama pool ID for a single-pool lookup. Wins over the other filters.")
+});
+var YieldPoolItem = import_zod7.z.object({
+  pool: import_zod7.z.string(),
+  chain: import_zod7.z.string(),
+  project: import_zod7.z.string(),
+  symbol: import_zod7.z.string(),
+  tvlUsd: import_zod7.z.number(),
+  apy: import_zod7.z.number().nullable(),
+  apyBase: import_zod7.z.number().nullable(),
+  apyReward: import_zod7.z.number().nullable(),
+  stablecoin: import_zod7.z.boolean(),
+  exposure: import_zod7.z.string().nullable(),
+  ilRisk: import_zod7.z.string().nullable(),
+  predictions: import_zod7.z.object({
+    predictedClass: import_zod7.z.string().nullable(),
+    binnedConfidence: import_zod7.z.number().nullable()
+  }).nullable()
+});
+var YieldsResponse = import_zod7.z.array(YieldPoolItem);
+var ProtocolFeesBody = import_zod7.z.object({
+  protocol: import_zod7.z.string().min(1).describe("Protocol slug to pull fee/revenue data for."),
+  dataType: import_zod7.z.enum([
+    "dailyFees",
+    "dailyRevenue",
+    "dailyHoldersRevenue",
+    "dailySupplySideRevenue",
+    "dailyBribesRevenue",
+    "dailyTokenTaxes"
+  ]).default("dailyFees").describe("Which fee/revenue stream to fetch. `dailyFees` = total user fees, `dailyRevenue` = protocol's cut.")
+});
+var ProtocolFeesResponse = import_zod7.z.object({
+  name: import_zod7.z.string(),
+  category: import_zod7.z.string().nullable(),
+  chains: import_zod7.z.array(import_zod7.z.string()),
+  total24h: import_zod7.z.number().nullable(),
+  total7d: import_zod7.z.number().nullable(),
+  total30d: import_zod7.z.number().nullable(),
+  totalAllTime: import_zod7.z.number().nullable(),
+  change1d: import_zod7.z.number().nullable(),
+  change7d: import_zod7.z.number().nullable(),
+  change1m: import_zod7.z.number().nullable(),
+  dailyChart: import_zod7.z.array(import_zod7.z.object({ date: import_zod7.z.number(), value: import_zod7.z.number() })).nullable()
+});
+var DexVolumesBody = import_zod7.z.object({
+  protocol: import_zod7.z.string().optional().describe("Single-DEX detail mode (e.g. `uniswap`). Mutually exclusive with `chain`."),
+  chain: import_zod7.z.string().optional().describe("Filter aggregate volume to one chain (e.g. `Ethereum`). Omit both for the global summary.")
+});
+var DexVolumesResponse = import_zod7.z.union([
+  import_zod7.z.object({
+    total24h: import_zod7.z.number(),
+    total7d: import_zod7.z.number(),
+    protocols: import_zod7.z.array(import_zod7.z.unknown())
+  }).passthrough(),
+  import_zod7.z.object({
+    name: import_zod7.z.string(),
+    chains: import_zod7.z.array(import_zod7.z.string())
+  }).passthrough()
+]);
+var StablecoinsBody = import_zod7.z.object({
+  chain: import_zod7.z.string().optional().describe("Filter circulating-supply data to one chain."),
+  stablecoinId: import_zod7.z.string().optional().describe("DeFiLlama stablecoin ID for a single-coin lookup (e.g. `1` for USDT).")
+});
+var StablecoinsResponse = import_zod7.z.unknown();
+var BridgesBody = import_zod7.z.object({
+  chain: import_zod7.z.string().optional().describe("Filter bridge volume to one chain."),
+  bridgeId: import_zod7.z.number().optional().describe("DeFiLlama numeric bridge ID for a single-bridge detail view.")
+});
+var BridgeItem = import_zod7.z.object({
+  id: import_zod7.z.number(),
+  name: import_zod7.z.string(),
+  displayName: import_zod7.z.string(),
+  volumePrevDay: import_zod7.z.number(),
+  last24hVolume: import_zod7.z.number(),
+  weeklyVolume: import_zod7.z.number().nullable(),
+  monthlyVolume: import_zod7.z.number().nullable(),
+  chains: import_zod7.z.array(import_zod7.z.string()).optional()
+});
+var BridgesResponse = import_zod7.z.unknown();
+var BridgesListResponse = import_zod7.z.array(BridgeItem);
+
+// src/geckoterminal/schemas.ts
+var schemas_exports8 = {};
+__export(schemas_exports8, {
+  PoolOhlcvBody: () => PoolOhlcvBody,
+  PoolOhlcvCandle: () => PoolOhlcvCandle,
+  PoolOhlcvResponse: () => PoolOhlcvResponse,
+  PoolTrade: () => PoolTrade,
+  PoolTradesBody: () => PoolTradesBody,
+  PoolTradesResponse: () => PoolTradesResponse,
+  TokenInfoBody: () => TokenInfoBody2,
+  TokenInfoItem: () => TokenInfoItem,
+  TokenInfoResponse: () => TokenInfoResponse,
+  TokenPool: () => TokenPool,
+  TokenPoolsBody: () => TokenPoolsBody,
+  TokenPoolsResponse: () => TokenPoolsResponse,
+  TrendingPool: () => TrendingPool,
+  TrendingPoolsResponse: () => TrendingPoolsResponse
+});
+var import_zod8 = require("zod");
+var Network = import_zod8.z.string().min(1).describe("GeckoTerminal network slug (e.g. `eth`, `bsc`, `base`, `arbitrum`).");
+var TokenPoolsBody = import_zod8.z.object({
+  network: Network,
+  tokenAddress: import_zod8.z.string().min(1).describe("Token contract address on `network`. Returns the pools that include it."),
+  page: import_zod8.z.number().int().min(1).optional().default(1).describe("1-based page number \u2014 GeckoTerminal returns up to 20 pools per page.")
+});
+var TokenPool = import_zod8.z.object({
+  poolAddress: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  dex: import_zod8.z.string(),
+  priceUsd: import_zod8.z.string().nullable(),
+  priceNative: import_zod8.z.string().nullable(),
+  volume24h: import_zod8.z.number().nullable(),
+  reserveUsd: import_zod8.z.number().nullable(),
+  priceChangePercentage: import_zod8.z.object({
+    m5: import_zod8.z.string().nullable(),
+    h1: import_zod8.z.string().nullable(),
+    h6: import_zod8.z.string().nullable(),
+    h24: import_zod8.z.string().nullable()
+  }),
+  transactions: import_zod8.z.object({
+    buys24h: import_zod8.z.number().nullable(),
+    sells24h: import_zod8.z.number().nullable()
+  })
+});
+var TokenPoolsResponse = import_zod8.z.array(TokenPool);
+var PoolOhlcvBody = import_zod8.z.object({
+  network: Network,
+  poolAddress: import_zod8.z.string().min(1).describe("DEX pool contract address on `network`."),
+  timeframe: import_zod8.z.enum(["day", "hour", "minute"]).optional().default("day").describe("Candle resolution unit."),
+  aggregate: import_zod8.z.number().int().min(1).optional().describe("Bucket multiple `timeframe` units into one candle (e.g. `timeframe=hour, aggregate=4` \u2192 4-hour candles)."),
+  limit: import_zod8.z.number().int().min(1).max(1e3).optional().default(100).describe("Number of candles to return (1\u20131000)."),
+  beforeTimestamp: import_zod8.z.number().optional().describe("Unix epoch seconds \u2014 return candles strictly before this time. Use for pagination backwards in history.")
+});
+var PoolOhlcvCandle = import_zod8.z.object({
+  timestamp: import_zod8.z.number(),
+  open: import_zod8.z.number(),
+  high: import_zod8.z.number(),
+  low: import_zod8.z.number(),
+  close: import_zod8.z.number(),
+  volumeUsd: import_zod8.z.number()
+});
+var PoolOhlcvResponse = import_zod8.z.array(PoolOhlcvCandle);
+var PoolTradesBody = import_zod8.z.object({
+  network: Network,
+  poolAddress: import_zod8.z.string().min(1).describe("DEX pool contract address on `network`."),
+  tradeVolumeInUsdGreaterThan: import_zod8.z.number().optional().describe("Drop trades below this USD-equivalent volume threshold. Useful for filtering dust/wash trades.")
+});
+var PoolTrade = import_zod8.z.object({
+  blockTimestamp: import_zod8.z.string(),
+  txHash: import_zod8.z.string(),
+  kind: import_zod8.z.string(),
+  volumeUsd: import_zod8.z.string().nullable(),
+  fromTokenAmount: import_zod8.z.string(),
+  toTokenAmount: import_zod8.z.string(),
+  fromTokenAddress: import_zod8.z.string(),
+  toTokenAddress: import_zod8.z.string(),
+  priceFromInUsd: import_zod8.z.string().nullable(),
+  priceToInUsd: import_zod8.z.string().nullable(),
+  txFromAddress: import_zod8.z.string()
+});
+var PoolTradesResponse = import_zod8.z.array(PoolTrade);
+var TrendingPool = import_zod8.z.object({
+  poolAddress: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  network: import_zod8.z.string(),
+  dex: import_zod8.z.string(),
+  priceUsd: import_zod8.z.string().nullable(),
+  priceChangeH24: import_zod8.z.string().nullable(),
+  volume24h: import_zod8.z.number().nullable(),
+  reserveUsd: import_zod8.z.number().nullable()
+});
+var TrendingPoolsResponse = import_zod8.z.array(TrendingPool);
+var TokenInfoBody2 = import_zod8.z.object({
+  network: Network,
+  addresses: import_zod8.z.array(import_zod8.z.string().min(1)).min(1).max(30).describe("Token contract addresses on `network` (1\u201330 per request). Batched lookup."),
+  includeTopPools: import_zod8.z.boolean().optional().default(true).describe("Include each token's top pools in the response. Set false to slim down the payload.")
+});
+var TokenInfoItem = import_zod8.z.object({
+  address: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  symbol: import_zod8.z.string(),
+  decimals: import_zod8.z.number(),
+  totalSupply: import_zod8.z.string().nullable(),
+  priceUsd: import_zod8.z.string().nullable(),
+  marketCapUsd: import_zod8.z.string().nullable(),
+  fdvUsd: import_zod8.z.string().nullable(),
+  imageUrl: import_zod8.z.string().nullable(),
+  coingeckoCoinId: import_zod8.z.string().nullable(),
+  volume24h: import_zod8.z.number().nullable(),
+  topPools: import_zod8.z.array(import_zod8.z.object({ address: import_zod8.z.string(), name: import_zod8.z.string(), dex: import_zod8.z.string() }))
+});
+var TokenInfoResponse = import_zod8.z.array(TokenInfoItem);
+
+// src/kaito/schemas.ts
+var schemas_exports9 = {};
+__export(schemas_exports9, {
+  AdvancedSearchBody: () => AdvancedSearchBody,
+  EngagementBody: () => EngagementBody,
+  EntitiesQuery: () => EntitiesQuery,
+  EventsBody: () => EventsBody,
+  FeedsBody: () => FeedsBody,
+  KaitoResponse: () => KaitoResponse,
+  KolMindshareBody: () => KolMindshareBody,
+  MarketSmartFollowingBody: () => MarketSmartFollowingBody,
+  MentionsBody: () => MentionsBody,
+  MindshareArenaBody: () => MindshareArenaBody,
+  MindshareBody: () => MindshareBody,
+  MindshareDeltaBody: () => MindshareDeltaBody,
+  MindshareNarrativeBody: () => MindshareNarrativeBody,
+  NarrativesQuery: () => NarrativesQuery,
+  SearchBody: () => SearchBody2,
+  SentimentBody: () => SentimentBody2,
+  SmartFollowersBody: () => SmartFollowersBody,
+  SmartFollowingBody: () => SmartFollowingBody,
+  TweetEngagementBody: () => TweetEngagementBody,
+  TwitterUserMetadataBody: () => TwitterUserMetadataBody
+});
+var import_zod9 = require("zod");
+var dateString = (note) => import_zod9.z.string().optional().describe(note);
+var sortOrder = import_zod9.z.enum(["asc", "desc"]).optional().describe("Sort direction for the result list.");
+var EntitiesQuery = import_zod9.z.object({
+  query: import_zod9.z.string().optional().describe("Free-text filter for entity names. Omit to list all."),
+  limit: import_zod9.z.coerce.number().int().min(1).max(100).optional().describe("Max entities to return (1\u2013100).")
+});
+var NarrativesQuery = import_zod9.z.object({
+  query: import_zod9.z.string().optional().describe("Free-text filter for narrative names. Omit to list all."),
+  limit: import_zod9.z.coerce.number().int().min(1).max(100).optional().describe("Max narratives to return (1\u2013100).")
+});
+var SearchBody2 = import_zod9.z.object({
+  query: import_zod9.z.string().min(1).describe("Free-text search query across tweets, narratives, and entities."),
+  size: import_zod9.z.number().int().min(1).max(50).optional().describe("Result page size (1\u201350). Default 10.")
+});
+var AdvancedSearchBody = import_zod9.z.object({
+  tokens: import_zod9.z.string().optional().describe("Comma-separated token symbols to filter tweets to (e.g. `BTC,ETH`)."),
+  keyword: import_zod9.z.string().optional().describe("Keyword filter \u2014 substring-matched against tweet text."),
+  query: import_zod9.z.string().optional().describe("Semantic search query."),
+  usernames: import_zod9.z.string().optional().describe("Comma-separated Twitter usernames to filter to."),
+  sources: import_zod9.z.string().optional().describe("Comma-separated source filters."),
+  min_created_at: dateString("ISO 8601 \u2014 earliest tweet creation time."),
+  max_created_at: dateString("ISO 8601 \u2014 latest tweet creation time."),
+  from: import_zod9.z.number().optional().describe("Result offset for pagination."),
+  size: import_zod9.z.number().optional().describe("Page size."),
+  languages: import_zod9.z.string().optional().describe("Comma-separated language codes (e.g. `en,zh`)."),
+  sort_by: import_zod9.z.enum([
+    "relevance",
+    "created_at",
+    "engagement",
+    "smart_engagement",
+    "author",
+    "length",
+    "bookmark",
+    "sentiment",
+    "views"
+  ]).optional().describe("Field to sort by."),
+  sort_order: sortOrder,
+  tweet_length_type: import_zod9.z.enum(["short", "long", "thread", "article"]).optional().describe("Filter by tweet length category."),
+  tweet_type: import_zod9.z.enum(["tweet", "quote", "reply"]).optional().describe("Filter by tweet shape."),
+  sentiment_type: import_zod9.z.enum(["bullish", "bearish", "neutral"]).optional().describe("Filter by Kaito's sentiment classification."),
+  author_type: import_zod9.z.enum(["Organization", "Individual"]).optional().describe("Filter by author classification."),
+  min_bookmark_count: import_zod9.z.number().optional().describe("Minimum bookmark count threshold."),
+  max_bookmark_count: import_zod9.z.number().optional().describe("Maximum bookmark count threshold."),
+  min_view_count: import_zod9.z.number().optional().describe("Minimum view count threshold."),
+  max_view_count: import_zod9.z.number().optional().describe("Maximum view count threshold."),
+  min_smart_engagement_count: import_zod9.z.number().optional().describe("Minimum smart-follower engagement count."),
+  max_smart_engagement_count: import_zod9.z.number().optional().describe("Maximum smart-follower engagement count."),
+  min_like_count: import_zod9.z.number().optional().describe("Minimum like count threshold."),
+  max_like_count: import_zod9.z.number().optional().describe("Maximum like count threshold."),
+  min_reply_count: import_zod9.z.number().optional().describe("Minimum reply count threshold."),
+  max_reply_count: import_zod9.z.number().optional().describe("Maximum reply count threshold."),
+  min_retweet_count: import_zod9.z.number().optional().describe("Minimum retweet count threshold."),
+  max_retweet_count: import_zod9.z.number().optional().describe("Maximum retweet count threshold."),
+  min_quote_count: import_zod9.z.number().optional().describe("Minimum quote-tweet count threshold."),
+  max_quote_count: import_zod9.z.number().optional().describe("Maximum quote-tweet count threshold.")
+});
+var TweetEngagementBody = import_zod9.z.object({
+  tweet_id: import_zod9.z.string().min(1).describe("Twitter status ID (numeric, as a string).")
+});
+var FeedsBody = import_zod9.z.object({
+  token: import_zod9.z.string().optional().describe("Token symbol to filter feed to (e.g. `BTC`). Omit for all."),
+  min_created_at: dateString("ISO 8601 \u2014 earliest tweet creation time."),
+  max_created_at: dateString("ISO 8601 \u2014 latest tweet creation time."),
+  size: import_zod9.z.number().int().min(1).max(50).optional().describe("Page size (1\u201350).")
+});
+var SentimentBody2 = import_zod9.z.object({
+  token: import_zod9.z.string().min(1).describe("Token symbol to compute sentiment for (e.g. `BTC`)."),
+  start_date: dateString("ISO 8601 \u2014 earliest date in the analysis window."),
+  end_date: dateString("ISO 8601 \u2014 latest date in the analysis window."),
+  adjusted: import_zod9.z.boolean().optional().describe("Apply Kaito's bot/spam adjustment."),
+  average: import_zod9.z.boolean().optional().describe("Return rolling average vs raw daily values."),
+  gaussian: import_zod9.z.boolean().optional().describe("Apply Gaussian smoothing to the time series."),
+  language: import_zod9.z.enum(["all", "en", "zh", "ko", "others"]).optional().describe("Restrict source tweets to one language."),
+  version: import_zod9.z.enum(["2", "3"]).optional().describe("Sentiment model version. Default to v3 (latest).")
+});
+var EngagementBody = import_zod9.z.object({
+  token: import_zod9.z.string().optional().describe("Token symbol filter. Mutually exclusive with `keyword`."),
+  keyword: import_zod9.z.string().optional().describe("Keyword filter. Mutually exclusive with `token`."),
+  start_date: dateString("ISO 8601 \u2014 start date for the engagement window."),
+  end_date: dateString("ISO 8601 \u2014 end date for the engagement window.")
+});
+var MentionsBody = EngagementBody;
+var MindshareBody = import_zod9.z.object({
+  token: import_zod9.z.string().min(1).describe("Token symbol to compute mindshare for."),
+  start_date: dateString("ISO 8601 \u2014 earliest date in the analysis window."),
+  end_date: dateString("ISO 8601 \u2014 latest date in the analysis window."),
+  scope: import_zod9.z.string().optional().describe("Optional scope filter (e.g. narrative or category).")
+});
+var MindshareArenaBody = import_zod9.z.object({
+  duration: import_zod9.z.enum(["all", "24h", "48h", "7d", "30d", "3m", "6m", "12m"]).optional().describe("Mindshare measurement window."),
+  language: import_zod9.z.enum(["all", "en", "zh", "ko", "others"]).optional().describe("Restrict tweets to one language."),
+  categories: import_zod9.z.enum(["EXCHANGE", "INFOMKT"]).optional().describe("Restrict to a single arena category."),
+  pre_tge: import_zod9.z.boolean().optional().describe("Include pre-TGE projects in the leaderboard."),
+  ex_official: import_zod9.z.boolean().optional().describe("Exclude tweets from official project accounts."),
+  weighted: import_zod9.z.boolean().optional().describe("Use Kaito's weighted-by-author-influence score."),
+  nft: import_zod9.z.boolean().optional().describe("Restrict to NFT projects.")
+});
+var MindshareDeltaBody = import_zod9.z.object({
+  duration: import_zod9.z.enum(["24h", "48h", "7d", "30d", "3m", "6m", "12m", "all"]).optional().describe("Window over which to compute the mindshare delta."),
+  sort_type: import_zod9.z.enum(["desc", "asc"]).optional().describe("Sort by largest delta first (`desc`) or smallest (`asc`)."),
+  limit: import_zod9.z.number().int().positive().optional().describe("Max projects to return.")
+});
+var MindshareNarrativeBody = import_zod9.z.object({
+  narrative: import_zod9.z.string().min(1).describe("Narrative slug (e.g. `RWA`, `AI`, `meme`)."),
+  start_date: dateString("ISO 8601 \u2014 earliest date in the analysis window."),
+  end_date: dateString("ISO 8601 \u2014 latest date in the analysis window.")
+});
+var KolMindshareBody = import_zod9.z.object({
+  token: import_zod9.z.string().min(1).describe("Token symbol to attribute KOL mindshare to."),
+  duration: import_zod9.z.enum(["24h", "48h", "7d", "30d", "3m", "6m", "12m", "all"]).optional().describe("KOL mindshare window."),
+  top_n: import_zod9.z.number().int().positive().optional().describe("Top N KOLs to return.")
+});
+var EventsBody = import_zod9.z.object({
+  token: import_zod9.z.string().min(1).describe("Token symbol to filter events for."),
+  start_date: dateString("ISO 8601 \u2014 earliest event date."),
+  end_date: dateString("ISO 8601 \u2014 latest event date."),
+  min_announcement_date: dateString("ISO 8601 \u2014 earliest announcement date."),
+  max_announcement_date: dateString("ISO 8601 \u2014 latest announcement date."),
+  event_types: import_zod9.z.string().optional().describe("Comma-separated event-type filters."),
+  sources: import_zod9.z.string().optional().describe("Comma-separated source filters."),
+  sort_by: import_zod9.z.enum(["event_date", "project_name", "market_cap", "announcement_date"]).optional().describe("Sort field."),
+  sort_order: sortOrder
+});
+var TwitterUserMetadataBody = import_zod9.z.object({
+  user_id: import_zod9.z.string().min(1).describe("Twitter user ID (numeric, as a string).")
+});
+var MarketSmartFollowingBody = import_zod9.z.object({
+  duration: import_zod9.z.enum(["24h", "48h", "7d", "30d", "all_dates"]).optional().describe("Window for the smart-following analysis."),
+  from: import_zod9.z.number().optional().describe("Result offset for pagination."),
+  sort_by: import_zod9.z.enum(["earliest_time", "smart_followers", "followers_change", "change_ratio"]).optional().describe("Sort field."),
+  sort_order: sortOrder,
+  filter_smart_followers_operator: import_zod9.z.enum(["gte", "lte"]).optional().describe("Comparison operator for `filter_smart_followers_value`."),
+  filter_smart_followers_value: import_zod9.z.number().optional().describe("Threshold for smart-follower count filter."),
+  user_status: import_zod9.z.enum(["new", "existing", "all"]).optional().describe("Filter to newly-tracked vs existing users."),
+  user_tag_individual_or_organization: import_zod9.z.enum(["Individual", "Organization", "all"]).optional().describe("Filter by author classification."),
+  user_type: import_zod9.z.enum(["kkol", "non_kkol", "all"]).optional().describe("Restrict to Kaito KOLs (`kkol`), non-KOLs, or both."),
+  user_web3_relevance: import_zod9.z.enum(["relevant", "irrelevant"]).optional().describe("Restrict to web3-relevant users.")
+});
+var SmartFollowersBody = import_zod9.z.object({
+  user_id: import_zod9.z.string().optional().describe("Twitter user ID (numeric, as a string). Provide this OR `username`."),
+  username: import_zod9.z.string().optional().describe("Twitter handle without the `@`. Provide this OR `user_id`."),
+  date: import_zod9.z.string().optional().describe("ISO 8601 date \u2014 pin the smart-follower snapshot."),
+  mode: import_zod9.z.enum(["count", "users"]).optional().describe("`count` returns just the number; `users` returns the full list of follower handles.")
+}).refine((v) => !!(v.user_id || v.username), "user_id or username required");
+var SmartFollowingBody = import_zod9.z.object({
+  user_id: import_zod9.z.string().optional().describe("Twitter user ID (numeric, as a string). Provide this OR `username`."),
+  username: import_zod9.z.string().optional().describe("Twitter handle without the `@`. Provide this OR `user_id`."),
+  category: import_zod9.z.enum(["ALL", "Organization", "Individual"]).optional().describe("Restrict the followed-by-smart-followers list to a category.")
+}).refine((v) => !!(v.user_id || v.username), "user_id or username required");
+var KaitoResponse = import_zod9.z.unknown();
+
+// src/moralis/schemas.ts
+var schemas_exports10 = {};
+__export(schemas_exports10, {
+  DefiPosition: () => DefiPosition,
+  DefiPositionsBody: () => DefiPositionsBody,
+  DefiPositionsResponse: () => DefiPositionsResponse,
+  NftHoldingsBody: () => NftHoldingsBody,
+  NftHoldingsResponse: () => NftHoldingsResponse,
+  NftItem: () => NftItem,
+  TokenTransfer: () => TokenTransfer,
+  TransfersBody: () => TransfersBody,
+  TransfersResponse: () => TransfersResponse,
+  WalletBody: () => WalletBody,
+  WalletResponse: () => WalletResponse,
+  WalletTokenBalance: () => WalletTokenBalance
+});
+var import_zod10 = require("zod");
+var CHAIN_NAMES = {
+  eth: "0x1",
+  ethereum: "0x1",
+  bsc: "0x38",
+  bnb: "0x38",
+  polygon: "0x89",
+  matic: "0x89",
+  arbitrum: "0xa4b1",
+  optimism: "0xa",
+  base: "0x2105",
+  avalanche: "0xa86a",
+  avax: "0xa86a",
+  fantom: "0xfa",
+  ftm: "0xfa",
+  linea: "0xe708"
+};
+var evmChainId = import_zod10.z.string().default("0x1").transform((val) => CHAIN_NAMES[val.toLowerCase()] ?? val).describe(
+  "EVM chain \u2014 accepts a friendly name (`eth`, `base`, `polygon`, `arbitrum`, \u2026) or a hex chain id (`0x1`, `0x2105`, \u2026). Defaults to Ethereum mainnet."
+);
+var evmAddress = import_zod10.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("EVM-style 0x-prefixed 40-hex-char address.");
+var WalletBody = import_zod10.z.object({
+  address: evmAddress,
+  chain: evmChainId.optional(),
+  toBlock: import_zod10.z.number().int().optional().describe("Snapshot the wallet at this block height. Omit for the current head.")
+});
+var WalletTokenBalance = import_zod10.z.object({
+  tokenAddress: import_zod10.z.string().nullable(),
+  name: import_zod10.z.string(),
+  symbol: import_zod10.z.string(),
+  decimals: import_zod10.z.number(),
+  balance: import_zod10.z.string(),
+  balanceFormatted: import_zod10.z.string(),
+  usdPrice: import_zod10.z.number().nullable(),
+  usdValue: import_zod10.z.number().nullable(),
+  portfolioPercentage: import_zod10.z.number(),
+  nativeToken: import_zod10.z.boolean(),
+  logo: import_zod10.z.string().nullable()
+});
+var WalletResponse = import_zod10.z.object({
+  address: import_zod10.z.string(),
+  totalNetworthUsd: import_zod10.z.string(),
+  chains: import_zod10.z.array(
+    import_zod10.z.object({
+      chain: import_zod10.z.string(),
+      networthUsd: import_zod10.z.string(),
+      nativeBalanceFormatted: import_zod10.z.string(),
+      tokenBalanceUsd: import_zod10.z.string()
+    })
+  ),
+  tokens: import_zod10.z.array(WalletTokenBalance)
+});
+var TransfersBody = import_zod10.z.object({
+  address: evmAddress,
+  chain: evmChainId.optional(),
+  limit: import_zod10.z.number().max(100).default(50).describe("Transfers per page (max 100)."),
+  fromDate: import_zod10.z.string().optional().describe("ISO 8601 (or YYYY-MM-DD) start date \u2014 only return transfers after this date."),
+  toDate: import_zod10.z.string().optional().describe("ISO 8601 (or YYYY-MM-DD) end date \u2014 only return transfers before this date."),
+  cursor: import_zod10.z.string().optional().describe("Opaque pagination cursor from the previous response. Omit for page 1.")
+});
+var TokenTransfer = import_zod10.z.object({
+  tokenAddress: import_zod10.z.string(),
+  tokenName: import_zod10.z.string().nullable(),
+  tokenSymbol: import_zod10.z.string().nullable(),
+  tokenDecimals: import_zod10.z.number(),
+  fromAddress: import_zod10.z.string(),
+  toAddress: import_zod10.z.string(),
+  value: import_zod10.z.string(),
+  valueFormatted: import_zod10.z.string().nullable(),
+  blockTimestamp: import_zod10.z.string(),
+  blockNumber: import_zod10.z.string(),
+  transactionHash: import_zod10.z.string()
+});
+var TransfersResponse = import_zod10.z.object({
+  transfers: import_zod10.z.array(TokenTransfer),
+  cursor: import_zod10.z.string().nullable()
+});
+var DefiPositionsBody = import_zod10.z.object({
+  address: evmAddress,
+  chain: evmChainId.optional()
+});
+var DefiPosition = import_zod10.z.object({
+  protocolName: import_zod10.z.string().nullable(),
+  protocolId: import_zod10.z.string().nullable(),
+  protocolUrl: import_zod10.z.string().nullable(),
+  protocolLogo: import_zod10.z.string().nullable(),
+  label: import_zod10.z.string().nullable(),
+  balanceUsd: import_zod10.z.number().nullable(),
+  totalUnclaimedUsdValue: import_zod10.z.number().nullable(),
+  tokens: import_zod10.z.array(import_zod10.z.unknown())
+});
+var DefiPositionsResponse = import_zod10.z.array(DefiPosition);
+var NftHoldingsBody = import_zod10.z.object({
+  address: evmAddress,
+  chain: evmChainId.optional(),
+  limit: import_zod10.z.number().max(100).default(50).describe("NFTs per page (max 100)."),
+  cursor: import_zod10.z.string().optional().describe("Opaque pagination cursor from the previous response. Omit for page 1.")
+});
+var NftItem = import_zod10.z.object({
+  tokenAddress: import_zod10.z.string(),
+  tokenId: import_zod10.z.string(),
+  contractType: import_zod10.z.string().nullable(),
+  name: import_zod10.z.string().nullable(),
+  symbol: import_zod10.z.string().nullable(),
+  tokenUri: import_zod10.z.string().nullable(),
+  amount: import_zod10.z.number().nullable(),
+  ownerOf: import_zod10.z.string().nullable(),
+  possibleSpam: import_zod10.z.boolean(),
+  metadata: import_zod10.z.unknown().nullable()
+});
+var NftHoldingsResponse = import_zod10.z.object({
+  nfts: import_zod10.z.array(NftItem),
+  cursor: import_zod10.z.string().nullable()
+});
+
+// src/noya/schemas.ts
+var schemas_exports11 = {};
+__export(schemas_exports11, {
+  AnalysisEventHistoryBody: () => AnalysisEventHistoryBody,
+  AnalysisEventsBody: () => AnalysisEventsBody,
+  AnalysisLatestResponse: () => AnalysisLatestResponse,
+  AnalysisMarketHistoryBody: () => AnalysisMarketHistoryBody,
+  AnalysisTopBody: () => AnalysisTopBody,
+  AnalysisVersionsBody: () => AnalysisVersionsBody,
+  CryptoToken: () => CryptoToken,
+  PolymarketByEventBody: () => PolymarketByEventBody,
+  PolymarketEventsBody: () => PolymarketEventsBody,
+  PolymarketFilterBody: () => PolymarketFilterBody,
+  PolymarketFilterResponse: () => PolymarketFilterResponse,
+  PolymarketRecommendationsBody: () => PolymarketRecommendationsBody,
+  PolymarketResponse: () => PolymarketResponse,
+  PolymarketSearchBody: () => PolymarketSearchBody,
+  PolymarketSimilarBody: () => PolymarketSimilarBody,
+  PolymarketTagsBody: () => PolymarketTagsBody,
+  TokenDetailBody: () => TokenDetailBody,
+  TokenScores: () => TokenScores,
+  TokensByVersionBody: () => TokensByVersionBody,
+  TokensRecommendationsBody: () => TokensRecommendationsBody,
+  TokensSearchBody: () => TokensSearchBody,
+  TokensSearchResponse: () => TokensSearchResponse,
+  TokensSimilarBody: () => TokensSimilarBody,
+  TopMarketsByEvBody: () => TopMarketsByEvBody,
+  TopTokensByScoreBody: () => TopTokensByScoreBody,
+  VersionsResponse: () => VersionsResponse
+});
+var import_zod11 = require("zod");
+var TokensSearchBody = import_zod11.z.object({
+  q: import_zod11.z.string().min(1).describe("Free-text search query \u2014 matches token symbol, name, or category."),
+  limit: import_zod11.z.number().int().min(1).max(100).default(10).describe("Max tokens to return (1\u2013100)."),
+  signal: import_zod11.z.string().optional().describe("Filter to tokens with a specific Noya signal (e.g. `strong_buy`)."),
+  risk: import_zod11.z.string().optional().describe("Filter to tokens at a specific risk tier (e.g. `low`, `medium`, `high`)."),
+  minFinalScore: import_zod11.z.number().optional().describe("Minimum AI final score (0\u2013100)."),
+  maxFinalScore: import_zod11.z.number().optional().describe("Maximum AI final score (0\u2013100)."),
+  minMarketCap: import_zod11.z.number().optional().describe("Minimum market cap in USD."),
+  maxMarketCap: import_zod11.z.number().optional().describe("Maximum market cap in USD."),
+  grades: import_zod11.z.string().optional().describe("Comma-separated grade filters (e.g. `A,A+`).")
+});
+var TokensSimilarBody = import_zod11.z.object({
+  tokenId: import_zod11.z.string().min(1).describe("Noya token ID to find similar tokens for."),
+  limit: import_zod11.z.number().int().min(1).max(100).default(10).describe("Max similar tokens to return.")
+});
+var TokensRecommendationsBody = import_zod11.z.object({
+  riskTolerance: import_zod11.z.enum(["conservative", "moderate", "aggressive"]).describe("Caller's risk profile \u2014 filters the recommendation set accordingly."),
+  minMarketCap: import_zod11.z.number().optional().describe("Minimum market cap in USD."),
+  maxMarketCap: import_zod11.z.number().optional().describe("Maximum market cap in USD."),
+  query: import_zod11.z.string().optional().describe("Optional free-text query to bias recommendations toward."),
+  limit: import_zod11.z.number().int().min(1).max(100).default(20).describe("Max tokens to recommend (1\u2013100).")
+});
+var TopTokensByScoreBody = import_zod11.z.object({
+  limit: import_zod11.z.number().int().min(1).max(100).default(20).describe("Number of top tokens to return."),
+  grades: import_zod11.z.string().optional().describe("Comma-separated grade filters (e.g. `A,A+`)."),
+  minCatalystScore: import_zod11.z.number().optional().describe("Minimum AI catalyst score (0\u2013100)."),
+  minMarketCap: import_zod11.z.number().optional().describe("Minimum market cap in USD."),
+  maxMarketCap: import_zod11.z.number().optional().describe("Maximum market cap in USD.")
+});
+var TokensByVersionBody = import_zod11.z.object({
+  versionId: import_zod11.z.number().int().min(1).optional().describe("Specific Noya analysis version ID. Defaults to the latest."),
+  signal: import_zod11.z.string().optional().describe("Filter to a specific signal value."),
+  risk: import_zod11.z.string().optional().describe("Filter to a specific risk tier."),
+  sort: import_zod11.z.string().optional().describe("Field name to sort by (e.g. `marketCap`, `aiFinal`)."),
+  order: import_zod11.z.enum(["asc", "desc"]).optional().describe("Sort direction.")
+});
+var TokenDetailBody = import_zod11.z.object({
+  versionId: import_zod11.z.number().int().min(1).optional().describe("Specific Noya analysis version. Defaults to the latest."),
+  symbol: import_zod11.z.string().min(1).describe("Token symbol (e.g. `BTC`, `ETH`).")
+});
+var TokenScores = import_zod11.z.object({
+  longTerm: import_zod11.z.number().nullable(),
+  shortTerm: import_zod11.z.number().nullable(),
+  aiFinal: import_zod11.z.number().nullable(),
+  aiMomentum: import_zod11.z.number().nullable(),
+  aiSentiment: import_zod11.z.number().nullable(),
+  aiCatalysts: import_zod11.z.number().nullable(),
+  aiFundamentals: import_zod11.z.number().nullable()
+});
+var CryptoToken = import_zod11.z.object({
+  symbol: import_zod11.z.string(),
+  name: import_zod11.z.string(),
+  overallGrade: import_zod11.z.string(),
+  overallScore: import_zod11.z.number(),
+  recommendation: import_zod11.z.string(),
+  marketCap: import_zod11.z.number(),
+  category: import_zod11.z.string(),
+  rank: import_zod11.z.number().nullable(),
+  price: import_zod11.z.number().nullable(),
+  volume24h: import_zod11.z.number().nullable(),
+  scores: TokenScores,
+  riskLevel: import_zod11.z.string().nullable(),
+  timeHorizon: import_zod11.z.string().nullable(),
+  aiSummary: import_zod11.z.string().nullable(),
+  catalystCount: import_zod11.z.number(),
+  hasWebContext: import_zod11.z.boolean()
+});
+var TokensSearchResponse = import_zod11.z.object({
+  total: import_zod11.z.number(),
+  limit: import_zod11.z.number(),
+  versionId: import_zod11.z.number(),
+  data: import_zod11.z.array(
+    import_zod11.z.object({ token: CryptoToken, score: import_zod11.z.number(), tokenId: import_zod11.z.string() })
+  )
+});
+var VersionsResponse = import_zod11.z.object({
+  count: import_zod11.z.number(),
+  versions: import_zod11.z.array(
+    import_zod11.z.object({
+      id: import_zod11.z.number(),
+      runAt: import_zod11.z.string(),
+      status: import_zod11.z.string(),
+      tokenCount: import_zod11.z.number()
+    })
+  )
+});
+var PolymarketSearchBody = import_zod11.z.object({
+  q: import_zod11.z.string().min(1).describe("Free-text search query \u2014 matches market question, description, and tags."),
+  limit: import_zod11.z.number().int().min(1).max(100).default(10).describe("Max markets to return (1\u2013100).")
+});
+var PolymarketSimilarBody = import_zod11.z.object({
+  conditionId: import_zod11.z.string().min(1).describe("Polymarket condition ID (or event ID, depending on `type`) to find similar items for."),
+  limit: import_zod11.z.number().int().min(1).max(100).default(10).describe("Max similar items to return."),
+  type: import_zod11.z.enum(["market", "event"]).default("market").describe("Whether `conditionId` refers to a market or an event.")
+});
+var PolymarketRecommendationsBody = import_zod11.z.object({
+  riskTolerance: import_zod11.z.enum(["conservative", "moderate", "aggressive"]).describe("Caller's risk profile."),
+  preferredTags: import_zod11.z.array(import_zod11.z.string()).optional().describe("Bias toward markets carrying any of these tags."),
+  preferredCategories: import_zod11.z.array(import_zod11.z.string()).optional().describe("Bias toward markets in these categories."),
+  minDaysUntilClose: import_zod11.z.number().optional().describe("Minimum days until the market resolves."),
+  maxDaysUntilClose: import_zod11.z.number().optional().describe("Maximum days until the market resolves."),
+  minLiquidity: import_zod11.z.number().optional().describe("Minimum on-book liquidity in USD."),
+  minVolume24h: import_zod11.z.number().optional().describe("Minimum 24h volume in USD."),
+  query: import_zod11.z.string().optional().describe("Optional free-text query to bias recommendations toward."),
+  limit: import_zod11.z.number().int().min(1).max(100).default(20).describe("Max markets to recommend.")
+});
+var TopMarketsByEvBody = import_zod11.z.object({
+  limit: import_zod11.z.number().int().min(1).max(100).default(20).describe("Number of top markets to return."),
+  minLiquidity: import_zod11.z.number().optional().describe("Minimum on-book liquidity in USD."),
+  minVolume24h: import_zod11.z.number().optional().describe("Minimum 24h volume in USD."),
+  tags: import_zod11.z.string().optional().describe("Comma-separated tag filter.")
+});
+var PolymarketFilterBody = import_zod11.z.object({
+  q: import_zod11.z.string().min(1).describe("Free-text search query \u2014 required by the upstream filter endpoint."),
+  limit: import_zod11.z.number().int().min(1).max(100).default(20).describe("Max results."),
+  tags: import_zod11.z.string().optional().describe("Comma-separated tag filter."),
+  category: import_zod11.z.string().optional().describe("Restrict to a single category."),
+  active: import_zod11.z.boolean().optional().describe("Filter to active (non-resolved) markets."),
+  minLiquidity: import_zod11.z.number().optional().describe("Minimum on-book liquidity in USD."),
+  minVolume24h: import_zod11.z.number().optional().describe("Minimum 24h volume in USD.")
+});
+var PolymarketFilterResponse = import_zod11.z.object({
+  metadata: import_zod11.z.object({
+    query: import_zod11.z.string(),
+    type: import_zod11.z.string(),
+    total: import_zod11.z.number(),
+    limit: import_zod11.z.number(),
+    filters: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.unknown()),
+    duration: import_zod11.z.number()
+  }),
+  data: import_zod11.z.array(
+    import_zod11.z.object({
+      score: import_zod11.z.number(),
+      id: import_zod11.z.string(),
+      payload: import_zod11.z.unknown()
+    })
+  )
+});
+var PolymarketEventsBody = import_zod11.z.object({
+  limit: import_zod11.z.number().int().min(1).max(200).default(100).describe("Max events to return (1\u2013200).")
+});
+var PolymarketByEventBody = import_zod11.z.object({
+  eventSlug: import_zod11.z.string().min(1).describe("Polymarket event slug (URL fragment, e.g. `2024-presidential-election`)."),
+  limit: import_zod11.z.number().int().min(1).max(100).default(50).describe("Max markets per event to return.")
+});
+var PolymarketTagsBody = import_zod11.z.object({
+  type: import_zod11.z.enum(["market", "event"]).optional().describe("Restrict tag list to those used on markets or events. Returns both when omitted.")
+});
+var PolymarketResponse = import_zod11.z.object({
+  total: import_zod11.z.number(),
+  limit: import_zod11.z.number(),
+  data: import_zod11.z.array(import_zod11.z.unknown())
+});
+var VersionParam = import_zod11.z.union([import_zod11.z.literal("latest"), import_zod11.z.number().int().positive()]).describe("Analysis batch version. `latest` for the most recent run, or a numeric version ID for a specific batch.");
+var AnalysisSignal = import_zod11.z.enum(["strong_buy", "buy", "hold", "sell", "strong_sell", "none"]).describe("Noya analysis signal classification.");
+var AnalysisVersionsBody = import_zod11.z.object({
+  limit: import_zod11.z.number().int().min(1).max(100).default(20).describe("Max versions to list."),
+  offset: import_zod11.z.number().int().min(0).default(0).describe("Pagination offset.")
+});
+var AnalysisEventsBody = import_zod11.z.object({
+  version: VersionParam.default("latest"),
+  tag: import_zod11.z.string().optional().describe("Filter events to those carrying a specific tag."),
+  signal: AnalysisSignal.optional(),
+  limit: import_zod11.z.number().int().min(1).max(200).default(50).describe("Max events to return."),
+  offset: import_zod11.z.number().int().min(0).default(0).describe("Pagination offset.")
+});
+var AnalysisEventHistoryBody = import_zod11.z.object({
+  eventId: import_zod11.z.string().min(1).describe("Polymarket event ID to fetch the analysis history for.")
+});
+var AnalysisMarketHistoryBody = import_zod11.z.object({
+  conditionId: import_zod11.z.string().min(1).describe("Polymarket condition ID to fetch the analysis history for.")
+});
+var AnalysisTopBody = import_zod11.z.object({
+  version: VersionParam.default("latest"),
+  by: import_zod11.z.enum(["ev_percentage", "confidence", "signal_strength"]).default("ev_percentage").describe("Ranking metric."),
+  signal: AnalysisSignal.optional(),
+  limit: import_zod11.z.number().int().min(1).max(200).default(20).describe("Max markets to return.")
+});
+var AnalysisLatestResponse = import_zod11.z.object({
+  batch: import_zod11.z.object({
+    version: import_zod11.z.number(),
+    createdAt: import_zod11.z.string(),
+    model: import_zod11.z.string(),
+    tags: import_zod11.z.array(import_zod11.z.string()),
+    eventCount: import_zod11.z.number(),
+    marketCount: import_zod11.z.number(),
+    sourceFile: import_zod11.z.string(),
+    notes: import_zod11.z.string().nullable()
+  }).nullable(),
+  signalHistogram: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.number())
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alternative,
+  batch,
+  coingecko,
+  coinglass,
+  composite,
+  cryptonews,
+  defillama,
+  geckoterminal,
+  kaito,
+  moralis,
+  noya
+});