@noya-ai/data-server-schemas 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Noya
+
+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

@@ -0,0 +1,25 @@
+# @noya-ai/data-server-schemas
+
+Shared [Zod](https://zod.dev) schemas for the Noya data-server API surface. Published as a runtime dependency of [`@noya-ai/sdk`](https://www.npmjs.com/package/@noya-ai/sdk), [`@noya-ai/cli`](https://www.npmjs.com/package/@noya-ai/cli), and [`@noya-ai/mcp`](https://www.npmjs.com/package/@noya-ai/mcp) — you generally don't depend on this directly.
+
+## Install
+
+```bash
+npm install @noya-ai/data-server-schemas
+```
+
+## Usage
+
+Schemas are exported per data family via subpath imports:
+
+```ts
+import { PriceBody, PriceResponse } from "@noya-ai/data-server-schemas/coingecko";
+
+const parsed = PriceBody.parse({ tokenIds: ["bitcoin"] });
+```
+
+Families: `alternative`, `batch`, `coingecko`, `coinglass`, `composite`, `cryptonews`, `defillama`, `geckoterminal`, `kaito`, `moralis`, `noya`. The root export re-exports all of them.
+
+## License
+
+MIT

package/dist/alternative/schemas.cjs

@@ -0,0 +1,44 @@
+"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/alternative/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  FearGreedBody: () => FearGreedBody,
+  FearGreedEntry: () => FearGreedEntry,
+  FearGreedResponse: () => FearGreedResponse
+});
+module.exports = __toCommonJS(schemas_exports);
+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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FearGreedBody,
+  FearGreedEntry,
+  FearGreedResponse
+});

package/dist/alternative/schemas.d.cts

@@ -0,0 +1,2 @@
+import 'zod';
+export { F as FearGreedBody, a as FearGreedEntry, b as FearGreedResponse } from '../schemas-BYLoGYNO.cjs';

package/dist/alternative/schemas.d.ts

@@ -0,0 +1,2 @@
+import 'zod';
+export { F as FearGreedBody, a as FearGreedEntry, b as FearGreedResponse } from '../schemas-BYLoGYNO.js';

package/dist/alternative/schemas.js

@@ -0,0 +1,11 @@
+import {
+  FearGreedBody,
+  FearGreedEntry,
+  FearGreedResponse
+} from "../chunk-DKMPZFSH.js";
+import "../chunk-MLKGABMK.js";
+export {
+  FearGreedBody,
+  FearGreedEntry,
+  FearGreedResponse
+};

package/dist/batch/schemas.cjs

