@noya-ai/data-server-schemas 0.1.0

package/dist/chunk-W5SLY2ZT.js

@@ -0,0 +1,134 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/geckoterminal/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  PoolOhlcvBody: () => PoolOhlcvBody,
+  PoolOhlcvCandle: () => PoolOhlcvCandle,
+  PoolOhlcvResponse: () => PoolOhlcvResponse,
+  PoolTrade: () => PoolTrade,
+  PoolTradesBody: () => PoolTradesBody,
+  PoolTradesResponse: () => PoolTradesResponse,
+  TokenInfoBody: () => TokenInfoBody,
+  TokenInfoItem: () => TokenInfoItem,
+  TokenInfoResponse: () => TokenInfoResponse,
+  TokenPool: () => TokenPool,
+  TokenPoolsBody: () => TokenPoolsBody,
+  TokenPoolsResponse: () => TokenPoolsResponse,
+  TrendingPool: () => TrendingPool,
+  TrendingPoolsResponse: () => TrendingPoolsResponse
+});
+import { z } from "zod";
+var Network = z.string().min(1).describe("GeckoTerminal network slug (e.g. `eth`, `bsc`, `base`, `arbitrum`).");
+var TokenPoolsBody = z.object({
+  network: Network,
+  tokenAddress: z.string().min(1).describe("Token contract address on `network`. Returns the pools that include it."),
+  page: z.number().int().min(1).optional().default(1).describe("1-based page number \u2014 GeckoTerminal returns up to 20 pools per page.")
+});
+var TokenPool = z.object({
+  poolAddress: z.string(),
+  name: z.string(),
+  dex: z.string(),
+  priceUsd: z.string().nullable(),
+  priceNative: z.string().nullable(),
+  volume24h: z.number().nullable(),
+  reserveUsd: z.number().nullable(),
+  priceChangePercentage: z.object({
+    m5: z.string().nullable(),
+    h1: z.string().nullable(),
+    h6: z.string().nullable(),
+    h24: z.string().nullable()
+  }),
+  transactions: z.object({
+    buys24h: z.number().nullable(),
+    sells24h: z.number().nullable()
+  })
+});
+var TokenPoolsResponse = z.array(TokenPool);
+var PoolOhlcvBody = z.object({
+  network: Network,
+  poolAddress: z.string().min(1).describe("DEX pool contract address on `network`."),
+  timeframe: z.enum(["day", "hour", "minute"]).optional().default("day").describe("Candle resolution unit."),
+  aggregate: 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: z.number().int().min(1).max(1e3).optional().default(100).describe("Number of candles to return (1\u20131000)."),
+  beforeTimestamp: z.number().optional().describe("Unix epoch seconds \u2014 return candles strictly before this time. Use for pagination backwards in history.")
+});
+var PoolOhlcvCandle = z.object({
+  timestamp: z.number(),
+  open: z.number(),
+  high: z.number(),
+  low: z.number(),
+  close: z.number(),
+  volumeUsd: z.number()
+});
+var PoolOhlcvResponse = z.array(PoolOhlcvCandle);
+var PoolTradesBody = z.object({
+  network: Network,
+  poolAddress: z.string().min(1).describe("DEX pool contract address on `network`."),
+  tradeVolumeInUsdGreaterThan: z.number().optional().describe("Drop trades below this USD-equivalent volume threshold. Useful for filtering dust/wash trades.")
+});
+var PoolTrade = z.object({
+  blockTimestamp: z.string(),
+  txHash: z.string(),
+  kind: z.string(),
+  volumeUsd: z.string().nullable(),
+  fromTokenAmount: z.string(),
+  toTokenAmount: z.string(),
+  fromTokenAddress: z.string(),
+  toTokenAddress: z.string(),
+  priceFromInUsd: z.string().nullable(),
+  priceToInUsd: z.string().nullable(),
+  txFromAddress: z.string()
+});
+var PoolTradesResponse = z.array(PoolTrade);
+var TrendingPool = z.object({
+  poolAddress: z.string(),
+  name: z.string(),
+  network: z.string(),
+  dex: z.string(),
+  priceUsd: z.string().nullable(),
+  priceChangeH24: z.string().nullable(),
+  volume24h: z.number().nullable(),
+  reserveUsd: z.number().nullable()
+});
+var TrendingPoolsResponse = z.array(TrendingPool);
+var TokenInfoBody = z.object({
+  network: Network,
+  addresses: z.array(z.string().min(1)).min(1).max(30).describe("Token contract addresses on `network` (1\u201330 per request). Batched lookup."),
+  includeTopPools: z.boolean().optional().default(true).describe("Include each token's top pools in the response. Set false to slim down the payload.")
+});
+var TokenInfoItem = z.object({
+  address: z.string(),
+  name: z.string(),
+  symbol: z.string(),
+  decimals: z.number(),
+  totalSupply: z.string().nullable(),
+  priceUsd: z.string().nullable(),
+  marketCapUsd: z.string().nullable(),
+  fdvUsd: z.string().nullable(),
+  imageUrl: z.string().nullable(),
+  coingeckoCoinId: z.string().nullable(),
+  volume24h: z.number().nullable(),
+  topPools: z.array(z.object({ address: z.string(), name: z.string(), dex: z.string() }))
+});
+var TokenInfoResponse = z.array(TokenInfoItem);
+
+export {
+  TokenPoolsBody,
+  TokenPool,
+  TokenPoolsResponse,
+  PoolOhlcvBody,
+  PoolOhlcvCandle,
+  PoolOhlcvResponse,
+  PoolTradesBody,
+  PoolTrade,
+  PoolTradesResponse,
+  TrendingPool,
+  TrendingPoolsResponse,
+  TokenInfoBody,
+  TokenInfoItem,
+  TokenInfoResponse,
+  schemas_exports
+};

