@dev.sail.money/sailor 0.0.2-12

package/packages/sdk/dist/intelligence.d.ts

@@ -0,0 +1,923 @@
+/**
+ * Sail Intelligence — https://api.sail.money
+ *
+ * AUTO-GENERATED from the OpenAPI spec at build time.
+ * Do not edit manually — run `pnpm build` to regenerate.
+ *
+ * Spec version : 1.2.0
+ * Generated at : 2026-06-05T12:43:07.205Z
+ */
+export declare const SAIL_INTELLIGENCE_BASE_URL = "https://api.sail.money";
+export declare const SAIL_INTELLIGENCE_DOCS_URL = "https://api.sail.money/docs";
+export interface ActionDetail {
+    action_type: string;
+    protocol: string;
+    amount: string;
+    underlying_amount?: string | null;
+}
+export interface AffectedPosition {
+    vault_address: string;
+    chain: string | null;
+    token: string | null;
+    issues: PositionIssue[];
+}
+export interface AllocationItem {
+    /** Vault contract address receiving allocation. */
+    vault_address: string;
+    /** Chain where the selected vault is deployed. */
+    chain: string;
+    /** Primary deposit token symbol for the selected vault. */
+    token: string;
+    /** Underlying protocol or venue name when available. */
+    protocol?: string | null;
+    /** Recommended portfolio weight for the vault. */
+    weight: number;
+    /** Recommended USD notional allocated to the vault. */
+    value_usd: number;
+    /** Expected APY contribution from the selected vault. */
+    expected_apy: number;
+}
+export interface AllocationRequest {
+    /** Total portfolio value in USD. */
+    portfolio_value_usd: number;
+    /** Market: 'usd' or 'eur'. */
+    market?: string;
+    /** Restrict to these chains. Omit for all chains. */
+    allowed_chains?: string[] | null;
+    /** Maximum number of vault positions. */
+    max_positions?: number;
+    /** Apply Sonar risk filtering. When False, pure yield logic — all market vaults included regardless of risk flags. */
+    sonar_enabled?: boolean;
+}
+export interface AllocationResponse {
+    /** Requested market segment. */
+    market: string;
+    /** Total USD portfolio value used for the allocation run. */
+    total_value_usd: number;
+    /** Recommended institutional allocation across selected vaults. */
+    allocations: AllocationItem[];
+    /** Expected blended APY for the proposed allocation. */
+    expected_portfolio_apy: number;
+    /** Whether Sonar filtering was applied during allocation. */
+    sonar_enabled: boolean;
+    /** UTC timestamp of the latest Sonar pipeline run. */
+    last_pipeline_run: string | null;
+    /** UTC timestamp when the allocation was produced. */
+    checked_at: string;
+}
+export interface BenchmarkResponse {
+    market: string;
+    chain?: string | null;
+    vault_count: number;
+    best_apy: number;
+    worst_apy: number;
+    median_apy: number;
+    mean_apy: number;
+    best_vault?: string | null;
+    sonar_enabled: boolean;
+    last_pipeline_run: string | null;
+    checked_at: string;
+}
+export interface CalldataInfo {
+    contract_address: string;
+    function_name: string;
+    parameters: string[];
+    value: string;
+    protocol: string;
+    description: string;
+}
+export interface CollateralTree {
+    /** Vault deposit token used as the root of the collateral dependency tree. */
+    deposit_token: string;
+    /** Terminal underlying assets reached by the collateral expansion. */
+    primitive_leaves: string[];
+    /** Expanded collateral structure used by Sonar dependency analysis. */
+    collateral_tokens: Record<string, unknown>[];
+    /** UTC timestamp when the collateral tree was last built. */
+    last_built: string;
+}
+export interface ComparePosition {
+    vault_address: string;
+    value_usd: number;
+}
+export interface CompareRequest {
+    /** Current portfolio positions. */
+    current: ComparePosition[];
+    /** Proposed portfolio positions. */
+    proposed: ComparePosition[];
+    /** Market: 'usd' or 'eur'. */
+    market?: string;
+}
+export interface CompareResponse {
+    /** Estimated APY of the current portfolio. */
+    current_portfolio_apy: number;
+    /** Estimated APY of the proposed portfolio. */
+    proposed_portfolio_apy: number;
+    /** APY delta between proposed and current portfolios. */
+    apy_change: number;
+    /** Number of Sonar risk flags in the current portfolio. */
+    current_risk_flags: number;
+    /** Number of Sonar risk flags in the proposed portfolio. */
+    proposed_risk_flags: number;
+    /** Net change in Sonar risk flags between portfolios. */
+    risk_change: number;
+    /** Vault addresses exited by the proposed portfolio. */
+    positions_exited: string[];
+    /** Vault addresses entered by the proposed portfolio. */
+    positions_entered: string[];
+    /** Overall assessment: improvement, degradation, or neutral. */
+    assessment: string;
+    /** UTC timestamp of the latest Sonar pipeline run. */
+    last_pipeline_run: string | null;
+    /** UTC timestamp when the comparison was produced. */
+    checked_at: string;
+}
+export interface Constraint {
+    kind: string;
+    params?: Record<string, unknown>;
+}
+export interface CostBreakdown {
+    /** Cumulative gas costs across all rebalancing events. */
+    gas_total_usd: number;
+    /** Estimated slippage on cross-token swaps. */
+    slippage_total_usd: number;
+    /** Bridge protocol fees for cross-chain moves. */
+    bridge_fees_total_usd: number;
+    /** Sum of all cost components. */
+    total_cost_usd: number;
+    /** Total number of periods the engine ran (checked and potentially rebalanced). */
+    rebalance_events: number;
+    /** Actual position changes executed (subset of rebalance_events that passed the profitability gate). */
+    trades_executed: number;
+    /** Average cost per executed trade. */
+    avg_cost_per_trade_usd: number;
+}
+export interface DepeggedTokens {
+    /** Total number of currently flagged depegged tokens. */
+    count: number;
+    /** Depegged tokens grouped by chain. */
+    by_chain: Record<string, string[]>;
+}
+export interface DetectorClearance {
+    /** Sonar detector name used in the audit trail. */
+    detector: string;
+    /** Detector outcome for the vault: clear or flagged. */
+    status: string;
+    /** Optional detector-specific explanation. */
+    detail?: string | null;
+}
+export interface DisableSource {
+    /** Underlying Sonar detector or disable source that flagged the vault. */
+    source: string;
+    /** Internal Sonar severity tier for this disable source. */
+    tier: number;
+    /** UTC timestamp when the disable source became active. */
+    disabled_at: string;
+}
+export interface DisabledVaults {
+    /** Total number of currently disabled vaults. */
+    count: number;
+    /** All currently disabled vault addresses. */
+    addresses: string[];
+    /** Disabled vault addresses grouped by Sonar source. */
+    by_source: Record<string, string[]>;
+}
+export interface ExecuteRequest {
+    chain_id: number;
+    total_capital: string;
+    token_address: string;
+    current_allocations?: Record<string, string>;
+    protocols?: string[];
+    constraints?: Constraint[];
+    receiver?: string | null;
+    include_forecast?: boolean;
+}
+export interface ExecuteResponse {
+    optimization_result: OptimizationResult;
+    action_plan: ActionDetail[];
+    calldata: CalldataInfo[];
+    swap_required?: SwapRequired[];
+    forecast_unavailable?: boolean | null;
+}
+export interface ExplainRequest {
+    /** Market: 'usd' or 'eur'. */
+    market?: string;
+    portfolio_value_usd: number;
+    max_positions?: number;
+    /** Restrict to a single chain. */
+    chain?: string | null;
+}
+export interface ExplainResponse {
+    allocation: AllocationItem[];
+    reasoning: VaultReasoning[];
+    universe_size: number;
+    filtered_count: number;
+    expected_portfolio_apy: number;
+    last_pipeline_run: string | null;
+    checked_at: string;
+}
+export interface InstitutionalRequest {
+    /** Current portfolio keyed by chain_id. Use '0x0000' as vault address for idle wallet cash. Values may be USD amounts (any > 2.0) or fractions (all ≤ 1.0). Example: {'1': {'0x0000': 50000, '0x9Fb7...': 30000}} */
+    portfolio_input: Record<string, Record<string, number>>;
+    /** Total portfolio value in USD. Required when portfolio_input values are fractions; auto-summed when values are USD amounts. */
+    total_balance?: number | null;
+    /** Market: 'usd' or 'eur'. */
+    client_market?: string;
+    /** Optional vault allowlist override. Accepts ['0x...'] addresses. */
+    client_sources?: string[] | null;
+    /** Executions per day. */
+    daily_executions?: number;
+    /** Max vault positions. */
+    max_positions?: number;
+    /** Allow same-chain token swaps. */
+    allow_swaps?: boolean;
+    /** Allow cross-chain bridges. */
+    allow_bridges?: boolean;
+    /** Lock current chain distribution. */
+    lock_chain_allocations?: boolean;
+    /** Required gain above break-even as a fraction, e.g. 0.05 = 5%. */
+    min_profit_margin?: number;
+    /** Max fraction of pool TVL per position, e.g. 0.01 = 1%. */
+    tvl_concentration_max?: number;
+}
+export interface InstitutionalResponse {
+    /** Recommended weights keyed by chain_id string, then vault address. */
+    address_weights_by_chain: Record<string, Record<string, number>>;
+    /** Requested client market segment. */
+    market: string;
+    /** Total USD portfolio value used for optimization. */
+    total_value_usd: number;
+    /** Expected blended APY for the optimized institutional portfolio. */
+    expected_portfolio_apy: number;
+    /** UTC timestamp of the latest Sonar pipeline run. */
+    last_pipeline_run: string | null;
+    /** UTC timestamp when the optimization response was produced. */
+    checked_at: string;
+}
+export interface OpportunitiesResponse {
+    /** Requested market segment, for example usd or eur. */
+    market: string;
+    /** Optional chain filter applied to the result set. */
+    chain: string | null;
+    /** Number of opportunities returned. */
+    count: number;
+    /** Ranked institutional yield opportunities. */
+    opportunities: YieldOpportunity[];
+    /** Whether Sonar filtering was applied to the result set. */
+    sonar_enabled: boolean;
+    /** UTC timestamp when the response was generated. */
+    checked_at: string;
+}
+export interface OptimizationResult {
+    allocations: ProtocolAllocation[];
+    total_costs: number;
+    weighted_apr_initial: number;
+    weighted_apr_final: number;
+    apr_improvement: number;
+    unallocated_amount?: string;
+}
+export interface PeriodSnapshot {
+    period_index: number;
+    date_offset_days: number;
+    p10_value_usd: number;
+    p50_value_usd: number;
+    p90_value_usd: number;
+    /** Weighted average APY applied in this period. */
+    avg_apy_applied: number;
+    /** Costs deducted during this rebalancing event (P50 path). */
+    costs_incurred_usd: number;
+    /** Number of position changes executed in this period. */
+    trades_executed?: number;
+    /** Vault addresses active in this period. */
+    active_vaults: string[];
+}
+export interface PortfolioCheckResponse {
+    summary: PortfolioSummary;
+    safe: string[];
+    affected: AffectedPosition[];
+    checked_at: string;
+}
+export interface PortfolioPosition {
+    /** Chain name (e.g. 'base', 'arbitrum', 'ethereum'). */
+    chain: string;
+    /** Token symbol (e.g. 'usdc', 'usdt', 'eurc'). */
+    token: string;
+    /** USD value allocated to this chain/token. */
+    amount_usd: number;
+}
+export interface PortfolioSummary {
+    total: number;
+    safe: number;
+    affected: number;
+}
+export interface PortfolioValueCurve {
+    /** 10th-percentile portfolio value at each period. */
+    p10: number[];
+    /** Median (50th-percentile) portfolio value. */
+    p50: number[];
+    /** 90th-percentile portfolio value at each period. */
+    p90: number[];
+    /** Day offsets from simulation start (period boundaries). */
+    dates_days_offset: number[];
+}
+export interface PositionIssue {
+    /** Issue type, for example vault_disabled or token_depegged. */
+    type: string;
+    /** Originating Sonar source or detector for this issue. */
+    source: string;
+    /** Internal Sonar severity tier for the issue. */
+    tier: number;
+    /** Human-readable severity label, for example CRITICAL or WARN. */
+    severity: string;
+    /** UTC timestamp when the issue became active. */
+    disabled_at: string;
+    /** Optional additional context for the issue. */
+    detail?: string | null;
+}
+export interface ProtocolAllocation {
+    protocol: string;
+    allocation: string;
+    apr: number;
+    risk_score?: number | null;
+    forecast_apr?: number[] | null;
+    forecast_apr_sigma?: number[] | null;
+}
+/** CompareResponse without risk-delta fields — used by Engine Raw tier. */
+export interface RawCompareResponse {
+    /** Estimated APY of the current portfolio. */
+    current_portfolio_apy: number;
+    /** Estimated APY of the proposed portfolio. */
+    proposed_portfolio_apy: number;
+    /** APY delta between proposed and current portfolios. */
+    apy_change: number;
+    /** Vault addresses exited by the proposed portfolio. */
+    positions_exited: string[];
+    /** Vault addresses entered by the proposed portfolio. */
+    positions_entered: string[];
+    /** Overall APY assessment: improvement, degradation, or neutral. */
+    assessment: string;
+    /** UTC timestamp of the latest pipeline run used for the comparison. */
+    last_pipeline_run: string | null;
+    /** UTC timestamp when the comparison was produced. */
+    checked_at: string;
+}
+export interface RawOpportunitiesResponse {
+    market: string;
+    chain: string | null;
+    count: number;
+    opportunities: RawYieldOpportunity[];
+    checked_at: string;
+}
+/** YieldOpportunity without risk_flagged — used by Engine Raw tier. */
+export interface RawYieldOpportunity {
+    /** Vault contract address. */
+    vault_address: string;
+    /** Chain where the opportunity is deployed. */
+    chain: string;
+    /** Primary deposit token symbol. */
+    token: string;
+    /** Underlying protocol or venue name when available. */
+    protocol?: string | null;
+    /** Current total APY used for ranking. */
+    apy: number;
+    /** Base APY component. */
+    apy_base?: number | null;
+    /** Reward-token APY component. */
+    apy_reward?: number | null;
+    /** Current total value locked in USD when available. */
+    tvl_usd?: number | null;
+    /** UTC timestamp of the latest APY refresh. */
+    last_updated?: string | null;
+}
+export interface RebalanceMove {
+    /** Vault contract address affected by the rebalance plan. */
+    vault_address: string;
+    /** Chain where the vault is deployed. */
+    chain?: string | null;
+    /** Primary deposit token symbol. */
+    token?: string | null;
+    /** Recommended action: exit, enter, or keep. */
+    action: string;
+    /** Primary reason for the rebalance action. */
+    reason: string;
+    /** Current APY of the position when applicable. */
+    current_apy?: number | null;
+    /** Target APY after the rebalance action when applicable. */
+    target_apy?: number | null;
+    /** USD notional associated with the move. */
+    value_usd: number;
+}
+export interface RebalancePosition {
+    /** Vault contract address in the current portfolio. */
+    vault_address: string;
+    /** Current USD notional held in the vault. */
+    value_usd: number;
+}
+export interface RebalanceRequest {
+    /** Current portfolio positions. */
+    positions: RebalancePosition[];
+    /** Market: 'usd' or 'eur'. */
+    market?: string;
+    max_positions?: number;
+    /** Apply Sonar risk filtering. When False, pure yield logic — all market vaults included regardless of risk flags. */
+    sonar_enabled?: boolean;
+}
+export interface RebalanceResponse {
+    moves: RebalanceMove[];
+    current_portfolio_apy: number;
+    optimal_portfolio_apy: number;
+    apy_improvement: number;
+    last_pipeline_run: string | null;
+    checked_at: string;
+}
+export interface RiskScore {
+    /** Aggregated Sonar severity for the vault. */
+    severity: string;
+    /** List of Sonar detectors contributing to the score. */
+    detectors: string[];
+    /** UTC timestamp of the risk score snapshot. */
+    ts: string;
+}
+export interface RisksSummaryResponse {
+    disabled_vaults: DisabledVaults;
+    depegged_tokens: DepeggedTokens;
+    vault_risk_scores: Record<string, unknown>;
+    last_pipeline_run: string | null;
+    checked_at: string;
+}
+export interface SafeCheckResponse {
+    safe: boolean;
+    vault_address: string;
+    chain?: string | null;
+    token?: string | null;
+    /** Non-empty when safe=False. Values: 'vault_disabled', 'token_depegged'. */
+    reasons?: string[];
+    checked_at: string;
+}
+export interface ScreenRequest {
+    /** Vault contract addresses to screen. Max 200. */
+    addresses: string[];
+}
+export interface ScreenResponse {
+    results: VaultScreenResult[];
+    summary: ScreenSummary;
+    last_pipeline_run: string | null;
+    checked_at: string;
+}
+export interface ScreenSummary {
+    total: number;
+    blocked: number;
+    caution: number;
+    clear: number;
+}
+export interface SimulationCreateResponse {
+    job_id: string;
+    status: string;
+    message: string;
+    poll_url: string;
+}
+export interface SimulationPollResponse {
+    job_id: string;
+    status: string;
+    result?: SimulationResult | null;
+    error?: string | null;
+    checked_at: string;
+}
+export interface SimulationRequest {
+    /** Total initial portfolio size in USD. Use this for a simple single-amount simulation. Mutually exclusive with `portfolio`. */
+    initial_amount?: number | null;
+    /** Per-chain/token allocation. E.g. [{chain:'base',token:'usdc',amount_usd:50000}, {chain:'arbitrum',token:'usdc',amount_usd:30000}]. Overrides `initial_amount` and `chains`/`tokens` filters — the simulation starts from these exact positions. */
+    portfolio?: PortfolioPosition[] | null;
+    /** Forecast horizon in months. */
+    horizon_months: number;
+    /** conservative → low-risk tier (no bridges, ≤2 positions); balanced → mid tier (swaps + bridges, ≤4 positions); aggressive → max tier (full features, ≤5 positions). */
+    strategy?: string;
+    /** Token list to include (e.g. ['usdc', 'usdt']). */
+    tokens?: string[];
+    /** Chain filter (e.g. ['base', 'arbitrum']). Null = all chains. */
+    chains?: string[] | null;
+    /** Allow cross-token swaps during rebalancing. */
+    allow_swaps?: boolean;
+    /** Allow cross-chain bridges during rebalancing. */
+    allow_bridges?: boolean;
+    /** How often the simulator rebalances the portfolio. */
+    rebalance_frequency?: string;
+    /** Restrict simulation to a specific vault allowlist (by vault address). */
+    custom_vaults?: string[] | null;
+    /** Return P10/P90 uncertainty bands alongside the P50 median curve. */
+    confidence_intervals?: boolean;
+    /** Number of Monte Carlo scenarios to run. */
+    monte_carlo_scenarios?: number;
+    /** Override the maximum number of concurrent vault positions. Defaults to the strategy tier value (conservative=2, balanced=4, aggressive=5). Higher values increase diversification but may dilute yield per position. */
+    max_positions?: number | null;
+    /** Override the minimum profit margin required before executing a rebalance move. 0.0 = move whenever there's any gain; 0.2 = require 20%% cost buffer. Defaults to strategy tier value (conservative=0, balanced=0.2, aggressive=0.1). */
+    min_profit_margin?: number | null;
+}
+export interface SimulationResult {
+    job_id: string;
+    status: string;
+    initial_amount: number;
+    horizon_months: number;
+    strategy: string;
+    final_p10_usd: number;
+    final_p50_usd: number;
+    final_p90_usd: number;
+    portfolio_value_curve: PortfolioValueCurve;
+    cost_breakdown: CostBreakdown;
+    /** Annualized return on the P50 path (e.g. 0.087 = 8.7%). */
+    annualized_return_p50: number;
+    scenarios_run: number;
+    created_at: string;
+    completed_at: string;
+    /** Per-period snapshots (P10/P50/P90, APY, costs, active vaults). Included in poll responses. */
+    periods?: PeriodSnapshot[] | null;
+}
+export interface SimulationTimelineResponse {
+    job_id: string;
+    periods: PeriodSnapshot[];
+    checked_at: string;
+}
+export interface SwapRequired {
+    from_chain: number;
+    from_token: string;
+    to_chain: number;
+    to_token: string;
+    amount: string;
+}
+export interface ValidateRequest {
+    vault_address: string;
+    /** Chain name (e.g. 'base'). */
+    chain?: string | null;
+    /** Deposit token symbol (e.g. 'usdc'). */
+    token?: string | null;
+    /** Intended position size in USD. Used to check TVL concentration. */
+    value_usd?: number | null;
+}
+export interface ValidateResponse {
+    /** Whether the proposed position passes Sonar validation. */
+    valid: boolean;
+    /** Vault contract address that was validated. */
+    vault_address: string;
+    /** Resolved chain for the validation result. */
+    chain?: string | null;
+    /** Resolved deposit token for the validation result. */
+    token?: string | null;
+    /** Operational Sonar recommendation: safe_to_enter, blocked, or caution. */
+    recommendation: string;
+    /** Hard risk flags that directly affect the recommendation. */
+    risk_flags?: string[];
+    /** Non-blocking warnings relevant to institutional review. */
+    warnings?: string[];
+    /** UTC timestamp when the validation decision was produced. */
+    checked_at: string;
+}
+export interface VaultReasoning {
+    /** Vault contract address evaluated during the explain run. */
+    vault_address: string;
+    /** Chain where the evaluated vault is deployed. */
+    chain: string;
+    /** Primary deposit token symbol for the evaluated vault. */
+    token: string;
+    /** APY observed for the vault during the explain run. */
+    apy: number;
+    /** Rank of the vault within the evaluated opportunity universe. */
+    apy_rank: number;
+    /** Assigned portfolio weight when selected, otherwise zero. */
+    weight: number;
+    /** Assigned USD notional when selected, otherwise zero. */
+    value_usd: number;
+    /** Whether Engine selected the vault in the proposed allocation. */
+    selected: boolean;
+    /** Whether Sonar flagged the vault during evaluation. */
+    risk_flagged: boolean;
+    /** Per-detector Sonar audit trail for the vault. */
+    sonar_clearance: DetectorClearance[];
+    /** Explicit reasons why the vault was selected or rejected. */
+    selection_reasons: string[];
+}
+export interface VaultRiskResponse {
+    /** Normalized vault contract address. */
+    vault_address: string;
+    /** Human-readable vault name when available. */
+    name?: string | null;
+    /** Chain where the vault is deployed. */
+    chain?: string | null;
+    /** Primary deposit token symbol for the vault. */
+    token?: string | null;
+    /** Whether Sonar currently blocks this vault for institutional use. */
+    is_disabled: boolean;
+    /** Detailed Sonar disable reasons for the vault. */
+    disable_sources?: DisableSource[];
+    /** Tokens on the vault's path currently affected by active risk events. */
+    affected_tokens?: string[];
+    /** Latest Sonar risk score context for the vault. */
+    risk_score?: RiskScore | null;
+    /** Collateral dependency structure used for risk interpretation. */
+    collateral_tree?: CollateralTree | null;
+    /** UTC timestamp of the latest Sonar pipeline run. */
+    last_pipeline_run?: string | null;
+}
+export interface VaultScreenResult {
+    /** Normalized vault contract address that was screened. */
+    vault_address: string;
+    /** Human-readable vault name when available. */
+    name?: string | null;
+    /** Chain where the screened vault is deployed. */
+    chain?: string | null;
+    /** Primary deposit token symbol for the vault. */
+    token?: string | null;
+    /** Institutional Sonar decision tier: blocked, caution, or clear. */
+    risk_tier: string;
+    /** Sonar detectors currently active for this vault. */
+    active_detectors: string[];
+    /** Detailed disable sources behind the decision. */
+    disable_sources?: DisableSource[];
+    /** Optional Sonar risk score context for the screened vault. */
+    risk_score?: RiskScore | null;
+}
+export interface YieldOpportunity {
+    /** Vault contract address. */
+    vault_address: string;
+    /** Chain where the opportunity is deployed. */
+    chain: string;
+    /** Primary deposit token symbol. */
+    token: string;
+    /** Underlying protocol or venue name when available. */
+    protocol?: string | null;
+    /** Current total APY used by Engine for ranking. */
+    apy: number;
+    /** Base APY component. */
+    apy_base?: number | null;
+    /** Reward-token APY component. */
+    apy_reward?: number | null;
+    /** Current total value locked in USD when available. */
+    tvl_usd?: number | null;
+    /** Whether Sonar currently flags the vault. */
+    risk_flagged: boolean;
+    /** UTC timestamp of the latest APY refresh. */
+    last_updated?: string | null;
+}
+export interface YieldSourceItem {
+    /** Yield source contract address. */
+    vault_address: string;
+    /** Chain where the yield source is deployed. */
+    chain: string;
+    /** Protocol and strategy name. */
+    name: string;
+    /** Primary deposit token symbol. */
+    token: string;
+}
+export interface YieldSourcesResponse {
+    /** Number of yield sources returned. */
+    count: number;
+    /** Chain filter applied, if any. */
+    chain?: string | null;
+    /** Token filter applied, if any. */
+    token?: string | null;
+    /** Available yield sources monitored by Sonar. */
+    sources: YieldSourceItem[];
+    /** UTC timestamp when the response was generated. */
+    checked_at: string;
+}
+export interface _NonceReq {
+    address: string;
+}
+export interface _VerifyReq {
+    message: string;
+    signature: string;
+}
+export interface PortfolioCheckRequest {
+}
+export interface SailIntelligenceOptions {
+    /** API key — passed as `X-API-Key` header. */
+    apiKey: string;
+    /** Override the base URL (for testing / staging). */
+    baseUrl?: string;
+}
+export declare class SailIntelligence {
+    private readonly _base;
+    private readonly _headers;
+    constructor(opts: SailIntelligenceOptions);
+    private _get;
+    private _post;
+    /**
+     * All available yield sources
+     * Returns all yield sources monitored by Sail Intelligence Sonar. Filter by chain or token to narrow the result set.
+     */
+    vaultSources(query?: {
+        chain?: string;
+        token?: string;
+    }): Promise<YieldSourcesResponse>;
+    /**
+     * Single yield source risk intelligence
+     * Returns Sail Intelligence Sonar risk intelligence for a single yield source. Includes active disable flags, affected tokens, risk score context, and the collateral dependency tree used for institutional review workflows.
+     */
+    vault(vaultAddress: string): Promise<VaultRiskResponse>;
+    /**
+     * Quick yield source safety decision
+     * Returns a single operational answer for institutional workflows: is this yield source currently safe to interact with. Checks both the source-level kill switch and deposit-token depeg status. For full Sonar context use GET /v1/vault/{address}.
+     */
+    vaultSafe(vaultAddress: string, query?: {
+        chain?: string;
+        token?: string;
+    }): Promise<SafeCheckResponse>;
+    /**
+     * Portfolio risk check
+     * Given a list of institutional positions (vault address plus optional chain/token), returns which are currently affected by active Sonar risk signals (vault disabled or deposit token depegged). Maximum 500 positions per request.
+     */
+    portfolioCheck(body: PortfolioCheckRequest): Promise<PortfolioCheckResponse>;
+    /**
+     * Sonar global risk snapshot
+     * Returns a full Sonar monitoring snapshot of all currently active risk flags: disabled vault addresses (with source breakdown and cooldown state), depegged tokens per chain, per-vault risk scores, and the timestamp of the last institutional monitoring pipeline run.
+     */
+    risksSummary(): Promise<RisksSummaryResponse>;
+    /**
+     * Institutional yield opportunities
+     * Returns the top available institutional yield opportunities for a given market, pre-filtered by Sonar risk signals. Disabled yield sources and depegged tokens are excluded by default. Results are sorted by APY descending.
+     */
+    engineOpportunities(query?: {
+        market?: string;
+        chain?: string;
+        limit?: string;
+        include_disabled?: string;
+    }): Promise<OpportunitiesResponse>;
+    /**
+     * Institutional market APY benchmark
+     * Returns APY statistics for all Sonar-clean vaults in a given market. Useful for benchmarking institutional portfolios against the currently available Sonar-cleared yield universe.
+     */
+    engineBenchmark(query?: {
+        market?: string;
+        chain?: string;
+    }): Promise<BenchmarkResponse>;
+    /**
+     * Institutional allocation recommendation
+     * Returns a recommended allocation across top-APY yield sources for a given portfolio value. Applies Sonar risk filters so disabled yield sources and depegged tokens are excluded. Uses equal-weight greedy allocation (top N by APY). For deeper execution-layer optimisation, use the institutional execution stack directly.
+     */
+    engineAllocate(body: AllocationRequest): Promise<AllocationResponse>;
+    /**
+     * Institutional rebalancing recommendation
+     * Given current institutional yield source positions, computes a rebalancing plan: which positions to exit (risk-flagged, depegged, or suboptimal APY), which to keep, and which new positions to enter. Returns current versus optimal APY and the improvement delta.
+     */
+    engineRebalance(body: RebalanceRequest): Promise<RebalanceResponse>;
+    /**
+     * Allocation audit trail
+     * Returns the recommended allocation alongside a full audit trail: APY rank of each vault considered, per-detector Sonar clearance status, and explicit reasons why each vault was selected or rejected. Designed for compliance review and institutional due diligence.
+     */
+    engineExplain(body: ExplainRequest): Promise<ExplainResponse>;
+    /**
+     * Institutional portfolio comparison
+     * Compares a current institutional portfolio against a proposed portfolio side by side. Returns APY delta, Sonar risk delta, which positions were exited or entered, and an overall assessment (improvement / degradation / neutral).
+     */
+    engineCompare(body: CompareRequest): Promise<CompareResponse>;
+    /**
+     * Institutional portfolio optimization
+     * Accepts a current portfolio keyed by chain_id and returns an APY-optimized allocation across authorized vaults. Applies Sonar risk filters and the client's vault allowlist. Mirrors the contract of the fungi-core institutional_endpoint script.
+     */
+    engineInstitutional(body: InstitutionalRequest): Promise<InstitutionalResponse>;
+    /**
+     * Allocation with execution-ready calldata
+     * Runs the institutional optimisation **and** returns the on-chain transaction batch (withdraws → approvals → deposits) needed to reach the target portfolio. Calldata is rendered from the live vault catalog — no per-protocol code paths. Designed for partners running automated DeFi treasury workflows (Ampli, etc.).
+     */
+    engineExecute(body: ExecuteRequest): Promise<ExecuteResponse>;
+    /**
+     * Live protocol catalog (APY + TVL) for a chain × token
+     * Returns every active vault we monitor for this chain + token with its current APY, TVL, and (when available) numeric risk score. Shaped to match the discovery feed in Ampli §5.3 — partners can consume it directly without an adapter.
+     */
+    engineProtocols(chainId: string, tokenAddress: string): Promise<unknown>;
+    /**
+     * Yield opportunities (custom risk)
+     * All available institutional yield sources for a given market sorted by APY. No Sonar risk filtering is applied, so all vaults are included regardless of risk status. Sonar signals are not exposed; clients apply their own risk logic.
+     */
+    engineRawOpportunities(query?: {
+        market?: string;
+        chain?: string;
+        limit?: string;
+    }): Promise<RawOpportunitiesResponse>;
+    /**
+     * Market APY benchmark (custom risk)
+     * APY statistics across all vaults in a market, including Sonar-flagged ones. Useful for institutional teams that want the full yield landscape without Sonar filtering.
+     */
+    engineRawBenchmark(query?: {
+        market?: string;
+        chain?: string;
+    }): Promise<BenchmarkResponse>;
+    /**
+     * Allocation recommendation (custom risk)
+     * Recommended allocation across top-APY vaults with no Sonar risk filtering. Allocates purely by APY. Clients apply their own institutional risk layer.
+     */
+    engineRawAllocate(body: AllocationRequest): Promise<AllocationResponse>;
+    /**
+     * Rebalancing recommendation (custom risk)
+     * Rebalancing recommendation with no Sonar risk filtering. Exit reasons are APY-based only — no risk_flagged or token_depegged exits.
+     */
+    engineRawRebalance(body: RebalanceRequest): Promise<RebalanceResponse>;
+    /**
+     * Portfolio comparison (custom risk)
+     * Side-by-side institutional portfolio comparison with no Sonar risk filtering. Assessment is based purely on APY delta. Sonar risk delta fields are not returned.
+     */
+    engineRawCompare(body: CompareRequest): Promise<RawCompareResponse>;
+    /**
+     * Institutional Sonar screening
+     * Screen up to 200 vault addresses in a single call. Returns a per-vault risk tier (blocked / caution / clear), the active Sonar detectors that flagged each vault, and a full disable-source breakdown. Designed for due diligence workflows and compliance audit trails.
+     */
+    sonarScreen(body: ScreenRequest): Promise<ScreenResponse>;
+    /**
+     * Institutional pre-trade validation
+     * Validates a proposed institutional vault position before execution. Checks the vault kill-switch, deposit token depeg status, and optionally TVL concentration if a position size is provided. Returns an operational recommendation: safe_to_enter, caution, or blocked.
+     */
+    sonarValidate(body: ValidateRequest): Promise<ValidateResponse>;
+    /**
+     * TCN model info
+     * Returns metadata about the currently loaded APY predictor: whether it is a trained neural model or the heuristic fallback, training timestamp, vault count, and validation loss.
+     */
+    simulationModelInfo(): Promise<unknown>;
+    /**
+     * Available chain/token combinations
+     * Returns live chain→token mapping derived from vault data in apy_data.
+     */
+    simulationChains(): Promise<unknown>;
+    /**
+     * Create portfolio simulation
+     * Queues a simulation of portfolio performance over the specified horizon. Uses TCN-predicted APY distributions and models gas, slippage, and bridge costs at every rebalancing event. Poll the returned `poll_url` for results.
+     */
+    simulation(body: SimulationRequest): Promise<unknown>;
+    /**
+     * List simulations
+     * Returns recent simulation jobs for the authenticated client, newest first.
+     */
+    simulations(query?: {
+        limit?: string;
+    }): Promise<[]>;
+    /**
+     * Poll simulation result
+     * Returns the current status of a simulation job. When `status` is `complete`, the `result` field contains the full P10/P50/P90 portfolio value curves and cost breakdown. Typical completion time: 5–15 seconds.
+     */
+    getSimulation(jobId: string): Promise<SimulationPollResponse>;
+    /**
+     * Delete simulation
+     * Permanently deletes a simulation job and its results.
+     */
+    deleteSimulation(jobId: string): Promise<unknown>;
+    /**
+     * Period-by-period simulation breakdown
+     * Returns a snapshot for every rebalancing period: P10/P50/P90 values, APY applied, costs incurred, and active vaults.
+     */
+    simulationTimeline(jobId: string): Promise<SimulationTimelineResponse>;
+    /**
+     * Get Pricing
+     * Public pricing manifest — backs `/pricing` UI + `/docs` price badges.
+     */
+    pricing(): Promise<unknown>;
+    /**
+     * Get Pricing Quote
+     * Pre-flight price + accepts entries — lets clients dry-run x402 flows.
+     */
+    pricingQuote(query?: {
+        route?: string;
+        horizon_months?: string;
+        positions?: string;
+        addresses?: string;
+    }): Promise<unknown>;
+    /**
+     * Siwe Nonce
+     */
+    billingSiweNonce(body: _NonceReq): Promise<unknown>;
+    /**
+     * Siwe Verify
+     */
+    billingSiweVerify(body: _VerifyReq): Promise<unknown>;
+    /**
+     * Logout
+     */
+    billingLogout(): Promise<unknown>;
+    /**
+     * Billing Me
+     */
+    billingMe(): Promise<unknown>;
+    /**
+     * Billing Keys
+     */
+    billingKeys(): Promise<unknown>;
+    /**
+     * Billing Payments
+     */
+    billingPayments(query?: {
+        from?: string;
+        to?: string;
+        limit?: string;
+        offset?: string;
+    }): Promise<unknown>;
+    /**
+     * Facilitator Verify
+     */
+    facilitatorVerify(): Promise<unknown>;
+    /**
+     * Facilitator Settle
+     */
+    facilitatorSettle(): Promise<unknown>;
+    /**
+     * Facilitator Supported
+     */
+    facilitatorSupported(): Promise<unknown>;
+}
+//# sourceMappingURL=intelligence.d.ts.map