@noya-ai/data-server-schemas 0.1.0

package/dist/chunk-KLRIACSR.js

@@ -0,0 +1,162 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/coingecko/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  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
+});
+import { z } from "zod";
+var PriceBody = z.object({
+  tokenIds: z.array(z.string()).min(1).describe("CoinGecko token IDs to price (e.g. `bitcoin`, `ethereum`). At least one required."),
+  vsCurrencies: z.array(z.string()).optional().describe("Quote currencies (e.g. `usd`, `eur`, `btc`). Defaults to USD when omitted."),
+  include24hrChange: z.boolean().default(true).describe("Include 24-hour percentage price change in the response."),
+  includeMarketCap: z.boolean().default(true).describe("Include market cap in the response."),
+  include24hrVol: z.boolean().default(false).describe("Include 24-hour trading volume in the response.")
+});
+var TokenPrice = z.object({
+  id: z.string(),
+  price: z.number().nullable(),
+  change24h: z.number().nullable(),
+  marketCap: z.number().nullable(),
+  volume24h: z.number().nullable(),
+  currency: z.string()
+});
+var PriceResponse = z.array(TokenPrice);
+var OhlcvBody = z.object({
+  tokenId: z.string().min(1).describe("CoinGecko token ID (e.g. `bitcoin`)."),
+  vsCurrency: z.string().default("usd").describe("Quote currency for the OHLCV candles."),
+  days: z.enum(["1", "7", "14", "30", "90", "180", "365", "max"]).default("7").describe("Lookback window. Use `max` for the full available history."),
+  interval: z.enum(["daily", "hourly"]).optional().describe("Candle resolution. CoinGecko picks a sensible default if omitted (hourly for short windows, daily for long).")
+});
+var OhlcvCandle = z.object({
+  timestamp: z.number(),
+  open: z.number(),
+  high: z.number(),
+  low: z.number(),
+  close: z.number()
+});
+var OhlcvResponse = z.array(OhlcvCandle);
+var TokenInfoBody = z.object({
+  tokenId: z.string().min(1).describe("CoinGecko token ID to fetch metadata for.")
+});
+var ContractAddress = z.object({
+  chain: z.string(),
+  chainId: z.number().nullable(),
+  platformId: z.string(),
+  address: z.string()
+});
+var TokenInfo = z.object({
+  id: z.string(),
+  symbol: z.string(),
+  name: z.string(),
+  description: z.string(),
+  categories: z.array(z.string()),
+  links: z.object({
+    homepage: z.array(z.string()),
+    twitter: z.string().nullable(),
+    telegram: z.string().nullable(),
+    github: z.array(z.string()),
+    subreddit: z.string().nullable()
+  }),
+  contracts: z.array(ContractAddress),
+  genesisDate: z.string().nullable(),
+  image: z.string().nullable(),
+  marketCapRank: z.number().nullable()
+});
+var TrendingToken = z.object({
+  id: z.string(),
+  name: z.string(),
+  symbol: z.string(),
+  marketCapRank: z.number().nullable(),
+  priceBtc: z.number().nullable(),
+  priceUsd: z.number().nullable(),
+  change24h: z.number().nullable(),
+  thumb: z.string().nullable(),
+  score: z.number().nullable()
+});
+var TrendingResponse = z.array(TrendingToken);
+var SearchBody = z.object({
+  query: z.string().min(1).describe("Free-text search query (token name, symbol, or partial match).")
+});
+var SearchResult = z.object({
+  id: z.string(),
+  name: z.string(),
+  symbol: z.string(),
+  marketCapRank: z.number().nullable(),
+  thumb: z.string().nullable()
+});
+var SearchResponse = z.array(SearchResult);
+var PriceHistoryBody = z.object({
+  tokenId: z.string().min(1).describe("CoinGecko token ID."),
+  vsCurrency: z.string().default("usd").describe("Quote currency for the historical prices."),
+  days: z.string().optional().describe("Lookback window in days (e.g. `30`). Mutually exclusive with `from`/`to`."),
+  from: z.string().optional().describe("ISO 8601 start timestamp (UTC). Use with `to` instead of `days`."),
+  to: z.string().optional().describe("ISO 8601 end timestamp (UTC). Use with `from` instead of `days`."),
+  interval: 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 = z.object({
+  timestamp: z.number(),
+  price: z.number(),
+  marketCap: z.number().nullable(),
+  volume: z.number().nullable()
+});
+var PriceHistoryResponse = z.array(PricePoint);
+var PriceAtDateBody = z.object({
+  tokenId: z.string().min(1).describe("CoinGecko token ID."),
+  date: 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 = z.object({
+  id: z.string(),
+  name: z.string(),
+  symbol: z.string(),
+  date: z.string(),
+  price: z.record(z.string(), z.number()),
+  marketCap: z.record(z.string(), z.number()),
+  volume: z.record(z.string(), z.number())
+});
+
+export {
+  PriceBody,
+  TokenPrice,
+  PriceResponse,
+  OhlcvBody,
+  OhlcvCandle,
+  OhlcvResponse,
+  TokenInfoBody,
+  ContractAddress,
+  TokenInfo,
+  TrendingToken,
+  TrendingResponse,
+  SearchBody,
+  SearchResult,
+  SearchResponse,
+  PriceHistoryBody,
+  PricePoint,
+  PriceHistoryResponse,
+  PriceAtDateBody,
+  PriceSnapshot,
+  schemas_exports
+};

package/dist/chunk-MECUVGQT.js

@@ -0,0 +1,203 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/kaito/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  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: () => SearchBody,
+  SentimentBody: () => SentimentBody,
+  SmartFollowersBody: () => SmartFollowersBody,
+  SmartFollowingBody: () => SmartFollowingBody,
+  TweetEngagementBody: () => TweetEngagementBody,
+  TwitterUserMetadataBody: () => TwitterUserMetadataBody
+});
+import { z } from "zod";
+var dateString = (note) => z.string().optional().describe(note);
+var sortOrder = z.enum(["asc", "desc"]).optional().describe("Sort direction for the result list.");
+var EntitiesQuery = z.object({
+  query: z.string().optional().describe("Free-text filter for entity names. Omit to list all."),
+  limit: z.coerce.number().int().min(1).max(100).optional().describe("Max entities to return (1\u2013100).")
+});
+var NarrativesQuery = z.object({
+  query: z.string().optional().describe("Free-text filter for narrative names. Omit to list all."),
+  limit: z.coerce.number().int().min(1).max(100).optional().describe("Max narratives to return (1\u2013100).")
+});
+var SearchBody = z.object({
+  query: z.string().min(1).describe("Free-text search query across tweets, narratives, and entities."),
+  size: z.number().int().min(1).max(50).optional().describe("Result page size (1\u201350). Default 10.")
+});
+var AdvancedSearchBody = z.object({
+  tokens: z.string().optional().describe("Comma-separated token symbols to filter tweets to (e.g. `BTC,ETH`)."),
+  keyword: z.string().optional().describe("Keyword filter \u2014 substring-matched against tweet text."),
+  query: z.string().optional().describe("Semantic search query."),
+  usernames: z.string().optional().describe("Comma-separated Twitter usernames to filter to."),
+  sources: 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: z.number().optional().describe("Result offset for pagination."),
+  size: z.number().optional().describe("Page size."),
+  languages: z.string().optional().describe("Comma-separated language codes (e.g. `en,zh`)."),
+  sort_by: 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: z.enum(["short", "long", "thread", "article"]).optional().describe("Filter by tweet length category."),
+  tweet_type: z.enum(["tweet", "quote", "reply"]).optional().describe("Filter by tweet shape."),
+  sentiment_type: z.enum(["bullish", "bearish", "neutral"]).optional().describe("Filter by Kaito's sentiment classification."),
+  author_type: z.enum(["Organization", "Individual"]).optional().describe("Filter by author classification."),
+  min_bookmark_count: z.number().optional().describe("Minimum bookmark count threshold."),
+  max_bookmark_count: z.number().optional().describe("Maximum bookmark count threshold."),
+  min_view_count: z.number().optional().describe("Minimum view count threshold."),
+  max_view_count: z.number().optional().describe("Maximum view count threshold."),
+  min_smart_engagement_count: z.number().optional().describe("Minimum smart-follower engagement count."),
+  max_smart_engagement_count: z.number().optional().describe("Maximum smart-follower engagement count."),
+  min_like_count: z.number().optional().describe("Minimum like count threshold."),
+  max_like_count: z.number().optional().describe("Maximum like count threshold."),
+  min_reply_count: z.number().optional().describe("Minimum reply count threshold."),
+  max_reply_count: z.number().optional().describe("Maximum reply count threshold."),
+  min_retweet_count: z.number().optional().describe("Minimum retweet count threshold."),
+  max_retweet_count: z.number().optional().describe("Maximum retweet count threshold."),
+  min_quote_count: z.number().optional().describe("Minimum quote-tweet count threshold."),
+  max_quote_count: z.number().optional().describe("Maximum quote-tweet count threshold.")
+});
+var TweetEngagementBody = z.object({
+  tweet_id: z.string().min(1).describe("Twitter status ID (numeric, as a string).")
+});
+var FeedsBody = z.object({
+  token: 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: z.number().int().min(1).max(50).optional().describe("Page size (1\u201350).")
+});
+var SentimentBody = z.object({
+  token: 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: z.boolean().optional().describe("Apply Kaito's bot/spam adjustment."),
+  average: z.boolean().optional().describe("Return rolling average vs raw daily values."),
+  gaussian: z.boolean().optional().describe("Apply Gaussian smoothing to the time series."),
+  language: z.enum(["all", "en", "zh", "ko", "others"]).optional().describe("Restrict source tweets to one language."),
+  version: z.enum(["2", "3"]).optional().describe("Sentiment model version. Default to v3 (latest).")
+});
+var EngagementBody = z.object({
+  token: z.string().optional().describe("Token symbol filter. Mutually exclusive with `keyword`."),
+  keyword: 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 = z.object({
+  token: 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: z.string().optional().describe("Optional scope filter (e.g. narrative or category).")
+});
+var MindshareArenaBody = z.object({
+  duration: z.enum(["all", "24h", "48h", "7d", "30d", "3m", "6m", "12m"]).optional().describe("Mindshare measurement window."),
+  language: z.enum(["all", "en", "zh", "ko", "others"]).optional().describe("Restrict tweets to one language."),
+  categories: z.enum(["EXCHANGE", "INFOMKT"]).optional().describe("Restrict to a single arena category."),
+  pre_tge: z.boolean().optional().describe("Include pre-TGE projects in the leaderboard."),
+  ex_official: z.boolean().optional().describe("Exclude tweets from official project accounts."),
+  weighted: z.boolean().optional().describe("Use Kaito's weighted-by-author-influence score."),
+  nft: z.boolean().optional().describe("Restrict to NFT projects.")
+});
+var MindshareDeltaBody = z.object({
+  duration: z.enum(["24h", "48h", "7d", "30d", "3m", "6m", "12m", "all"]).optional().describe("Window over which to compute the mindshare delta."),
+  sort_type: z.enum(["desc", "asc"]).optional().describe("Sort by largest delta first (`desc`) or smallest (`asc`)."),
+  limit: z.number().int().positive().optional().describe("Max projects to return.")
+});
+var MindshareNarrativeBody = z.object({
+  narrative: 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 = z.object({
+  token: z.string().min(1).describe("Token symbol to attribute KOL mindshare to."),
+  duration: z.enum(["24h", "48h", "7d", "30d", "3m", "6m", "12m", "all"]).optional().describe("KOL mindshare window."),
+  top_n: z.number().int().positive().optional().describe("Top N KOLs to return.")
+});
+var EventsBody = z.object({
+  token: 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: z.string().optional().describe("Comma-separated event-type filters."),
+  sources: z.string().optional().describe("Comma-separated source filters."),
+  sort_by: z.enum(["event_date", "project_name", "market_cap", "announcement_date"]).optional().describe("Sort field."),
+  sort_order: sortOrder
+});
+var TwitterUserMetadataBody = z.object({
+  user_id: z.string().min(1).describe("Twitter user ID (numeric, as a string).")
+});
+var MarketSmartFollowingBody = z.object({
+  duration: z.enum(["24h", "48h", "7d", "30d", "all_dates"]).optional().describe("Window for the smart-following analysis."),
+  from: z.number().optional().describe("Result offset for pagination."),
+  sort_by: z.enum(["earliest_time", "smart_followers", "followers_change", "change_ratio"]).optional().describe("Sort field."),
+  sort_order: sortOrder,
+  filter_smart_followers_operator: z.enum(["gte", "lte"]).optional().describe("Comparison operator for `filter_smart_followers_value`."),
+  filter_smart_followers_value: z.number().optional().describe("Threshold for smart-follower count filter."),
+  user_status: z.enum(["new", "existing", "all"]).optional().describe("Filter to newly-tracked vs existing users."),
+  user_tag_individual_or_organization: z.enum(["Individual", "Organization", "all"]).optional().describe("Filter by author classification."),
+  user_type: z.enum(["kkol", "non_kkol", "all"]).optional().describe("Restrict to Kaito KOLs (`kkol`), non-KOLs, or both."),
+  user_web3_relevance: z.enum(["relevant", "irrelevant"]).optional().describe("Restrict to web3-relevant users.")
+});
+var SmartFollowersBody = z.object({
+  user_id: z.string().optional().describe("Twitter user ID (numeric, as a string). Provide this OR `username`."),
+  username: z.string().optional().describe("Twitter handle without the `@`. Provide this OR `user_id`."),
+  date: z.string().optional().describe("ISO 8601 date \u2014 pin the smart-follower snapshot."),
+  mode: 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 = z.object({
+  user_id: z.string().optional().describe("Twitter user ID (numeric, as a string). Provide this OR `username`."),
+  username: z.string().optional().describe("Twitter handle without the `@`. Provide this OR `user_id`."),
+  category: 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 = z.unknown();
+
+export {
+  EntitiesQuery,
+  NarrativesQuery,
+  SearchBody,
+  AdvancedSearchBody,
+  TweetEngagementBody,
+  FeedsBody,
+  SentimentBody,
+  EngagementBody,
+  MentionsBody,
+  MindshareBody,
+  MindshareArenaBody,
+  MindshareDeltaBody,
+  MindshareNarrativeBody,
+  KolMindshareBody,
+  EventsBody,
+  TwitterUserMetadataBody,
+  MarketSmartFollowingBody,
+  SmartFollowersBody,
+  SmartFollowingBody,
+  KaitoResponse,
+  schemas_exports
+};

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunk-PHNEQDUP.js

@@ -0,0 +1,89 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/cryptonews/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  NewsArticle: () => NewsArticle,
+  NewsBody: () => NewsBody,
+  NewsResponse: () => NewsResponse,
+  SentimentBody: () => SentimentBody,
+  SentimentItem: () => SentimentItem,
+  SentimentResponse: () => SentimentResponse,
+  TrendingQuery: () => TrendingQuery,
+  TrendingResponse: () => TrendingResponse,
+  TrendingTicker: () => TrendingTicker
+});
+import { z } from "zod";
+var NewsBody = z.object({
+  tickers: z.string().optional().describe("Comma-separated tickers to filter by (e.g. `BTC,ETH`). Omit for the full feed."),
+  items: z.number().int().min(1).max(100).optional().default(10).describe("Articles per page (1\u2013100)."),
+  page: z.number().int().min(1).optional().default(1).describe("1-based page number for pagination."),
+  sentiment: z.enum(["positive", "negative", "neutral"]).optional().describe("Filter to articles with this sentiment classification."),
+  topic: z.string().optional().describe("Filter by topic tag (e.g. `regulation`, `mining`, `defi`)."),
+  source: z.string().optional().describe("Filter by news outlet (e.g. `coindesk`, `cointelegraph`)."),
+  date: z.string().optional().describe(
+    "Date filter. Accepts presets (`today`, `last7days`, `last30days`) or `MMDDYYYY-MMDDYYYY` ranges."
+  ),
+  sort: z.enum(["rank", "date"]).optional().describe("Sort order \u2014 `rank` for relevance, `date` for newest first.")
+});
+var NewsArticle = z.object({
+  title: z.string(),
+  text: z.string(),
+  url: z.string(),
+  imageUrl: z.string().nullable(),
+  date: z.string(),
+  source: z.string(),
+  sentiment: z.string(),
+  tickers: z.array(z.string()),
+  topics: z.array(z.string()),
+  type: z.string()
+});
+var NewsResponse = z.object({
+  articles: z.array(NewsArticle),
+  totalPages: z.number().nullable()
+});
+var SentimentBody = z.object({
+  tickers: z.string().min(1).describe("Comma-separated tickers to score (e.g. `BTC,ETH,SOL`)."),
+  date: 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 = z.object({
+  ticker: z.string(),
+  sentiment: z.string(),
+  sentimentScore: z.number().nullable(),
+  positive: z.number(),
+  negative: z.number(),
+  neutral: z.number()
+});
+var SentimentResponse = z.array(SentimentItem);
+var TrendingQuery = z.object({
+  date: z.string().optional().describe("Date window \u2014 same format as the sentiment endpoint. Defaults to today.")
+});
+var TrendingTicker = z.object({
+  ticker: z.string(),
+  name: z.string(),
+  totalMentions: z.number(),
+  positiveMentions: z.number(),
+  negativeMentions: z.number(),
+  neutralMentions: z.number(),
+  sentimentScore: z.number().nullable()
+});
+var TrendingResponse = z.array(TrendingTicker);
+
+export {
+  NewsBody,
+  NewsArticle,
+  NewsResponse,
+  SentimentBody,
+  SentimentItem,
+  SentimentResponse,
+  TrendingQuery,
+  TrendingTicker,
+  TrendingResponse,
+  schemas_exports
+};

package/dist/chunk-ROAH5BN3.js

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

package/dist/chunk-VK45O334.js

@@ -0,0 +1,129 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/composite/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  AlphaRadarBody: () => AlphaRadarBody,
+  AlphaRadarComponent: () => AlphaRadarComponent,
+  AlphaRadarResponse: () => AlphaRadarResponse,
+  HealthResponse: () => HealthResponse,
+  MarketSnapshotBody: () => MarketSnapshotBody,
+  MarketSnapshotResponse: () => MarketSnapshotResponse,
+  SignalLabel: () => SignalLabel,
+  WalletXrayBody: () => WalletXrayBody,
+  WalletXrayResponse: () => WalletXrayResponse
+});
+import { z } from "zod";
+var MarketSnapshotBody = z.object({
+  coingeckoId: z.string().min(1).describe("CoinGecko token ID for the price + market-cap component (e.g. `bitcoin`)."),
+  coinglassSymbol: z.string().min(1).describe("CoinGlass coin symbol for the funding + open-interest component (e.g. `BTC`).")
+});
+var MarketSnapshotResponse = z.object({
+  token: z.string(),
+  price: z.object({
+    usd: z.number().nullable(),
+    change24h: z.number().nullable(),
+    marketCap: z.number().nullable(),
+    volume24h: z.number().nullable()
+  }),
+  fearGreed: z.object({
+    value: z.number().nullable(),
+    classification: z.string().nullable()
+  }),
+  funding: z.object({
+    rates: z.array(z.object({ exchange: z.string(), rate: z.number().nullable() }))
+  }).nullable(),
+  openInterest: z.object({
+    totalUsd: z.number().nullable(),
+    byExchange: z.array(z.object({ exchange: z.string(), usd: z.number().nullable() }))
+  }).nullable()
+});
+var AlphaRadarBody = z.object({
+  symbol: z.string().min(1).describe("Coin symbol to score across the alpha-radar signal components (e.g. `BTC`).")
+});
+var SignalLabel = z.enum([
+  "very_bearish",
+  "bearish",
+  "neutral",
+  "bullish",
+  "very_bullish"
+]);
+var AlphaRadarComponent = z.object({
+  score: z.number(),
+  weight: z.number(),
+  signal: SignalLabel
+}).catchall(z.unknown());
+var AlphaRadarResponse = z.object({
+  symbol: z.string(),
+  timestamp: z.string(),
+  score: z.number(),
+  signal: SignalLabel,
+  componentsUsed: z.number(),
+  components: z.record(z.string(), AlphaRadarComponent),
+  errors: z.record(z.string(), z.string()).optional()
+});
+var WalletXrayBody = z.object({
+  address: z.string().min(1).describe("Wallet address to analyze (EVM `0x\u2026` or chain-native format)."),
+  chain: z.string().optional().describe("Chain name to scope the analysis (e.g. `eth`, `base`, `polygon`). Defaults to Ethereum mainnet.")
+});
+var WalletXrayResponse = z.object({
+  address: z.string(),
+  chain: z.string(),
+  profile: z.object({
+    tag: z.string(),
+    netWorthUsd: z.number(),
+    tokenCount: z.number(),
+    nftCount: z.number(),
+    defiPositionCount: z.number(),
+    recentTransferCount: z.number()
+  }),
+  topHoldings: z.array(z.unknown()),
+  recentActivity: z.object({
+    totalTransfers: z.number(),
+    inflows: z.number(),
+    outflows: z.number(),
+    recentInflows: z.array(z.unknown()),
+    recentOutflows: z.array(z.unknown())
+  }),
+  defiPositions: z.array(z.unknown()),
+  nftSummary: z.object({
+    total: z.number(),
+    topCollections: z.array(z.object({ name: z.string(), count: z.number() }))
+  }),
+  errors: z.record(z.string(), z.string().nullable())
+});
+var HealthResponse = z.object({
+  status: z.enum(["ok", "degraded"]),
+  uptime: z.number(),
+  redis: z.boolean(),
+  rateLimit: z.object({
+    limit: z.number(),
+    windowMs: z.number(),
+    used: z.number(),
+    remaining: z.number(),
+    clientIp: z.string()
+  }),
+  services: z.array(
+    z.object({
+      name: z.string(),
+      status: z.enum(["ok", "error"]),
+      latencyMs: z.number(),
+      error: z.string().optional()
+    })
+  )
+});
+
+export {
+  MarketSnapshotBody,
+  MarketSnapshotResponse,
+  AlphaRadarBody,
+  SignalLabel,
+  AlphaRadarComponent,
+  AlphaRadarResponse,
+  WalletXrayBody,
+  WalletXrayResponse,
+  HealthResponse,
+  schemas_exports
+};