package/dist/chunk-ZP2HSALI.js

@@ -0,0 +1,150 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/moralis/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  DefiPosition: () => DefiPosition,
+  DefiPositionsBody: () => DefiPositionsBody,
+  DefiPositionsResponse: () => DefiPositionsResponse,
+  NftHoldingsBody: () => NftHoldingsBody,
+  NftHoldingsResponse: () => NftHoldingsResponse,
+  NftItem: () => NftItem,
+  TokenTransfer: () => TokenTransfer,
+  TransfersBody: () => TransfersBody,
+  TransfersResponse: () => TransfersResponse,
+  WalletBody: () => WalletBody,
+  WalletResponse: () => WalletResponse,
+  WalletTokenBalance: () => WalletTokenBalance
+});
+import { z } from "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 = 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 = z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("EVM-style 0x-prefixed 40-hex-char address.");
+var WalletBody = z.object({
+  address: evmAddress,
+  chain: evmChainId.optional(),
+  toBlock: z.number().int().optional().describe("Snapshot the wallet at this block height. Omit for the current head.")
+});
+var WalletTokenBalance = z.object({
+  tokenAddress: z.string().nullable(),
+  name: z.string(),
+  symbol: z.string(),
+  decimals: z.number(),
+  balance: z.string(),
+  balanceFormatted: z.string(),
+  usdPrice: z.number().nullable(),
+  usdValue: z.number().nullable(),
+  portfolioPercentage: z.number(),
+  nativeToken: z.boolean(),
+  logo: z.string().nullable()
+});
+var WalletResponse = z.object({
+  address: z.string(),
+  totalNetworthUsd: z.string(),
+  chains: z.array(
+    z.object({
+      chain: z.string(),
+      networthUsd: z.string(),
+      nativeBalanceFormatted: z.string(),
+      tokenBalanceUsd: z.string()
+    })
+  ),
+  tokens: z.array(WalletTokenBalance)
+});
+var TransfersBody = z.object({
+  address: evmAddress,
+  chain: evmChainId.optional(),
+  limit: z.number().max(100).default(50).describe("Transfers per page (max 100)."),
+  fromDate: z.string().optional().describe("ISO 8601 (or YYYY-MM-DD) start date \u2014 only return transfers after this date."),
+  toDate: z.string().optional().describe("ISO 8601 (or YYYY-MM-DD) end date \u2014 only return transfers before this date."),
+  cursor: z.string().optional().describe("Opaque pagination cursor from the previous response. Omit for page 1.")
+});
+var TokenTransfer = z.object({
+  tokenAddress: z.string(),
+  tokenName: z.string().nullable(),
+  tokenSymbol: z.string().nullable(),
+  tokenDecimals: z.number(),
+  fromAddress: z.string(),
+  toAddress: z.string(),
+  value: z.string(),
+  valueFormatted: z.string().nullable(),
+  blockTimestamp: z.string(),
+  blockNumber: z.string(),
+  transactionHash: z.string()
+});
+var TransfersResponse = z.object({
+  transfers: z.array(TokenTransfer),
+  cursor: z.string().nullable()
+});
+var DefiPositionsBody = z.object({
+  address: evmAddress,
+  chain: evmChainId.optional()
+});
+var DefiPosition = z.object({
+  protocolName: z.string().nullable(),
+  protocolId: z.string().nullable(),
+  protocolUrl: z.string().nullable(),
+  protocolLogo: z.string().nullable(),
+  label: z.string().nullable(),
+  balanceUsd: z.number().nullable(),
+  totalUnclaimedUsdValue: z.number().nullable(),
+  tokens: z.array(z.unknown())
+});
+var DefiPositionsResponse = z.array(DefiPosition);
+var NftHoldingsBody = z.object({
+  address: evmAddress,
+  chain: evmChainId.optional(),
+  limit: z.number().max(100).default(50).describe("NFTs per page (max 100)."),
+  cursor: z.string().optional().describe("Opaque pagination cursor from the previous response. Omit for page 1.")
+});
+var NftItem = z.object({
+  tokenAddress: z.string(),
+  tokenId: z.string(),
+  contractType: z.string().nullable(),
+  name: z.string().nullable(),
+  symbol: z.string().nullable(),
+  tokenUri: z.string().nullable(),
+  amount: z.number().nullable(),
+  ownerOf: z.string().nullable(),
+  possibleSpam: z.boolean(),
+  metadata: z.unknown().nullable()
+});
+var NftHoldingsResponse = z.object({
+  nfts: z.array(NftItem),
+  cursor: z.string().nullable()
+});
+
+export {
+  WalletBody,
+  WalletTokenBalance,
+  WalletResponse,
+  TransfersBody,
+  TokenTransfer,
+  TransfersResponse,
+  DefiPositionsBody,
+  DefiPosition,
+  DefiPositionsResponse,
+  NftHoldingsBody,
+  NftItem,
+  NftHoldingsResponse,
+  schemas_exports
+};