@@ -0,0 +1,73 @@
+"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/batch/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  BatchBody: () => BatchBody,
+  BatchFailure: () => BatchFailure,
+  BatchItem: () => BatchItem,
+  BatchResponse: () => BatchResponse,
+  BatchResult: () => BatchResult,
+  BatchSuccess: () => BatchSuccess
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+var BatchItem = import_zod.z.object({
+  name: import_zod.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_zod.z.enum(["GET", "POST"]).describe("HTTP method for the sub-request."),
+  path: import_zod.z.string().startsWith("/").min(2).describe("Server-relative path of the sub-request (e.g. `/coingecko/price`). Nested batch paths are forbidden."),
+  body: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("JSON body for POST sub-requests. Ignored for GET."),
+  query: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Query-string parameters appended to the sub-request URL."),
+  timeoutMs: import_zod.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_zod.z.object({
+  requests: import_zod.z.array(BatchItem).min(1).max(20).describe("Array of sub-requests to dispatch in parallel (1\u201320 items)."),
+  defaultTimeoutMs: import_zod.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_zod.z.object({
+  ok: import_zod.z.literal(true),
+  status: import_zod.z.number(),
+  data: import_zod.z.unknown(),
+  cache: import_zod.z.enum(["HIT", "MISS"]).optional()
+});
+var BatchFailure = import_zod.z.object({
+  ok: import_zod.z.literal(false),
+  status: import_zod.z.number(),
+  error: import_zod.z.string()
+});
+var BatchResult = import_zod.z.union([BatchSuccess, BatchFailure]);
+var BatchResponse = import_zod.z.object({
+  results: import_zod.z.record(import_zod.z.string(), BatchResult)
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatchBody,
+  BatchFailure,
+  BatchItem,
+  BatchResponse,
+  BatchResult,
+  BatchSuccess
+});

package/dist/batch/schemas.d.cts

@@ -0,0 +1,2 @@
+import 'zod';
+export { B as BatchBody, a as BatchFailure, b as BatchItem, c as BatchResponse, d as BatchResult, e as BatchSuccess } from '../schemas-CAn6VbI-.cjs';

package/dist/batch/schemas.d.ts

@@ -0,0 +1,2 @@
+import 'zod';
+export { B as BatchBody, a as BatchFailure, b as BatchItem, c as BatchResponse, d as BatchResult, e as BatchSuccess } from '../schemas-CAn6VbI-.js';

package/dist/batch/schemas.js

@@ -0,0 +1,17 @@
+import {
+  BatchBody,
+  BatchFailure,
+  BatchItem,
+  BatchResponse,
+  BatchResult,
+  BatchSuccess
+} from "../chunk-ROAH5BN3.js";
+import "../chunk-MLKGABMK.js";
+export {
+  BatchBody,
+  BatchFailure,
+  BatchItem,
+  BatchResponse,
+  BatchResult,
+  BatchSuccess
+};

package/dist/chunk-BWY4ZL7E.js

@@ -0,0 +1,142 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/defillama/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  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
+});
+import { z } from "zod";
+var TvlBody = z.object({
+  protocol: z.string().optional().describe("DeFiLlama protocol slug (e.g. `aave-v3`). Mutually exclusive with `chain`."),
+  chain: z.string().optional().describe("Chain name (e.g. `Ethereum`, `Base`). Returns the chain's aggregate TVL."),
+  historical: 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 = z.object({ date: z.number(), tvl: z.number() });
+var TvlResponse = z.object({
+  type: z.enum(["protocol", "chain"]),
+  name: z.string(),
+  currentTvl: z.number().nullable(),
+  history: z.array(TvlDataPoint).nullable()
+});
+var YieldsBody = z.object({
+  chain: z.string().optional().describe("Filter pools to a single chain."),
+  token: z.string().optional().describe("Filter pools that include this token symbol (e.g. `USDC`)."),
+  protocol: z.string().optional().describe("Filter pools by protocol slug (e.g. `aave-v3`)."),
+  minTvl: z.number().optional().describe("Minimum pool TVL in USD \u2014 drop dust pools below this threshold."),
+  poolId: z.string().optional().describe("Specific DeFiLlama pool ID for a single-pool lookup. Wins over the other filters.")
+});
+var YieldPoolItem = z.object({
+  pool: z.string(),
+  chain: z.string(),
+  project: z.string(),
+  symbol: z.string(),
+  tvlUsd: z.number(),
+  apy: z.number().nullable(),
+  apyBase: z.number().nullable(),
+  apyReward: z.number().nullable(),
+  stablecoin: z.boolean(),
+  exposure: z.string().nullable(),
+  ilRisk: z.string().nullable(),
+  predictions: z.object({
+    predictedClass: z.string().nullable(),
+    binnedConfidence: z.number().nullable()
+  }).nullable()
+});
+var YieldsResponse = z.array(YieldPoolItem);
+var ProtocolFeesBody = z.object({
+  protocol: z.string().min(1).describe("Protocol slug to pull fee/revenue data for."),
+  dataType: 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 = z.object({
+  name: z.string(),
+  category: z.string().nullable(),
+  chains: z.array(z.string()),
+  total24h: z.number().nullable(),
+  total7d: z.number().nullable(),
+  total30d: z.number().nullable(),
+  totalAllTime: z.number().nullable(),
+  change1d: z.number().nullable(),
+  change7d: z.number().nullable(),
+  change1m: z.number().nullable(),
+  dailyChart: z.array(z.object({ date: z.number(), value: z.number() })).nullable()
+});
+var DexVolumesBody = z.object({
+  protocol: z.string().optional().describe("Single-DEX detail mode (e.g. `uniswap`). Mutually exclusive with `chain`."),
+  chain: z.string().optional().describe("Filter aggregate volume to one chain (e.g. `Ethereum`). Omit both for the global summary.")
+});
+var DexVolumesResponse = z.union([
+  z.object({
+    total24h: z.number(),
+    total7d: z.number(),
+    protocols: z.array(z.unknown())
+  }).passthrough(),
+  z.object({
+    name: z.string(),
+    chains: z.array(z.string())
+  }).passthrough()
+]);
+var StablecoinsBody = z.object({
+  chain: z.string().optional().describe("Filter circulating-supply data to one chain."),
+  stablecoinId: z.string().optional().describe("DeFiLlama stablecoin ID for a single-coin lookup (e.g. `1` for USDT).")
+});
+var StablecoinsResponse = z.unknown();
+var BridgesBody = z.object({
+  chain: z.string().optional().describe("Filter bridge volume to one chain."),
+  bridgeId: z.number().optional().describe("DeFiLlama numeric bridge ID for a single-bridge detail view.")
+});
+var BridgeItem = z.object({
+  id: z.number(),
+  name: z.string(),
+  displayName: z.string(),
+  volumePrevDay: z.number(),
+  last24hVolume: z.number(),
+  weeklyVolume: z.number().nullable(),
+  monthlyVolume: z.number().nullable(),
+  chains: z.array(z.string()).optional()
+});
+var BridgesResponse = z.unknown();
+var BridgesListResponse = z.array(BridgeItem);
+
+export {
+  TvlBody,
+  TvlDataPoint,
+  TvlResponse,
+  YieldsBody,
+  YieldPoolItem,
+  YieldsResponse,
+  ProtocolFeesBody,
+  ProtocolFeesResponse,
+  DexVolumesBody,
+  DexVolumesResponse,
+  StablecoinsBody,
+  StablecoinsResponse,
+  BridgesBody,
+  BridgeItem,
+  BridgesResponse,
+  BridgesListResponse,
+  schemas_exports
+};

package/dist/chunk-C3YNWX7W.js

@@ -0,0 +1,256 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/noya/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  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
+});
+import { z } from "zod";
+var TokensSearchBody = z.object({
+  q: z.string().min(1).describe("Free-text search query \u2014 matches token symbol, name, or category."),
+  limit: z.number().int().min(1).max(100).default(10).describe("Max tokens to return (1\u2013100)."),
+  signal: z.string().optional().describe("Filter to tokens with a specific Noya signal (e.g. `strong_buy`)."),
+  risk: z.string().optional().describe("Filter to tokens at a specific risk tier (e.g. `low`, `medium`, `high`)."),
+  minFinalScore: z.number().optional().describe("Minimum AI final score (0\u2013100)."),
+  maxFinalScore: z.number().optional().describe("Maximum AI final score (0\u2013100)."),
+  minMarketCap: z.number().optional().describe("Minimum market cap in USD."),
+  maxMarketCap: z.number().optional().describe("Maximum market cap in USD."),
+  grades: z.string().optional().describe("Comma-separated grade filters (e.g. `A,A+`).")
+});
+var TokensSimilarBody = z.object({
+  tokenId: z.string().min(1).describe("Noya token ID to find similar tokens for."),
+  limit: z.number().int().min(1).max(100).default(10).describe("Max similar tokens to return.")
+});
+var TokensRecommendationsBody = z.object({
+  riskTolerance: z.enum(["conservative", "moderate", "aggressive"]).describe("Caller's risk profile \u2014 filters the recommendation set accordingly."),
+  minMarketCap: z.number().optional().describe("Minimum market cap in USD."),
+  maxMarketCap: z.number().optional().describe("Maximum market cap in USD."),
+  query: z.string().optional().describe("Optional free-text query to bias recommendations toward."),
+  limit: z.number().int().min(1).max(100).default(20).describe("Max tokens to recommend (1\u2013100).")
+});
+var TopTokensByScoreBody = z.object({
+  limit: z.number().int().min(1).max(100).default(20).describe("Number of top tokens to return."),
+  grades: z.string().optional().describe("Comma-separated grade filters (e.g. `A,A+`)."),
+  minCatalystScore: z.number().optional().describe("Minimum AI catalyst score (0\u2013100)."),
+  minMarketCap: z.number().optional().describe("Minimum market cap in USD."),
+  maxMarketCap: z.number().optional().describe("Maximum market cap in USD.")
+});
+var TokensByVersionBody = z.object({
+  versionId: z.number().int().min(1).optional().describe("Specific Noya analysis version ID. Defaults to the latest."),
+  signal: z.string().optional().describe("Filter to a specific signal value."),
+  risk: z.string().optional().describe("Filter to a specific risk tier."),
+  sort: z.string().optional().describe("Field name to sort by (e.g. `marketCap`, `aiFinal`)."),
+  order: z.enum(["asc", "desc"]).optional().describe("Sort direction.")
+});
+var TokenDetailBody = z.object({
+  versionId: z.number().int().min(1).optional().describe("Specific Noya analysis version. Defaults to the latest."),
+  symbol: z.string().min(1).describe("Token symbol (e.g. `BTC`, `ETH`).")
+});
+var TokenScores = z.object({
+  longTerm: z.number().nullable(),
+  shortTerm: z.number().nullable(),
+  aiFinal: z.number().nullable(),
+  aiMomentum: z.number().nullable(),
+  aiSentiment: z.number().nullable(),
+  aiCatalysts: z.number().nullable(),
+  aiFundamentals: z.number().nullable()
+});
+var CryptoToken = z.object({
+  symbol: z.string(),
+  name: z.string(),
+  overallGrade: z.string(),
+  overallScore: z.number(),
+  recommendation: z.string(),
+  marketCap: z.number(),
+  category: z.string(),
+  rank: z.number().nullable(),
+  price: z.number().nullable(),
+  volume24h: z.number().nullable(),
+  scores: TokenScores,
+  riskLevel: z.string().nullable(),
+  timeHorizon: z.string().nullable(),
+  aiSummary: z.string().nullable(),
+  catalystCount: z.number(),
+  hasWebContext: z.boolean()
+});
+var TokensSearchResponse = z.object({
+  total: z.number(),
+  limit: z.number(),
+  versionId: z.number(),
+  data: z.array(
+    z.object({ token: CryptoToken, score: z.number(), tokenId: z.string() })
+  )
+});
+var VersionsResponse = z.object({
+  count: z.number(),
+  versions: z.array(
+    z.object({
+      id: z.number(),
+      runAt: z.string(),
+      status: z.string(),
+      tokenCount: z.number()
+    })
+  )
+});
+var PolymarketSearchBody = z.object({
+  q: z.string().min(1).describe("Free-text search query \u2014 matches market question, description, and tags."),
+  limit: z.number().int().min(1).max(100).default(10).describe("Max markets to return (1\u2013100).")
+});
+var PolymarketSimilarBody = z.object({
+  conditionId: z.string().min(1).describe("Polymarket condition ID (or event ID, depending on `type`) to find similar items for."),
+  limit: z.number().int().min(1).max(100).default(10).describe("Max similar items to return."),
+  type: z.enum(["market", "event"]).default("market").describe("Whether `conditionId` refers to a market or an event.")
+});
+var PolymarketRecommendationsBody = z.object({
+  riskTolerance: z.enum(["conservative", "moderate", "aggressive"]).describe("Caller's risk profile."),
+  preferredTags: z.array(z.string()).optional().describe("Bias toward markets carrying any of these tags."),
+  preferredCategories: z.array(z.string()).optional().describe("Bias toward markets in these categories."),
+  minDaysUntilClose: z.number().optional().describe("Minimum days until the market resolves."),
+  maxDaysUntilClose: z.number().optional().describe("Maximum days until the market resolves."),
+  minLiquidity: z.number().optional().describe("Minimum on-book liquidity in USD."),
+  minVolume24h: z.number().optional().describe("Minimum 24h volume in USD."),
+  query: z.string().optional().describe("Optional free-text query to bias recommendations toward."),
+  limit: z.number().int().min(1).max(100).default(20).describe("Max markets to recommend.")
+});
+var TopMarketsByEvBody = z.object({
+  limit: z.number().int().min(1).max(100).default(20).describe("Number of top markets to return."),
+  minLiquidity: z.number().optional().describe("Minimum on-book liquidity in USD."),
+  minVolume24h: z.number().optional().describe("Minimum 24h volume in USD."),
+  tags: z.string().optional().describe("Comma-separated tag filter.")
+});
+var PolymarketFilterBody = z.object({
+  q: z.string().min(1).describe("Free-text search query \u2014 required by the upstream filter endpoint."),
+  limit: z.number().int().min(1).max(100).default(20).describe("Max results."),
+  tags: z.string().optional().describe("Comma-separated tag filter."),
+  category: z.string().optional().describe("Restrict to a single category."),
+  active: z.boolean().optional().describe("Filter to active (non-resolved) markets."),
+  minLiquidity: z.number().optional().describe("Minimum on-book liquidity in USD."),
+  minVolume24h: z.number().optional().describe("Minimum 24h volume in USD.")
+});
+var PolymarketFilterResponse = z.object({
+  metadata: z.object({
+    query: z.string(),
+    type: z.string(),
+    total: z.number(),
+    limit: z.number(),
+    filters: z.record(z.string(), z.unknown()),
+    duration: z.number()
+  }),
+  data: z.array(
+    z.object({
+      score: z.number(),
+      id: z.string(),
+      payload: z.unknown()
+    })
+  )
+});
+var PolymarketEventsBody = z.object({
+  limit: z.number().int().min(1).max(200).default(100).describe("Max events to return (1\u2013200).")
+});
+var PolymarketByEventBody = z.object({
+  eventSlug: z.string().min(1).describe("Polymarket event slug (URL fragment, e.g. `2024-presidential-election`)."),
+  limit: z.number().int().min(1).max(100).default(50).describe("Max markets per event to return.")
+});
+var PolymarketTagsBody = z.object({
+  type: z.enum(["market", "event"]).optional().describe("Restrict tag list to those used on markets or events. Returns both when omitted.")
+});
+var PolymarketResponse = z.object({
+  total: z.number(),
+  limit: z.number(),
+  data: z.array(z.unknown())
+});
+var VersionParam = z.union([z.literal("latest"), 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 = z.enum(["strong_buy", "buy", "hold", "sell", "strong_sell", "none"]).describe("Noya analysis signal classification.");
+var AnalysisVersionsBody = z.object({
+  limit: z.number().int().min(1).max(100).default(20).describe("Max versions to list."),
+  offset: z.number().int().min(0).default(0).describe("Pagination offset.")
+});
+var AnalysisEventsBody = z.object({
+  version: VersionParam.default("latest"),
+  tag: z.string().optional().describe("Filter events to those carrying a specific tag."),
+  signal: AnalysisSignal.optional(),
+  limit: z.number().int().min(1).max(200).default(50).describe("Max events to return."),
+  offset: z.number().int().min(0).default(0).describe("Pagination offset.")
+});
+var AnalysisEventHistoryBody = z.object({
+  eventId: z.string().min(1).describe("Polymarket event ID to fetch the analysis history for.")
+});
+var AnalysisMarketHistoryBody = z.object({
+  conditionId: z.string().min(1).describe("Polymarket condition ID to fetch the analysis history for.")
+});
+var AnalysisTopBody = z.object({
+  version: VersionParam.default("latest"),
+  by: z.enum(["ev_percentage", "confidence", "signal_strength"]).default("ev_percentage").describe("Ranking metric."),
+  signal: AnalysisSignal.optional(),
+  limit: z.number().int().min(1).max(200).default(20).describe("Max markets to return.")
+});
+var AnalysisLatestResponse = z.object({
+  batch: z.object({
+    version: z.number(),
+    createdAt: z.string(),
+    model: z.string(),
+    tags: z.array(z.string()),
+    eventCount: z.number(),
+    marketCount: z.number(),
+    sourceFile: z.string(),
+    notes: z.string().nullable()
+  }).nullable(),
+  signalHistogram: z.record(z.string(), z.number())
+});
+
+export {
+  TokensSearchBody,
+  TokensSimilarBody,
+  TokensRecommendationsBody,
+  TopTokensByScoreBody,
+  TokensByVersionBody,
+  TokenDetailBody,
+  TokenScores,
+  CryptoToken,
+  TokensSearchResponse,
+  VersionsResponse,
+  PolymarketSearchBody,
+  PolymarketSimilarBody,
+  PolymarketRecommendationsBody,
+  TopMarketsByEvBody,
+  PolymarketFilterBody,
+  PolymarketFilterResponse,
+  PolymarketEventsBody,
+  PolymarketByEventBody,
+  PolymarketTagsBody,
+  PolymarketResponse,
+  AnalysisVersionsBody,
+  AnalysisEventsBody,
+  AnalysisEventHistoryBody,
+  AnalysisMarketHistoryBody,
+  AnalysisTopBody,
+  AnalysisLatestResponse,
+  schemas_exports
+};

package/dist/chunk-DKMPZFSH.js

@@ -0,0 +1,29 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/alternative/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  FearGreedBody: () => FearGreedBody,
+  FearGreedEntry: () => FearGreedEntry,
+  FearGreedResponse: () => FearGreedResponse
+});
+import { z } from "zod";
+var FearGreedBody = z.object({
+  limit: 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 = z.object({
+  value: z.number(),
+  classification: z.string(),
+  timestamp: z.number(),
+  timeUntilUpdate: z.number().nullable()
+});
+var FearGreedResponse = z.array(FearGreedEntry);
+
+export {
+  FearGreedBody,
+  FearGreedEntry,
+  FearGreedResponse,
+  schemas_exports
+};