package/dist/chunk-ZTOGXNAW.js

@@ -0,0 +1,198 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/coinglass/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  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
+});
+import { z } from "zod";
+var symbol = z.string().transform((s) => s.toUpperCase()).describe("Coin symbol, uppercased (e.g. `BTC`, `ETH`).");
+var intervalEnum = 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 = z.enum(["4h", "6h", "8h", "12h", "1d", "1w"]).default("4h").describe("Aggregation window for the snapshot.");
+var FundingRatesBody = z.object({
+  symbol: symbol.optional()
+});
+var FundingRateItem = z.object({
+  symbol: z.string(),
+  exchange: z.string(),
+  fundingRate: z.number().nullable(),
+  fundingRateInterval: z.number().nullable(),
+  nextFundingTime: z.number().nullable()
+});
+var FundingRatesResponse = z.array(FundingRateItem);
+var OpenInterestBody = z.object({ symbol });
+var OpenInterestItem = z.object({
+  exchange: z.string(),
+  symbol: z.string(),
+  openInterestUsd: z.number().nullable(),
+  openInterestQuantity: z.number().nullable(),
+  coinMarginUsd: z.number().nullable(),
+  stablecoinMarginUsd: z.number().nullable(),
+  changePercent5m: z.number().nullable(),
+  changePercent15m: z.number().nullable(),
+  changePercent30m: z.number().nullable(),
+  changePercent1h: z.number().nullable(),
+  changePercent4h: z.number().nullable(),
+  changePercent24h: z.number().nullable()
+});
+var OpenInterestResponse = z.array(OpenInterestItem);
+var LiquidationsBody = z.object({
+  symbol: symbol.optional()
+});
+var LiquidationItem = z.object({
+  symbol: z.string(),
+  liquidationUsd24h: z.number().nullable(),
+  longLiquidationUsd24h: z.number().nullable(),
+  shortLiquidationUsd24h: z.number().nullable(),
+  liquidationUsd12h: z.number().nullable(),
+  longLiquidationUsd12h: z.number().nullable(),
+  shortLiquidationUsd12h: z.number().nullable(),
+  liquidationUsd4h: z.number().nullable(),
+  longLiquidationUsd4h: z.number().nullable(),
+  shortLiquidationUsd4h: z.number().nullable(),
+  liquidationUsd1h: z.number().nullable(),
+  longLiquidationUsd1h: z.number().nullable(),
+  shortLiquidationUsd1h: z.number().nullable()
+});
+var LiquidationsResponse = z.array(LiquidationItem);
+var LongShortRatioBody = z.object({
+  symbol: symbol.default("BTC"),
+  range: rangeEnum
+});
+var LongShortExchangeItem = z.object({
+  exchange: z.string(),
+  buyRatio: z.number().nullable(),
+  sellRatio: z.number().nullable(),
+  buyVolUsd: z.number().nullable(),
+  sellVolUsd: z.number().nullable()
+});
+var LongShortRatioResponse = z.object({
+  symbol: z.string(),
+  buyRatio: z.number().nullable(),
+  sellRatio: z.number().nullable(),
+  buyVolUsd: z.number().nullable(),
+  sellVolUsd: z.number().nullable(),
+  exchanges: z.array(LongShortExchangeItem)
+});
+var SupportedListResponse = z.array(z.string());
+var ExchangePairsBody = z.object({
+  symbol: symbol.optional(),
+  exchange: z.string().optional().describe("Filter to a single exchange (e.g. `Binance`). Returns all when omitted.")
+});
+var ExchangePairItem = z.object({
+  exchange: z.string(),
+  instrumentId: z.string(),
+  baseAsset: z.string(),
+  quoteAsset: z.string(),
+  settlementCurrency: z.string(),
+  maxLeverage: z.number().nullable(),
+  fundingInterval: z.number().nullable()
+});
+var ExchangePairsResponse = z.array(ExchangePairItem);
+var LiquidationsByExchangeBody = z.object({
+  symbol: symbol.default("BTC"),
+  range: rangeEnum
+});
+var LiquidationByExchangeItem = z.object({
+  exchange: z.string(),
+  liquidationUsd: z.number().nullable(),
+  longLiquidationUsd: z.number().nullable(),
+  shortLiquidationUsd: z.number().nullable()
+});
+var LiquidationsByExchangeResponse = z.array(LiquidationByExchangeItem);
+var historyBody = z.object({
+  exchange: z.string().default("Binance").describe("Exchange to pull historical data from."),
+  symbol: symbol.default("BTCUSDT"),
+  interval: intervalEnum,
+  limit: z.number().int().min(1).max(4500).default(100).describe("Number of historical points to return (1\u20134500)."),
+  startTime: z.number().optional().describe("Unix epoch ms \u2014 start of the time window. Omit to use `limit` newest points."),
+  endTime: 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 = z.object({
+  time: z.number(),
+  open: z.number(),
+  high: z.number(),
+  low: z.number(),
+  close: z.number()
+});
+var OhlcCandleResponse = z.array(OhlcCandle);
+var LiquidationHistoryItem = z.object({
+  time: z.number(),
+  longLiquidationUsd: z.number(),
+  shortLiquidationUsd: z.number()
+});
+var LiquidationHistoryResponse = z.array(LiquidationHistoryItem);
+var LongShortRatioHistoryItem = z.object({
+  time: z.number(),
+  longPercent: z.number(),
+  shortPercent: z.number(),
+  longShortRatio: z.number()
+});
+var LongShortRatioHistoryResponse = z.array(LongShortRatioHistoryItem);
+
+export {
+  FundingRatesBody,
+  FundingRateItem,
+  FundingRatesResponse,
+  OpenInterestBody,
+  OpenInterestItem,
+  OpenInterestResponse,
+  LiquidationsBody,
+  LiquidationItem,
+  LiquidationsResponse,
+  LongShortRatioBody,
+  LongShortExchangeItem,
+  LongShortRatioResponse,
+  SupportedListResponse,
+  ExchangePairsBody,
+  ExchangePairItem,
+  ExchangePairsResponse,
+  LiquidationsByExchangeBody,
+  LiquidationByExchangeItem,
+  LiquidationsByExchangeResponse,
+  FundingRateHistoryBody,
+  OpenInterestHistoryBody,
+  LiquidationHistoryBody,
+  LongShortRatioHistoryBody,
+  OhlcCandle,
+  OhlcCandleResponse,
+  LiquidationHistoryItem,
+  LiquidationHistoryResponse,
+  LongShortRatioHistoryItem,
+  LongShortRatioHistoryResponse,
+  schemas_exports
+};

package/dist/coingecko/schemas.cjs

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

package/dist/coingecko/schemas.d.cts

@@ -0,0 +1,2 @@
+import 'zod';
+export { C as ContractAddress, O as OhlcvBody, a as OhlcvCandle, b as OhlcvResponse, P as PriceAtDateBody, c as PriceBody, d as PriceHistoryBody, e as PriceHistoryResponse, f as PricePoint, g as PriceResponse, h as PriceSnapshot, S as SearchBody, i as SearchResponse, j as SearchResult, T as TokenInfo, k as TokenInfoBody, l as TokenPrice, m as TrendingResponse, n as TrendingToken } from '../schemas-Cu7LkQN1.cjs';

package/dist/coingecko/schemas.d.ts

@@ -0,0 +1,2 @@
+import 'zod';
+export { C as ContractAddress, O as OhlcvBody, a as OhlcvCandle, b as OhlcvResponse, P as PriceAtDateBody, c as PriceBody, d as PriceHistoryBody, e as PriceHistoryResponse, f as PricePoint, g as PriceResponse, h as PriceSnapshot, S as SearchBody, i as SearchResponse, j as SearchResult, T as TokenInfo, k as TokenInfoBody, l as TokenPrice, m as TrendingResponse, n as TrendingToken } from '../schemas-Cu7LkQN1.js';