finance-query 3.0.0

# Code generated by `cargo soothfast sdk gen`. DO NOT EDIT.
# mypy: disable-error-code="no-any-return"
"""Sync and async clients for finance-query."""
from __future__ import annotations

import typing

from . import models
from ._runtime import AsyncPager, AsyncTransport, SyncPager, Transport, path_seg, query_of, to_wire
from ._server import EmbedConfig, embedded_base_url

DEFAULT_BASE_URL = "https://finance-query.com"
EMBED = EmbedConfig(
    binary="finance-query-server",
    args=(),
    base_url_env="FINANCE_QUERY_BASE_URL",
    bin_env="FINANCE_QUERY_SERVER_BIN",
    env=(
        ("HOST", "127.0.0.1"),
        ("PORT", "0"),
    ),
)


class ServerEnv(typing.TypedDict, total=False):
    """Environment for the bundled server.

    Every key is optional, and the names are the server's own — the same ones a deployment sets.
    """

    # Server Configuration
    # Defaults to "8000".
    PORT: str

    # Bind address. 0.0.0.0 serves every interface; an SDK-spawned server sets
    # 127.0.0.1 so nothing off the machine can reach it
    # Defaults to "0.0.0.0".
    HOST: str

    # Logging
    # Options: DEBUG, INFO, WARNING, ERROR
    # Defaults to "INFO".
    LOG_LEVEL: str

    # Options: json, text
    # Defaults to "json".
    LOG_FORMAT: str

    # Redis Cache (optional)
    # Unset unless you set it.
    REDIS_URL: str

    # Rate Limiting
    # Requests per minute, applied independently per client IP (default: 600 = 10 req/sec)
    # Defaults to "600".
    RATE_LIMIT_PER_MINUTE: str

    # API Defaults
    # Options: 1m, 5m, 15m, 30m, 1h, 1d, 1wk, 1mo, 3mo
    # Defaults to "1d".
    DEFAULT_INTERVAL: str

    # Options: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max
    # Defaults to "1mo".
    DEFAULT_RANGE: str

    # Default Query Limits
    # Defaults to "5".
    RECOMMENDATIONS_LIMIT: str

    # Defaults to "10".
    SEARCH_HITS: str

    # Defaults to "25".
    SCREENERS_COUNT: str

    # SEC EDGAR Integration (optional)
    # Contact email required by SEC - included in User-Agent header
    # Leave commented out to disable EDGAR endpoints
    # Unset unless you set it.
    EDGAR_EMAIL: str

    # FRED API Integration (optional)
    # Free API key from https://fred.stlouisfed.org/docs/api/api_key.html
    # Leave commented out to disable /v2/fred/* endpoints
    # Note: If running a public server, your terms of use must state that users are bound
    # by the FRED API Terms of Use: https://fred.stlouisfed.org/docs/api/terms_of_use.html
    # Unset unless you set it.
    FRED_API_KEY: str

    # Polygon.io - https://polygon.io/dashboard/api-keys
    # Unset unless you set it.
    POLYGON_API_KEY: str

    # Financial Modeling Prep - https://site.financialmodelingprep.com/developer/docs
    # Unset unless you set it.
    FMP_API_KEY: str

    # Alpha Vantage - https://www.alphavantage.co/support/#api-key
    # Unset unless you set it.
    ALPHAVANTAGE_API_KEY: str

    # US Bureau of Labor Statistics - https://data.bls.gov/registrationEngine/
    # Raises the request quota; the BLS API also works unregistered
    # Unset unless you set it.
    BLS_API_KEY: str

    # OpenFIGI - https://www.openfigi.com/api
    # Raises the rate limit on symbol lookups; works unregistered
    # Unset unless you set it.
    OPENFIGI_API_KEY: str


class Client:
    """Synchronous client for finance-query."""

    def __init__(
        self,
        base_url: str | None = None,
        *,
        server_env: ServerEnv | typing.Mapping[str, str] | None = None,
        timeout: float = 30.0,
        max_retries: int = 3,
        on_rate_limit: typing.Callable[[typing.Any], None] | None = None,
        transport: Transport | None = None,
    ) -> None:
        """Starts the bundled server when no base URL is given.

        Pass ``DEFAULT_BASE_URL`` to use the hosted deployment instead.

        ``server_env`` configures that server — see ``ServerEnv`` for the knobs it reads.
        """
        base_url = base_url or embedded_base_url(EMBED, typing.cast("typing.Mapping[str, str] | None", server_env))
        self._transport = transport or Transport(
            base_url, timeout=timeout, max_retries=max_retries, on_rate_limit=on_rate_limit
        )

    def close(self) -> None:
        self._transport.close()

    def __enter__(self) -> Client:
        return self

    def __exit__(self, *exc: object) -> None:
        self.close()

    def get_analysis(
        self,
        symbol: str,
        type: models.AnalysisType,
        *,
        fields: str | None = None,
    ) -> models.AnalysisResponse:
        """Get analysis data"""
        return self._transport.request(
            "GET",
            f"/v2/analysis/{path_seg(symbol)}/{path_seg(type)}",
            query=query_of({"fields": fields}),
            into=models.AnalysisResponse,
        )

    def get_batch_capital_gains(
        self,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlCapitalGainsBatch:
        """Get batch capital gains history"""
        return self._transport.request(
            "GET",
            "/v2/capital-gains",
            query=query_of({"fields": fields, "range": range, "symbols": symbols}),
            into=models.GqlCapitalGainsBatch,
        )

    def get_batch_charts(
        self,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        patterns: bool | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlChartsBatch:
        """Get batch historical chart data"""
        return self._transport.request(
            "GET",
            "/v2/charts",
            query=query_of({"fields": fields, "interval": interval, "patterns": patterns, "range": range, "symbols": symbols}),
            into=models.GqlChartsBatch,
        )

    def iter_batch_charts(
        self,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        patterns: bool | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Get batch historical chart data

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                "/v2/charts",
                query=query_of({"fields": fields, "interval": interval, "patterns": patterns, "range": range, "symbols": symbols, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_batch_dividends(
        self,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlDividendsBatch:
        """Get batch dividend history"""
        return self._transport.request(
            "GET",
            "/v2/dividends",
            query=query_of({"fields": fields, "range": range, "symbols": symbols}),
            into=models.GqlDividendsBatch,
        )

    def iter_batch_dividends(
        self,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Get batch dividend history

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                "/v2/dividends",
                query=query_of({"fields": fields, "range": range, "symbols": symbols, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_batch_financials(
        self,
        *,
        fields: str | None = None,
        frequency: models.Frequency | None = None,
        metrics: str | None = None,
        statement: models.StatementType,
        symbols: str,
    ) -> models.GqlFinancialsBatch:
        """Get batch financial statements"""
        return self._transport.request(
            "GET",
            "/v2/financials",
            query=query_of({"fields": fields, "frequency": frequency, "metrics": metrics, "statement": statement, "symbols": symbols}),
            into=models.GqlFinancialsBatch,
        )

    def get_batch_indicators(
        self,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlIndicatorsBatch:
        """Get batch technical indicators"""
        return self._transport.request(
            "GET",
            "/v2/indicators",
            query=query_of({"fields": fields, "interval": interval, "range": range, "symbols": symbols}),
            into=models.GqlIndicatorsBatch,
        )

    def iter_batch_indicators(
        self,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Get batch technical indicators

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                "/v2/indicators",
                query=query_of({"fields": fields, "interval": interval, "range": range, "symbols": symbols, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_batch_options(
        self,
        *,
        date: int | None = None,
        fields: str | None = None,
        symbols: str,
    ) -> models.GqlOptionsBatch:
        """Get batch options chains"""
        return self._transport.request(
            "GET",
            "/v2/options",
            query=query_of({"date": date, "fields": fields, "symbols": symbols}),
            into=models.GqlOptionsBatch,
        )

    def iter_batch_options(
        self,
        *,
        date: int | None = None,
        fields: str | None = None,
        symbols: str,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Get batch options chains

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                "/v2/options",
                query=query_of({"date": date, "fields": fields, "symbols": symbols, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_batch_recommendations(
        self,
        *,
        fields: str | None = None,
        limit: int | None = None,
        page_cursor: str | None = None,
        page_limit: int | None = None,
        symbols: str,
    ) -> models.GqlRecommendationsBatch:
        """Get batch stock recommendations"""
        return self._transport.request(
            "GET",
            "/v2/recommendations",
            query=query_of({"fields": fields, "limit": limit, "pageCursor": page_cursor, "pageLimit": page_limit, "symbols": symbols}),
            into=models.GqlRecommendationsBatch,
        )

    def get_batch_splits(
        self,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlSplitsBatch:
        """Get batch stock split history"""
        return self._transport.request(
            "GET",
            "/v2/splits",
            query=query_of({"fields": fields, "range": range, "symbols": symbols}),
            into=models.GqlSplitsBatch,
        )

    def get_calendar(
        self,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> list[models.GqlCalendarEvent]:
        """Get upcoming financial event calendar"""
        return self._transport.request(
            "GET",
            "/v2/calendar",
            query=query_of({"fields": fields, "range": range, "symbols": symbols}),
            into=list[models.GqlCalendarEvent],
        )

    def get_capital_gains(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
    ) -> list[models.GqlCapitalGain]:
        """Get capital gains distribution history"""
        return self._transport.request(
            "GET",
            f"/v2/capital-gains/{path_seg(symbol)}",
            query=query_of({"fields": fields, "range": range}),
            into=list[models.GqlCapitalGain],
        )

    def get_chart(
        self,
        symbol: str,
        *,
        end: int | None = None,
        events: bool | None = None,
        fields: str | None = None,
        interval: models.Interval | None = None,
        patterns: bool | None = None,
        range: models.TimeRange | None = None,
        start: int | None = None,
    ) -> models.GqlChart:
        """Get historical chart data"""
        return self._transport.request(
            "GET",
            f"/v2/chart/{path_seg(symbol)}",
            query=query_of({"end": end, "events": events, "fields": fields, "interval": interval, "patterns": patterns, "range": range, "start": start}),
            into=models.GqlChart,
        )

    def iter_chart(
        self,
        symbol: str,
        *,
        end: int | None = None,
        events: bool | None = None,
        fields: str | None = None,
        interval: models.Interval | None = None,
        patterns: bool | None = None,
        range: models.TimeRange | None = None,
        start: int | None = None,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Get historical chart data

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                f"/v2/chart/{path_seg(symbol)}",
                query=query_of({"end": end, "events": events, "fields": fields, "interval": interval, "patterns": patterns, "range": range, "start": start, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_commitments_of_traders(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> models.GqlCommitmentsOfTraders:
        """Weekly CFTC Commitments of Traders positioning (keyless)"""
        return self._transport.request(
            "GET",
            f"/v2/cftc/cot/{path_seg(symbol)}",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=models.GqlCommitmentsOfTraders,
        )

    def get_commodity(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlCommodityQuote:
        """Get a commodity's current quote"""
        return self._transport.request(
            "GET",
            f"/v2/commodities/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlCommodityQuote,
        )

    def get_company_profile(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlCompanyProfile:
        """Get company profile"""
        return self._transport.request(
            "GET",
            f"/v2/company-profile/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlCompanyProfile,
        )

    def get_congressional_trades(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlCongressionalTrade]:
        """Congressional trading disclosures for a symbol"""
        return self._transport.request(
            "GET",
            f"/v2/filings/{path_seg(symbol)}/congressional-trades",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlCongressionalTrade],
        )

    def get_crypto_coin(
        self,
        id: str,
        *,
        fields: str | None = None,
        vs_currency: str | None = None,
    ) -> models.GqlCoinQuote:
        """Single coin by CoinGecko ID"""
        return self._transport.request(
            "GET",
            f"/v2/crypto/coins/{path_seg(id)}",
            query=query_of({"fields": fields, "vsCurrency": vs_currency}),
            into=models.GqlCoinQuote,
        )

    def get_crypto_coins(
        self,
        *,
        count: int | None = None,
        fields: str | None = None,
        vs_currency: str | None = None,
    ) -> list[models.GqlCoinQuote]:
        """Top coins by market cap"""
        return self._transport.request(
            "GET",
            "/v2/crypto/coins",
            query=query_of({"count": count, "fields": fields, "vsCurrency": vs_currency}),
            into=list[models.GqlCoinQuote],
        )

    def iter_crypto_coins(
        self,
        *,
        count: int | None = None,
        fields: str | None = None,
        vs_currency: str | None = None,
        limit: int = 50,
    ) -> SyncPager[models.GqlCoinQuote]:
        """Top coins by market cap

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                "/v2/crypto/coins",
                query=query_of({"count": count, "fields": fields, "vsCurrency": vs_currency, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, models.GqlCoinQuote)

    def get_crypto_global(
        self,
        *,
        fields: str | None = None,
    ) -> models.GqlGlobalCryptoStats:
        """Aggregate global cryptocurrency market statistics"""
        return self._transport.request(
            "GET",
            "/v2/crypto/global",
            query=query_of({"fields": fields}),
            into=models.GqlGlobalCryptoStats,
        )

    def get_crypto_news(
        self,
        *,
        fields: str | None = None,
        limit: int | None = None,
        page_cursor: str | None = None,
        page_limit: int | None = None,
    ) -> list[models.GqlNews]:
        """Market-wide crypto news"""
        return self._transport.request(
            "GET",
            "/v2/crypto/news",
            query=query_of({"fields": fields, "limit": limit, "pageCursor": page_cursor, "pageLimit": page_limit}),
            into=list[models.GqlNews],
        )

    def get_crypto_search(
        self,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
        limit_results: int | None = None,
        query: str,
    ) -> list[models.GqlSymbolMatch]:
        """Search CoinGecko's coin universe by free-text query"""
        return self._transport.request(
            "GET",
            "/v2/crypto/search",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit, "limitResults": limit_results, "query": query}),
            into=list[models.GqlSymbolMatch],
        )

    def get_crypto_trending(
        self,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlTrendingCoin]:
        """Coins trending on CoinGecko over the last 24h"""
        return self._transport.request(
            "GET",
            "/v2/crypto/trending",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlTrendingCoin],
        )

    def get_currencies(
        self,
        *,
        fields: str | None = None,
    ) -> list[models.GqlCurrency]:
        """Get available currencies"""
        return self._transport.request(
            "GET",
            "/v2/currencies",
            query=query_of({"fields": fields}),
            into=list[models.GqlCurrency],
        )

    def get_dividends(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
    ) -> models.GqlDividends:
        """Get dividend history and analytics"""
        return self._transport.request(
            "GET",
            f"/v2/dividends/{path_seg(symbol)}",
            query=query_of({"fields": fields, "range": range}),
            into=models.GqlDividends,
        )

    def iter_dividends(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Get dividend history and analytics

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                f"/v2/dividends/{path_seg(symbol)}",
                query=query_of({"fields": fields, "range": range, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_earnings_surprises(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlEarningsSurpriseHistory:
        """Get earnings-surprise history"""
        return self._transport.request(
            "GET",
            f"/v2/earnings-surprises/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlEarningsSurpriseHistory,
        )

    def get_earnings_transcript(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        quarter: models.Quarter | None = None,
        year: int | None = None,
    ) -> models.GqlEarningsTranscript:
        """Get earnings call transcript"""
        return self._transport.request(
            "GET",
            f"/v2/earnings-transcript/{path_seg(symbol)}",
            query=query_of({"fields": fields, "quarter": quarter, "year": year}),
            into=models.GqlEarningsTranscript,
        )

    def get_edgar_cik(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlEdgarCik:
        """Resolve ticker to CIK"""
        return self._transport.request(
            "GET",
            f"/v2/edgar/cik/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlEdgarCik,
        )

    def get_edgar_facts(
        self,
        symbol: str,
        *,
        concepts: str | None = None,
        fields: str | None = None,
        taxonomy: str | None = None,
    ) -> list[models.GqlFactConcept]:
        """Get XBRL financial data"""
        return self._transport.request(
            "GET",
            f"/v2/edgar/facts/{path_seg(symbol)}",
            query=query_of({"concepts": concepts, "fields": fields, "taxonomy": taxonomy}),
            into=list[models.GqlFactConcept],
        )

    def iter_edgar_facts(
        self,
        symbol: str,
        *,
        concepts: str | None = None,
        fields: str | None = None,
        taxonomy: str | None = None,
        limit: int = 50,
    ) -> SyncPager[models.GqlFactConcept]:
        """Get XBRL financial data

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                f"/v2/edgar/facts/{path_seg(symbol)}",
                query=query_of({"concepts": concepts, "fields": fields, "taxonomy": taxonomy, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, models.GqlFactConcept)

    def get_edgar_search(
        self,
        *,
        end_date: str | None = None,
        fields: str | None = None,
        forms: str | None = None,
        from_: int | None = None,
        q: str,
        size: int | None = None,
        start_date: str | None = None,
    ) -> models.GqlEdgarSearchResults:
        """Search SEC filings"""
        return self._transport.request(
            "GET",
            "/v2/edgar/search",
            query=query_of({"endDate": end_date, "fields": fields, "forms": forms, "from": from_, "q": q, "size": size, "startDate": start_date}),
            into=models.GqlEdgarSearchResults,
        )

    def get_edgar_submissions(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlEdgarSubmissions:
        """Get SEC filing history"""
        return self._transport.request(
            "GET",
            f"/v2/edgar/submissions/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlEdgarSubmissions,
        )

    def iter_edgar_submissions(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Get SEC filing history

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                f"/v2/edgar/submissions/{path_seg(symbol)}",
                query=query_of({"fields": fields, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_etf_profile(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlEtfProfile:
        """Get ETF profile and holdings"""
        return self._transport.request(
            "GET",
            f"/v2/etf-profile/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlEtfProfile,
        )

    def get_exchanges(
        self,
        *,
        fields: str | None = None,
    ) -> list[models.GqlExchange]:
        """Get supported exchanges"""
        return self._transport.request(
            "GET",
            "/v2/exchanges",
            query=query_of({"fields": fields}),
            into=list[models.GqlExchange],
        )

    def get_executive_compensation(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlExecutiveCompensation]:
        """Disclosed executive compensation by year."""
        return self._transport.request(
            "GET",
            f"/v2/executive-compensation/{path_seg(symbol)}",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlExecutiveCompensation],
        )

    def get_fails_to_deliver(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlFailToDeliver]:
        """Fails-to-deliver records for a symbol"""
        return self._transport.request(
            "GET",
            f"/v2/filings/{path_seg(symbol)}/fails-to-deliver",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlFailToDeliver],
        )

    def get_fear_and_greed(
        self,
        *,
        fields: str | None = None,
    ) -> models.GqlFearAndGreed:
        """Fear & Greed Index"""
        return self._transport.request(
            "GET",
            "/v2/fear-and-greed",
            query=query_of({"fields": fields}),
            into=models.GqlFearAndGreed,
        )

    def get_feeds(
        self,
        *,
        fields: str | None = None,
        form_type: str | None = None,
        sources: str | None = None,
    ) -> list[models.GqlFeedEntry]:
        """RSS/Atom news feeds"""
        return self._transport.request(
            "GET",
            "/v2/feeds",
            query=query_of({"fields": fields, "formType": form_type, "sources": sources}),
            into=list[models.GqlFeedEntry],
        )

    def iter_feeds(
        self,
        *,
        fields: str | None = None,
        form_type: str | None = None,
        sources: str | None = None,
        limit: int = 50,
    ) -> SyncPager[models.GqlFeedEntry]:
        """RSS/Atom news feeds

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                "/v2/feeds",
                query=query_of({"fields": fields, "formType": form_type, "sources": sources, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, models.GqlFeedEntry)

    def get_filing_sections(
        self,
        symbol: str,
        *,
        accession_number: str,
        fields: str | None = None,
        form: models.FilingSectionFormParam,
    ) -> list[models.GqlFilingSection]:
        """Get sectioned text of one SEC filing"""
        return self._transport.request(
            "GET",
            f"/v2/filings/{path_seg(symbol)}/sections",
            query=query_of({"accessionNumber": accession_number, "fields": fields, "form": form}),
            into=list[models.GqlFilingSection],
        )

    def get_financials(
        self,
        symbol: str,
        statement: models.StatementType,
        *,
        fields: str | None = None,
        frequency: models.Frequency | None = None,
        metrics: str | None = None,
    ) -> list[models.GqlFinancialLineItem]:
        """Get financial statements"""
        return self._transport.request(
            "GET",
            f"/v2/financials/{path_seg(symbol)}/{path_seg(statement)}",
            query=query_of({"fields": fields, "frequency": frequency, "metrics": metrics}),
            into=list[models.GqlFinancialLineItem],
        )

    def get_forex(
        self,
        from_: str,
        to: str,
        *,
        fields: str | None = None,
    ) -> models.GqlForexQuote:
        """Get a currency pair's current exchange rate"""
        return self._transport.request(
            "GET",
            f"/v2/forex/{path_seg(from_)}/{path_seg(to)}",
            query=query_of({"fields": fields}),
            into=models.GqlForexQuote,
        )

    def get_forex_news(
        self,
        *,
        fields: str | None = None,
        limit: int | None = None,
        page_cursor: str | None = None,
        page_limit: int | None = None,
    ) -> list[models.GqlNews]:
        """Market-wide forex news"""
        return self._transport.request(
            "GET",
            "/v2/forex/news",
            query=query_of({"fields": fields, "limit": limit, "pageCursor": page_cursor, "pageLimit": page_limit}),
            into=list[models.GqlNews],
        )

    def get_fred_series(
        self,
        id: str,
        *,
        fields: str | None = None,
    ) -> models.GqlMacroSeries:
        """FRED time series"""
        return self._transport.request(
            "GET",
            f"/v2/fred/series/{path_seg(id)}",
            query=query_of({"fields": fields}),
            into=models.GqlMacroSeries,
        )

    def iter_fred_series(
        self,
        id: str,
        *,
        fields: str | None = None,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """FRED time series

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                f"/v2/fred/series/{path_seg(id)}",
                query=query_of({"fields": fields, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_fred_treasury_yields(
        self,
        *,
        fields: str | None = None,
        year: int | None = None,
    ) -> list[models.GqlTreasuryYield]:
        """US Treasury yield curve"""
        return self._transport.request(
            "GET",
            "/v2/fred/treasury-yields",
            query=query_of({"fields": fields, "year": year}),
            into=list[models.GqlTreasuryYield],
        )

    def iter_fred_treasury_yields(
        self,
        *,
        fields: str | None = None,
        year: int | None = None,
        limit: int = 50,
    ) -> SyncPager[models.GqlTreasuryYield]:
        """US Treasury yield curve

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                "/v2/fred/treasury-yields",
                query=query_of({"fields": fields, "year": year, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, models.GqlTreasuryYield)

    def get_futures(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlFuturesQuote:
        """Get a futures contract's current quote"""
        return self._transport.request(
            "GET",
            f"/v2/futures/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlFuturesQuote,
        )

    def get_gdelt_news(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlNews]:
        """Worldwide news mentioning a symbol (GDELT, keyless)"""
        return self._transport.request(
            "GET",
            f"/v2/gdelt/news/{path_seg(symbol)}",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlNews],
        )

    def get_general_news(
        self,
        *,
        count: int | None = None,
        fields: str | None = None,
        lang: str | None = None,
    ) -> list[models.GqlNews]:
        """Get general market news"""
        return self._transport.request(
            "GET",
            "/v2/news",
            query=query_of({"count": count, "fields": fields, "lang": lang}),
            into=list[models.GqlNews],
        )

    def iter_general_news(
        self,
        *,
        count: int | None = None,
        fields: str | None = None,
        lang: str | None = None,
        limit: int = 50,
    ) -> SyncPager[models.GqlNews]:
        """Get general market news

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                "/v2/news",
                query=query_of({"count": count, "fields": fields, "lang": lang, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, models.GqlNews)

    def get_grading_actions(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlGradingAction]:
        """Provider-routed analyst upgrades and downgrades."""
        return self._transport.request(
            "GET",
            f"/v2/grading-actions/{path_seg(symbol)}",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlGradingAction],
        )

    def get_holders(
        self,
        symbol: str,
        type: models.HolderType,
        *,
        fields: str | None = None,
    ) -> models.HoldersResponse:
        """Get holder data"""
        return self._transport.request(
            "GET",
            f"/v2/holders/{path_seg(symbol)}/{path_seg(type)}",
            query=query_of({"fields": fields}),
            into=models.HoldersResponse,
        )

    def iter_holders(
        self,
        symbol: str,
        type: models.HolderType,
        *,
        fields: str | None = None,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Get holder data

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                f"/v2/holders/{path_seg(symbol)}/{path_seg(type)}",
                query=query_of({"fields": fields, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_hours(
        self,
        *,
        fields: str | None = None,
        region: models.Region | None = None,
    ) -> models.GqlMarketHours:
        """Get market hours"""
        return self._transport.request(
            "GET",
            "/v2/hours",
            query=query_of({"fields": fields, "region": region}),
            into=models.GqlMarketHours,
        )

    def get_index_constituent_changes(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlIndexConstituentChange]:
        """Additions and removals from an index's constituent list."""
        return self._transport.request(
            "GET",
            f"/v2/indices/{path_seg(symbol)}/constituent-changes",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlIndexConstituentChange],
        )

    def get_index_constituents(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> list[models.GqlIndexConstituent]:
        """Get an index's current constituent list"""
        return self._transport.request(
            "GET",
            f"/v2/index-constituents/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=list[models.GqlIndexConstituent],
        )

    def get_indicators(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        range: models.TimeRange | None = None,
    ) -> models.GqlIndicatorsSummary:
        """Get technical indicators"""
        return self._transport.request(
            "GET",
            f"/v2/indicators/{path_seg(symbol)}",
            query=query_of({"fields": fields, "interval": interval, "range": range}),
            into=models.GqlIndicatorsSummary,
        )

    def get_indices(
        self,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        region: models.indices_Region | None = None,
    ) -> list[models.GqlQuote]:
        """Get world market indices"""
        return self._transport.request(
            "GET",
            "/v2/indices",
            query=query_of({"fields": fields, "format": format, "region": region}),
            into=list[models.GqlQuote],
        )

    def get_industry(
        self,
        industry: models.Industry,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
    ) -> models.GqlIndustryData:
        """Get industry data"""
        return self._transport.request(
            "GET",
            f"/v2/industries/{path_seg(industry)}",
            query=query_of({"fields": fields, "format": format, "lang": lang}),
            into=models.GqlIndustryData,
        )

    def get_key_metrics_ttm(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlKeyMetricsTtm:
        """Trailing-twelve-month key metrics."""
        return self._transport.request(
            "GET",
            f"/v2/key-metrics-ttm/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlKeyMetricsTtm,
        )

    def get_market_calendar(
        self,
        *,
        fields: str | None = None,
        from_: str | None = None,
        kind: models.MarketCalendarKindParam,
        to: str | None = None,
    ) -> list[models.GqlMarketCalendarEntry]:
        """Get a market-wide event calendar"""
        return self._transport.request(
            "GET",
            "/v2/market-calendar",
            query=query_of({"fields": fields, "from": from_, "kind": kind, "to": to}),
            into=list[models.GqlMarketCalendarEntry],
        )

    def get_market_summary(
        self,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
        region: models.Region | None = None,
    ) -> list[models.GqlMarketSummaryQuote]:
        """Get market summary"""
        return self._transport.request(
            "GET",
            "/v2/market-summary",
            query=query_of({"fields": fields, "format": format, "lang": lang, "region": region}),
            into=list[models.GqlMarketSummaryQuote],
        )

    def get_metrics(
        self,
    ) -> models.MetricsText:
        """Prometheus metrics"""
        return self._transport.request(
            "GET",
            "/v2/metrics",
            into=models.MetricsText,
        )

    def get_news(
        self,
        symbol: str,
        *,
        count: int | None = None,
        fields: str | None = None,
        lang: str | None = None,
    ) -> list[models.GqlNews]:
        """Get news for a symbol"""
        return self._transport.request(
            "GET",
            f"/v2/news/{path_seg(symbol)}",
            query=query_of({"count": count, "fields": fields, "lang": lang}),
            into=list[models.GqlNews],
        )

    def iter_news(
        self,
        symbol: str,
        *,
        count: int | None = None,
        fields: str | None = None,
        lang: str | None = None,
        limit: int = 50,
    ) -> SyncPager[models.GqlNews]:
        """Get news for a symbol

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                f"/v2/news/{path_seg(symbol)}",
                query=query_of({"count": count, "fields": fields, "lang": lang, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, models.GqlNews)

    def get_options(
        self,
        symbol: str,
        *,
        date: int | None = None,
        fields: str | None = None,
    ) -> models.GqlOptions:
        """Get options chain"""
        return self._transport.request(
            "GET",
            f"/v2/options/{path_seg(symbol)}",
            query=query_of({"date": date, "fields": fields}),
            into=models.GqlOptions,
        )

    def iter_options(
        self,
        symbol: str,
        *,
        date: int | None = None,
        fields: str | None = None,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Get options chain

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                f"/v2/options/{path_seg(symbol)}",
                query=query_of({"date": date, "fields": fields, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_press_releases(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlPressRelease]:
        """Get a company's own press releases"""
        return self._transport.request(
            "GET",
            f"/v2/press-releases/{path_seg(symbol)}",
            query=query_of({"fields": fields, "limit": limit}),
            into=list[models.GqlPressRelease],
        )

    def get_price_target_consensus(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlPriceTargetConsensus:
        """Get consensus analyst price target"""
        return self._transport.request(
            "GET",
            f"/v2/price-target-consensus/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlPriceTargetConsensus,
        )

    def get_price_target_summary(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlPriceTargetSummary:
        """Analyst price-target counts and averages per window."""
        return self._transport.request(
            "GET",
            f"/v2/price-target-summary/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlPriceTargetSummary,
        )

    def get_protocol_tvl(
        self,
        id: str,
        *,
        fields: str | None = None,
    ) -> models.GqlProtocolTvl:
        """A DeFi protocol's total value locked (DefiLlama, keyless)."""
        return self._transport.request(
            "GET",
            f"/v2/crypto/coins/{path_seg(id)}/tvl",
            query=query_of({"fields": fields}),
            into=models.GqlProtocolTvl,
        )

    def get_protocol_tvl_history(
        self,
        id: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlTvlPoint]:
        """A protocol's TVL history, oldest first."""
        return self._transport.request(
            "GET",
            f"/v2/crypto/coins/{path_seg(id)}/tvl-history",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlTvlPoint],
        )

    def get_quote(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
        logo: bool | None = None,
    ) -> models.GqlQuote:
        """Get quote for a symbol"""
        return self._transport.request(
            "GET",
            f"/v2/quote/{path_seg(symbol)}",
            query=query_of({"fields": fields, "format": format, "lang": lang, "logo": logo}),
            into=models.GqlQuote,
        )

    def get_quote_type(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlQuoteTypeData:
        """Get quote type"""
        return self._transport.request(
            "GET",
            f"/v2/quote-type/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlQuoteTypeData,
        )

    def get_quotes(
        self,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
        logo: bool | None = None,
        symbols: str,
    ) -> models.GqlQuotesBatch:
        """Get quotes for multiple symbols"""
        return self._transport.request(
            "GET",
            "/v2/quotes",
            query=query_of({"fields": fields, "format": format, "lang": lang, "logo": logo, "symbols": symbols}),
            into=models.GqlQuotesBatch,
        )

    def iter_quotes(
        self,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
        logo: bool | None = None,
        symbols: str,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Get quotes for multiple symbols

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                "/v2/quotes",
                query=query_of({"fields": fields, "format": format, "lang": lang, "logo": logo, "symbols": symbols, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)

    def get_rating_consensus(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlRatingConsensus:
        """Get consensus rating rollup"""
        return self._transport.request(
            "GET",
            f"/v2/rating-consensus/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlRatingConsensus,
        )

    def get_ratios_ttm(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlFinancialRatiosTtm:
        """Trailing-twelve-month financial ratios."""
        return self._transport.request(
            "GET",
            f"/v2/ratios-ttm/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlFinancialRatiosTtm,
        )

    def get_recommendations(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        limit: int | None = None,
    ) -> models.GqlRecommendation:
        """Get similar stock recommendations"""
        return self._transport.request(
            "GET",
            f"/v2/recommendations/{path_seg(symbol)}",
            query=query_of({"fields": fields, "limit": limit}),
            into=models.GqlRecommendation,
        )

    def get_risk(
        self,
        symbol: str,
        *,
        benchmark: str | None = None,
        fields: str | None = None,
        interval: models.Interval | None = None,
        range: models.TimeRange | None = None,
    ) -> models.GqlRiskSummary:
        """Risk analytics"""
        return self._transport.request(
            "GET",
            f"/v2/risk/{path_seg(symbol)}",
            query=query_of({"benchmark": benchmark, "fields": fields, "interval": interval, "range": range}),
            into=models.GqlRiskSummary,
        )

    def get_risk_factors(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> list[models.GqlRiskFactor]:
        """Get risk factors extracted from SEC filings"""
        return self._transport.request(
            "GET",
            f"/v2/filings/{path_seg(symbol)}/risk-factors",
            query=query_of({"fields": fields}),
            into=list[models.GqlRiskFactor],
        )

    def get_screeners(
        self,
        screener: models.Screener,
        *,
        count: int | None = None,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
    ) -> models.GqlScreenerResults:
        """Get screener results"""
        return self._transport.request(
            "GET",
            f"/v2/screeners/{path_seg(screener)}",
            query=query_of({"count": count, "fields": fields, "format": format}),
            into=models.GqlScreenerResults,
        )

    def get_sector(
        self,
        sector: models.Sector,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
    ) -> models.GqlSectorData:
        """Get sector data"""
        return self._transport.request(
            "GET",
            f"/v2/sectors/{path_seg(sector)}",
            query=query_of({"fields": fields, "format": format, "lang": lang}),
            into=models.GqlSectorData,
        )

    def get_sector_pe(
        self,
        *,
        fields: str | None = None,
    ) -> list[models.GqlMarketSectorPe]:
        """Get price/earnings ratios by sector"""
        return self._transport.request(
            "GET",
            "/v2/sector-pe",
            query=query_of({"fields": fields}),
            into=list[models.GqlMarketSectorPe],
        )

    def get_sector_performance(
        self,
        *,
        fields: str | None = None,
    ) -> list[models.GqlMarketSectorPerformance]:
        """Get aggregate performance for every sector"""
        return self._transport.request(
            "GET",
            "/v2/sector-performance",
            query=query_of({"fields": fields}),
            into=list[models.GqlMarketSectorPerformance],
        )

    def get_sector_performance_history(
        self,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlSectorPerformanceHistory]:
        """Sector performance per session."""
        return self._transport.request(
            "GET",
            "/v2/sector-performance/history",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlSectorPerformanceHistory],
        )

    def get_short_volume(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlShortVolume]:
        """Daily FINRA short-sale volume for a symbol (keyless)."""
        return self._transport.request(
            "GET",
            f"/v2/short-volume/{path_seg(symbol)}",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlShortVolume],
        )

    def get_spark(
        self,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlSparkBatch:
        """Get batch sparkline data"""
        return self._transport.request(
            "GET",
            "/v2/spark",
            query=query_of({"fields": fields, "interval": interval, "range": range, "symbols": symbols}),
            into=models.GqlSparkBatch,
        )

    def get_splits(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
    ) -> list[models.GqlSplit]:
        """Get stock split history"""
        return self._transport.request(
            "GET",
            f"/v2/splits/{path_seg(symbol)}",
            query=query_of({"fields": fields, "range": range}),
            into=list[models.GqlSplit],
        )

    def get_symbol_details(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlSymbolDetails:
        """Reference detail for one symbol."""
        return self._transport.request(
            "GET",
            f"/v2/symbol-details/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlSymbolDetails,
        )

    def get_transcript(
        self,
        symbol: str,
        *,
        lang: str | None = None,
        quarter: models.Quarter | None = None,
        year: int | None = None,
    ) -> models.GqlTranscript:
        """Get earnings transcript"""
        return self._transport.request(
            "GET",
            f"/v2/transcripts/{path_seg(symbol)}",
            query=query_of({"lang": lang, "quarter": quarter, "year": year}),
            into=models.GqlTranscript,
        )

    def get_transcripts(
        self,
        symbol: str,
        *,
        lang: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlTranscriptWithMeta]:
        """Get all earnings transcripts"""
        return self._transport.request(
            "GET",
            f"/v2/transcripts/{path_seg(symbol)}/all",
            query=query_of({"lang": lang, "limit": limit}),
            into=list[models.GqlTranscriptWithMeta],
        )

    def get_trending(
        self,
        *,
        fields: str | None = None,
        region: models.Region | None = None,
    ) -> list[models.GqlTrendingQuote]:
        """Get trending tickers"""
        return self._transport.request(
            "GET",
            "/v2/trending",
            query=query_of({"fields": fields, "region": region}),
            into=list[models.GqlTrendingQuote],
        )

    def health_check(
        self,
    ) -> models.HealthResponse:
        """Health check"""
        return self._transport.request(
            "GET",
            "/v2/health",
            into=models.HealthResponse,
        )

    def lookup(
        self,
        *,
        count: int | None = None,
        fields: str | None = None,
        lang: str | None = None,
        logo: bool | None = None,
        q: str,
        region: models.Region | None = None,
        type: models.LookupType | None = None,
    ) -> models.GqlLookupResults:
        """Look up symbols by type"""
        return self._transport.request(
            "GET",
            "/v2/lookup",
            query=query_of({"count": count, "fields": fields, "lang": lang, "logo": logo, "q": q, "region": region, "type": type}),
            into=models.GqlLookupResults,
        )

    def ping(
        self,
    ) -> models.PingResponse:
        """Ping endpoint"""
        return self._transport.request(
            "GET",
            "/v2/ping",
            into=models.PingResponse,
        )

    def post_backtest(
        self,
        symbol: str,
        body: models.BacktestRequest,
    ) -> models.GqlBacktestResult:
        """Run a strategy backtest"""
        return self._transport.request(
            "POST",
            f"/v2/backtest/{path_seg(symbol)}",
            json_body=to_wire(body),
            into=models.GqlBacktestResult,
        )

    def post_custom_screener(
        self,
        body: models.CustomScreenerRequest,
    ) -> models.GqlScreenerResults:
        """Custom screener query"""
        return self._transport.request(
            "POST",
            "/v2/screeners/custom",
            json_body=to_wire(body),
            into=models.GqlScreenerResults,
        )

    def search(
        self,
        *,
        cultural: bool | None = None,
        fields: str | None = None,
        fuzzy: bool | None = None,
        lang: str | None = None,
        logo: bool | None = None,
        news: int | None = None,
        q: str,
        quotes: int | None = None,
        region: models.Region | None = None,
        research: bool | None = None,
    ) -> models.GqlSearchResults:
        """Search symbols and companies"""
        return self._transport.request(
            "GET",
            "/v2/search",
            query=query_of({"cultural": cultural, "fields": fields, "fuzzy": fuzzy, "lang": lang, "logo": logo, "news": news, "q": q, "quotes": quotes, "region": region, "research": research}),
            into=models.GqlSearchResults,
        )

    def iter_search(
        self,
        *,
        cultural: bool | None = None,
        fields: str | None = None,
        fuzzy: bool | None = None,
        lang: str | None = None,
        logo: bool | None = None,
        news: int | None = None,
        q: str,
        quotes: int | None = None,
        region: models.Region | None = None,
        research: bool | None = None,
        limit: int = 50,
    ) -> SyncPager[typing.Any]:
        """Search symbols and companies

        Auto-paginates; iterate items or call `.pages()`.
        """
        def fetch(cursor: str | None) -> typing.Any:
            return self._transport.request(
                "GET",
                "/v2/search",
                query=query_of({"cultural": cultural, "fields": fields, "fuzzy": fuzzy, "lang": lang, "logo": logo, "news": news, "q": q, "quotes": quotes, "region": region, "research": research, "limit": limit, "cursor": cursor}),
            )

        return SyncPager(fetch, typing.Any)


class AsyncClient:
    """Asynchronous client for finance-query."""

    def __init__(
        self,
        base_url: str | None = None,
        *,
        server_env: ServerEnv | typing.Mapping[str, str] | None = None,
        timeout: float = 30.0,
        max_retries: int = 3,
        on_rate_limit: typing.Callable[[typing.Any], None] | None = None,
        transport: AsyncTransport | None = None,
    ) -> None:
        """Starts the bundled server when no base URL is given.

        Pass ``DEFAULT_BASE_URL`` to use the hosted deployment instead.

        ``server_env`` configures that server — see ``ServerEnv`` for the knobs it reads.
        """
        base_url = base_url or embedded_base_url(EMBED, typing.cast("typing.Mapping[str, str] | None", server_env))
        self._transport = transport or AsyncTransport(
            base_url, timeout=timeout, max_retries=max_retries, on_rate_limit=on_rate_limit
        )

    async def aclose(self) -> None:
        await self._transport.aclose()

    async def __aenter__(self) -> AsyncClient:
        return self

    async def __aexit__(self, *exc: object) -> None:
        await self.aclose()

    async def get_analysis(
        self,
        symbol: str,
        type: models.AnalysisType,
        *,
        fields: str | None = None,
    ) -> models.AnalysisResponse:
        """Get analysis data"""
        return await self._transport.request(
            "GET",
            f"/v2/analysis/{path_seg(symbol)}/{path_seg(type)}",
            query=query_of({"fields": fields}),
            into=models.AnalysisResponse,
        )

    async def get_batch_capital_gains(
        self,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlCapitalGainsBatch:
        """Get batch capital gains history"""
        return await self._transport.request(
            "GET",
            "/v2/capital-gains",
            query=query_of({"fields": fields, "range": range, "symbols": symbols}),
            into=models.GqlCapitalGainsBatch,
        )

    async def get_batch_charts(
        self,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        patterns: bool | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlChartsBatch:
        """Get batch historical chart data"""
        return await self._transport.request(
            "GET",
            "/v2/charts",
            query=query_of({"fields": fields, "interval": interval, "patterns": patterns, "range": range, "symbols": symbols}),
            into=models.GqlChartsBatch,
        )

    def iter_batch_charts(
        self,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        patterns: bool | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Get batch historical chart data

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                "/v2/charts",
                query=query_of({"fields": fields, "interval": interval, "patterns": patterns, "range": range, "symbols": symbols, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_batch_dividends(
        self,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlDividendsBatch:
        """Get batch dividend history"""
        return await self._transport.request(
            "GET",
            "/v2/dividends",
            query=query_of({"fields": fields, "range": range, "symbols": symbols}),
            into=models.GqlDividendsBatch,
        )

    def iter_batch_dividends(
        self,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Get batch dividend history

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                "/v2/dividends",
                query=query_of({"fields": fields, "range": range, "symbols": symbols, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_batch_financials(
        self,
        *,
        fields: str | None = None,
        frequency: models.Frequency | None = None,
        metrics: str | None = None,
        statement: models.StatementType,
        symbols: str,
    ) -> models.GqlFinancialsBatch:
        """Get batch financial statements"""
        return await self._transport.request(
            "GET",
            "/v2/financials",
            query=query_of({"fields": fields, "frequency": frequency, "metrics": metrics, "statement": statement, "symbols": symbols}),
            into=models.GqlFinancialsBatch,
        )

    async def get_batch_indicators(
        self,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlIndicatorsBatch:
        """Get batch technical indicators"""
        return await self._transport.request(
            "GET",
            "/v2/indicators",
            query=query_of({"fields": fields, "interval": interval, "range": range, "symbols": symbols}),
            into=models.GqlIndicatorsBatch,
        )

    def iter_batch_indicators(
        self,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Get batch technical indicators

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                "/v2/indicators",
                query=query_of({"fields": fields, "interval": interval, "range": range, "symbols": symbols, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_batch_options(
        self,
        *,
        date: int | None = None,
        fields: str | None = None,
        symbols: str,
    ) -> models.GqlOptionsBatch:
        """Get batch options chains"""
        return await self._transport.request(
            "GET",
            "/v2/options",
            query=query_of({"date": date, "fields": fields, "symbols": symbols}),
            into=models.GqlOptionsBatch,
        )

    def iter_batch_options(
        self,
        *,
        date: int | None = None,
        fields: str | None = None,
        symbols: str,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Get batch options chains

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                "/v2/options",
                query=query_of({"date": date, "fields": fields, "symbols": symbols, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_batch_recommendations(
        self,
        *,
        fields: str | None = None,
        limit: int | None = None,
        page_cursor: str | None = None,
        page_limit: int | None = None,
        symbols: str,
    ) -> models.GqlRecommendationsBatch:
        """Get batch stock recommendations"""
        return await self._transport.request(
            "GET",
            "/v2/recommendations",
            query=query_of({"fields": fields, "limit": limit, "pageCursor": page_cursor, "pageLimit": page_limit, "symbols": symbols}),
            into=models.GqlRecommendationsBatch,
        )

    async def get_batch_splits(
        self,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlSplitsBatch:
        """Get batch stock split history"""
        return await self._transport.request(
            "GET",
            "/v2/splits",
            query=query_of({"fields": fields, "range": range, "symbols": symbols}),
            into=models.GqlSplitsBatch,
        )

    async def get_calendar(
        self,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> list[models.GqlCalendarEvent]:
        """Get upcoming financial event calendar"""
        return await self._transport.request(
            "GET",
            "/v2/calendar",
            query=query_of({"fields": fields, "range": range, "symbols": symbols}),
            into=list[models.GqlCalendarEvent],
        )

    async def get_capital_gains(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
    ) -> list[models.GqlCapitalGain]:
        """Get capital gains distribution history"""
        return await self._transport.request(
            "GET",
            f"/v2/capital-gains/{path_seg(symbol)}",
            query=query_of({"fields": fields, "range": range}),
            into=list[models.GqlCapitalGain],
        )

    async def get_chart(
        self,
        symbol: str,
        *,
        end: int | None = None,
        events: bool | None = None,
        fields: str | None = None,
        interval: models.Interval | None = None,
        patterns: bool | None = None,
        range: models.TimeRange | None = None,
        start: int | None = None,
    ) -> models.GqlChart:
        """Get historical chart data"""
        return await self._transport.request(
            "GET",
            f"/v2/chart/{path_seg(symbol)}",
            query=query_of({"end": end, "events": events, "fields": fields, "interval": interval, "patterns": patterns, "range": range, "start": start}),
            into=models.GqlChart,
        )

    def iter_chart(
        self,
        symbol: str,
        *,
        end: int | None = None,
        events: bool | None = None,
        fields: str | None = None,
        interval: models.Interval | None = None,
        patterns: bool | None = None,
        range: models.TimeRange | None = None,
        start: int | None = None,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Get historical chart data

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                f"/v2/chart/{path_seg(symbol)}",
                query=query_of({"end": end, "events": events, "fields": fields, "interval": interval, "patterns": patterns, "range": range, "start": start, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_commitments_of_traders(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> models.GqlCommitmentsOfTraders:
        """Weekly CFTC Commitments of Traders positioning (keyless)"""
        return await self._transport.request(
            "GET",
            f"/v2/cftc/cot/{path_seg(symbol)}",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=models.GqlCommitmentsOfTraders,
        )

    async def get_commodity(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlCommodityQuote:
        """Get a commodity's current quote"""
        return await self._transport.request(
            "GET",
            f"/v2/commodities/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlCommodityQuote,
        )

    async def get_company_profile(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlCompanyProfile:
        """Get company profile"""
        return await self._transport.request(
            "GET",
            f"/v2/company-profile/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlCompanyProfile,
        )

    async def get_congressional_trades(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlCongressionalTrade]:
        """Congressional trading disclosures for a symbol"""
        return await self._transport.request(
            "GET",
            f"/v2/filings/{path_seg(symbol)}/congressional-trades",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlCongressionalTrade],
        )

    async def get_crypto_coin(
        self,
        id: str,
        *,
        fields: str | None = None,
        vs_currency: str | None = None,
    ) -> models.GqlCoinQuote:
        """Single coin by CoinGecko ID"""
        return await self._transport.request(
            "GET",
            f"/v2/crypto/coins/{path_seg(id)}",
            query=query_of({"fields": fields, "vsCurrency": vs_currency}),
            into=models.GqlCoinQuote,
        )

    async def get_crypto_coins(
        self,
        *,
        count: int | None = None,
        fields: str | None = None,
        vs_currency: str | None = None,
    ) -> list[models.GqlCoinQuote]:
        """Top coins by market cap"""
        return await self._transport.request(
            "GET",
            "/v2/crypto/coins",
            query=query_of({"count": count, "fields": fields, "vsCurrency": vs_currency}),
            into=list[models.GqlCoinQuote],
        )

    def iter_crypto_coins(
        self,
        *,
        count: int | None = None,
        fields: str | None = None,
        vs_currency: str | None = None,
        limit: int = 50,
    ) -> AsyncPager[models.GqlCoinQuote]:
        """Top coins by market cap

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                "/v2/crypto/coins",
                query=query_of({"count": count, "fields": fields, "vsCurrency": vs_currency, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, models.GqlCoinQuote)

    async def get_crypto_global(
        self,
        *,
        fields: str | None = None,
    ) -> models.GqlGlobalCryptoStats:
        """Aggregate global cryptocurrency market statistics"""
        return await self._transport.request(
            "GET",
            "/v2/crypto/global",
            query=query_of({"fields": fields}),
            into=models.GqlGlobalCryptoStats,
        )

    async def get_crypto_news(
        self,
        *,
        fields: str | None = None,
        limit: int | None = None,
        page_cursor: str | None = None,
        page_limit: int | None = None,
    ) -> list[models.GqlNews]:
        """Market-wide crypto news"""
        return await self._transport.request(
            "GET",
            "/v2/crypto/news",
            query=query_of({"fields": fields, "limit": limit, "pageCursor": page_cursor, "pageLimit": page_limit}),
            into=list[models.GqlNews],
        )

    async def get_crypto_search(
        self,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
        limit_results: int | None = None,
        query: str,
    ) -> list[models.GqlSymbolMatch]:
        """Search CoinGecko's coin universe by free-text query"""
        return await self._transport.request(
            "GET",
            "/v2/crypto/search",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit, "limitResults": limit_results, "query": query}),
            into=list[models.GqlSymbolMatch],
        )

    async def get_crypto_trending(
        self,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlTrendingCoin]:
        """Coins trending on CoinGecko over the last 24h"""
        return await self._transport.request(
            "GET",
            "/v2/crypto/trending",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlTrendingCoin],
        )

    async def get_currencies(
        self,
        *,
        fields: str | None = None,
    ) -> list[models.GqlCurrency]:
        """Get available currencies"""
        return await self._transport.request(
            "GET",
            "/v2/currencies",
            query=query_of({"fields": fields}),
            into=list[models.GqlCurrency],
        )

    async def get_dividends(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
    ) -> models.GqlDividends:
        """Get dividend history and analytics"""
        return await self._transport.request(
            "GET",
            f"/v2/dividends/{path_seg(symbol)}",
            query=query_of({"fields": fields, "range": range}),
            into=models.GqlDividends,
        )

    def iter_dividends(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Get dividend history and analytics

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                f"/v2/dividends/{path_seg(symbol)}",
                query=query_of({"fields": fields, "range": range, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_earnings_surprises(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlEarningsSurpriseHistory:
        """Get earnings-surprise history"""
        return await self._transport.request(
            "GET",
            f"/v2/earnings-surprises/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlEarningsSurpriseHistory,
        )

    async def get_earnings_transcript(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        quarter: models.Quarter | None = None,
        year: int | None = None,
    ) -> models.GqlEarningsTranscript:
        """Get earnings call transcript"""
        return await self._transport.request(
            "GET",
            f"/v2/earnings-transcript/{path_seg(symbol)}",
            query=query_of({"fields": fields, "quarter": quarter, "year": year}),
            into=models.GqlEarningsTranscript,
        )

    async def get_edgar_cik(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlEdgarCik:
        """Resolve ticker to CIK"""
        return await self._transport.request(
            "GET",
            f"/v2/edgar/cik/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlEdgarCik,
        )

    async def get_edgar_facts(
        self,
        symbol: str,
        *,
        concepts: str | None = None,
        fields: str | None = None,
        taxonomy: str | None = None,
    ) -> list[models.GqlFactConcept]:
        """Get XBRL financial data"""
        return await self._transport.request(
            "GET",
            f"/v2/edgar/facts/{path_seg(symbol)}",
            query=query_of({"concepts": concepts, "fields": fields, "taxonomy": taxonomy}),
            into=list[models.GqlFactConcept],
        )

    def iter_edgar_facts(
        self,
        symbol: str,
        *,
        concepts: str | None = None,
        fields: str | None = None,
        taxonomy: str | None = None,
        limit: int = 50,
    ) -> AsyncPager[models.GqlFactConcept]:
        """Get XBRL financial data

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                f"/v2/edgar/facts/{path_seg(symbol)}",
                query=query_of({"concepts": concepts, "fields": fields, "taxonomy": taxonomy, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, models.GqlFactConcept)

    async def get_edgar_search(
        self,
        *,
        end_date: str | None = None,
        fields: str | None = None,
        forms: str | None = None,
        from_: int | None = None,
        q: str,
        size: int | None = None,
        start_date: str | None = None,
    ) -> models.GqlEdgarSearchResults:
        """Search SEC filings"""
        return await self._transport.request(
            "GET",
            "/v2/edgar/search",
            query=query_of({"endDate": end_date, "fields": fields, "forms": forms, "from": from_, "q": q, "size": size, "startDate": start_date}),
            into=models.GqlEdgarSearchResults,
        )

    async def get_edgar_submissions(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlEdgarSubmissions:
        """Get SEC filing history"""
        return await self._transport.request(
            "GET",
            f"/v2/edgar/submissions/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlEdgarSubmissions,
        )

    def iter_edgar_submissions(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Get SEC filing history

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                f"/v2/edgar/submissions/{path_seg(symbol)}",
                query=query_of({"fields": fields, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_etf_profile(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlEtfProfile:
        """Get ETF profile and holdings"""
        return await self._transport.request(
            "GET",
            f"/v2/etf-profile/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlEtfProfile,
        )

    async def get_exchanges(
        self,
        *,
        fields: str | None = None,
    ) -> list[models.GqlExchange]:
        """Get supported exchanges"""
        return await self._transport.request(
            "GET",
            "/v2/exchanges",
            query=query_of({"fields": fields}),
            into=list[models.GqlExchange],
        )

    async def get_executive_compensation(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlExecutiveCompensation]:
        """Disclosed executive compensation by year."""
        return await self._transport.request(
            "GET",
            f"/v2/executive-compensation/{path_seg(symbol)}",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlExecutiveCompensation],
        )

    async def get_fails_to_deliver(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlFailToDeliver]:
        """Fails-to-deliver records for a symbol"""
        return await self._transport.request(
            "GET",
            f"/v2/filings/{path_seg(symbol)}/fails-to-deliver",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlFailToDeliver],
        )

    async def get_fear_and_greed(
        self,
        *,
        fields: str | None = None,
    ) -> models.GqlFearAndGreed:
        """Fear & Greed Index"""
        return await self._transport.request(
            "GET",
            "/v2/fear-and-greed",
            query=query_of({"fields": fields}),
            into=models.GqlFearAndGreed,
        )

    async def get_feeds(
        self,
        *,
        fields: str | None = None,
        form_type: str | None = None,
        sources: str | None = None,
    ) -> list[models.GqlFeedEntry]:
        """RSS/Atom news feeds"""
        return await self._transport.request(
            "GET",
            "/v2/feeds",
            query=query_of({"fields": fields, "formType": form_type, "sources": sources}),
            into=list[models.GqlFeedEntry],
        )

    def iter_feeds(
        self,
        *,
        fields: str | None = None,
        form_type: str | None = None,
        sources: str | None = None,
        limit: int = 50,
    ) -> AsyncPager[models.GqlFeedEntry]:
        """RSS/Atom news feeds

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                "/v2/feeds",
                query=query_of({"fields": fields, "formType": form_type, "sources": sources, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, models.GqlFeedEntry)

    async def get_filing_sections(
        self,
        symbol: str,
        *,
        accession_number: str,
        fields: str | None = None,
        form: models.FilingSectionFormParam,
    ) -> list[models.GqlFilingSection]:
        """Get sectioned text of one SEC filing"""
        return await self._transport.request(
            "GET",
            f"/v2/filings/{path_seg(symbol)}/sections",
            query=query_of({"accessionNumber": accession_number, "fields": fields, "form": form}),
            into=list[models.GqlFilingSection],
        )

    async def get_financials(
        self,
        symbol: str,
        statement: models.StatementType,
        *,
        fields: str | None = None,
        frequency: models.Frequency | None = None,
        metrics: str | None = None,
    ) -> list[models.GqlFinancialLineItem]:
        """Get financial statements"""
        return await self._transport.request(
            "GET",
            f"/v2/financials/{path_seg(symbol)}/{path_seg(statement)}",
            query=query_of({"fields": fields, "frequency": frequency, "metrics": metrics}),
            into=list[models.GqlFinancialLineItem],
        )

    async def get_forex(
        self,
        from_: str,
        to: str,
        *,
        fields: str | None = None,
    ) -> models.GqlForexQuote:
        """Get a currency pair's current exchange rate"""
        return await self._transport.request(
            "GET",
            f"/v2/forex/{path_seg(from_)}/{path_seg(to)}",
            query=query_of({"fields": fields}),
            into=models.GqlForexQuote,
        )

    async def get_forex_news(
        self,
        *,
        fields: str | None = None,
        limit: int | None = None,
        page_cursor: str | None = None,
        page_limit: int | None = None,
    ) -> list[models.GqlNews]:
        """Market-wide forex news"""
        return await self._transport.request(
            "GET",
            "/v2/forex/news",
            query=query_of({"fields": fields, "limit": limit, "pageCursor": page_cursor, "pageLimit": page_limit}),
            into=list[models.GqlNews],
        )

    async def get_fred_series(
        self,
        id: str,
        *,
        fields: str | None = None,
    ) -> models.GqlMacroSeries:
        """FRED time series"""
        return await self._transport.request(
            "GET",
            f"/v2/fred/series/{path_seg(id)}",
            query=query_of({"fields": fields}),
            into=models.GqlMacroSeries,
        )

    def iter_fred_series(
        self,
        id: str,
        *,
        fields: str | None = None,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """FRED time series

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                f"/v2/fred/series/{path_seg(id)}",
                query=query_of({"fields": fields, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_fred_treasury_yields(
        self,
        *,
        fields: str | None = None,
        year: int | None = None,
    ) -> list[models.GqlTreasuryYield]:
        """US Treasury yield curve"""
        return await self._transport.request(
            "GET",
            "/v2/fred/treasury-yields",
            query=query_of({"fields": fields, "year": year}),
            into=list[models.GqlTreasuryYield],
        )

    def iter_fred_treasury_yields(
        self,
        *,
        fields: str | None = None,
        year: int | None = None,
        limit: int = 50,
    ) -> AsyncPager[models.GqlTreasuryYield]:
        """US Treasury yield curve

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                "/v2/fred/treasury-yields",
                query=query_of({"fields": fields, "year": year, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, models.GqlTreasuryYield)

    async def get_futures(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlFuturesQuote:
        """Get a futures contract's current quote"""
        return await self._transport.request(
            "GET",
            f"/v2/futures/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlFuturesQuote,
        )

    async def get_gdelt_news(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlNews]:
        """Worldwide news mentioning a symbol (GDELT, keyless)"""
        return await self._transport.request(
            "GET",
            f"/v2/gdelt/news/{path_seg(symbol)}",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlNews],
        )

    async def get_general_news(
        self,
        *,
        count: int | None = None,
        fields: str | None = None,
        lang: str | None = None,
    ) -> list[models.GqlNews]:
        """Get general market news"""
        return await self._transport.request(
            "GET",
            "/v2/news",
            query=query_of({"count": count, "fields": fields, "lang": lang}),
            into=list[models.GqlNews],
        )

    def iter_general_news(
        self,
        *,
        count: int | None = None,
        fields: str | None = None,
        lang: str | None = None,
        limit: int = 50,
    ) -> AsyncPager[models.GqlNews]:
        """Get general market news

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                "/v2/news",
                query=query_of({"count": count, "fields": fields, "lang": lang, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, models.GqlNews)

    async def get_grading_actions(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlGradingAction]:
        """Provider-routed analyst upgrades and downgrades."""
        return await self._transport.request(
            "GET",
            f"/v2/grading-actions/{path_seg(symbol)}",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlGradingAction],
        )

    async def get_holders(
        self,
        symbol: str,
        type: models.HolderType,
        *,
        fields: str | None = None,
    ) -> models.HoldersResponse:
        """Get holder data"""
        return await self._transport.request(
            "GET",
            f"/v2/holders/{path_seg(symbol)}/{path_seg(type)}",
            query=query_of({"fields": fields}),
            into=models.HoldersResponse,
        )

    def iter_holders(
        self,
        symbol: str,
        type: models.HolderType,
        *,
        fields: str | None = None,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Get holder data

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                f"/v2/holders/{path_seg(symbol)}/{path_seg(type)}",
                query=query_of({"fields": fields, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_hours(
        self,
        *,
        fields: str | None = None,
        region: models.Region | None = None,
    ) -> models.GqlMarketHours:
        """Get market hours"""
        return await self._transport.request(
            "GET",
            "/v2/hours",
            query=query_of({"fields": fields, "region": region}),
            into=models.GqlMarketHours,
        )

    async def get_index_constituent_changes(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlIndexConstituentChange]:
        """Additions and removals from an index's constituent list."""
        return await self._transport.request(
            "GET",
            f"/v2/indices/{path_seg(symbol)}/constituent-changes",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlIndexConstituentChange],
        )

    async def get_index_constituents(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> list[models.GqlIndexConstituent]:
        """Get an index's current constituent list"""
        return await self._transport.request(
            "GET",
            f"/v2/index-constituents/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=list[models.GqlIndexConstituent],
        )

    async def get_indicators(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        range: models.TimeRange | None = None,
    ) -> models.GqlIndicatorsSummary:
        """Get technical indicators"""
        return await self._transport.request(
            "GET",
            f"/v2/indicators/{path_seg(symbol)}",
            query=query_of({"fields": fields, "interval": interval, "range": range}),
            into=models.GqlIndicatorsSummary,
        )

    async def get_indices(
        self,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        region: models.indices_Region | None = None,
    ) -> list[models.GqlQuote]:
        """Get world market indices"""
        return await self._transport.request(
            "GET",
            "/v2/indices",
            query=query_of({"fields": fields, "format": format, "region": region}),
            into=list[models.GqlQuote],
        )

    async def get_industry(
        self,
        industry: models.Industry,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
    ) -> models.GqlIndustryData:
        """Get industry data"""
        return await self._transport.request(
            "GET",
            f"/v2/industries/{path_seg(industry)}",
            query=query_of({"fields": fields, "format": format, "lang": lang}),
            into=models.GqlIndustryData,
        )

    async def get_key_metrics_ttm(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlKeyMetricsTtm:
        """Trailing-twelve-month key metrics."""
        return await self._transport.request(
            "GET",
            f"/v2/key-metrics-ttm/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlKeyMetricsTtm,
        )

    async def get_market_calendar(
        self,
        *,
        fields: str | None = None,
        from_: str | None = None,
        kind: models.MarketCalendarKindParam,
        to: str | None = None,
    ) -> list[models.GqlMarketCalendarEntry]:
        """Get a market-wide event calendar"""
        return await self._transport.request(
            "GET",
            "/v2/market-calendar",
            query=query_of({"fields": fields, "from": from_, "kind": kind, "to": to}),
            into=list[models.GqlMarketCalendarEntry],
        )

    async def get_market_summary(
        self,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
        region: models.Region | None = None,
    ) -> list[models.GqlMarketSummaryQuote]:
        """Get market summary"""
        return await self._transport.request(
            "GET",
            "/v2/market-summary",
            query=query_of({"fields": fields, "format": format, "lang": lang, "region": region}),
            into=list[models.GqlMarketSummaryQuote],
        )

    async def get_metrics(
        self,
    ) -> models.MetricsText:
        """Prometheus metrics"""
        return await self._transport.request(
            "GET",
            "/v2/metrics",
            into=models.MetricsText,
        )

    async def get_news(
        self,
        symbol: str,
        *,
        count: int | None = None,
        fields: str | None = None,
        lang: str | None = None,
    ) -> list[models.GqlNews]:
        """Get news for a symbol"""
        return await self._transport.request(
            "GET",
            f"/v2/news/{path_seg(symbol)}",
            query=query_of({"count": count, "fields": fields, "lang": lang}),
            into=list[models.GqlNews],
        )

    def iter_news(
        self,
        symbol: str,
        *,
        count: int | None = None,
        fields: str | None = None,
        lang: str | None = None,
        limit: int = 50,
    ) -> AsyncPager[models.GqlNews]:
        """Get news for a symbol

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                f"/v2/news/{path_seg(symbol)}",
                query=query_of({"count": count, "fields": fields, "lang": lang, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, models.GqlNews)

    async def get_options(
        self,
        symbol: str,
        *,
        date: int | None = None,
        fields: str | None = None,
    ) -> models.GqlOptions:
        """Get options chain"""
        return await self._transport.request(
            "GET",
            f"/v2/options/{path_seg(symbol)}",
            query=query_of({"date": date, "fields": fields}),
            into=models.GqlOptions,
        )

    def iter_options(
        self,
        symbol: str,
        *,
        date: int | None = None,
        fields: str | None = None,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Get options chain

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                f"/v2/options/{path_seg(symbol)}",
                query=query_of({"date": date, "fields": fields, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_press_releases(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlPressRelease]:
        """Get a company's own press releases"""
        return await self._transport.request(
            "GET",
            f"/v2/press-releases/{path_seg(symbol)}",
            query=query_of({"fields": fields, "limit": limit}),
            into=list[models.GqlPressRelease],
        )

    async def get_price_target_consensus(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlPriceTargetConsensus:
        """Get consensus analyst price target"""
        return await self._transport.request(
            "GET",
            f"/v2/price-target-consensus/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlPriceTargetConsensus,
        )

    async def get_price_target_summary(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlPriceTargetSummary:
        """Analyst price-target counts and averages per window."""
        return await self._transport.request(
            "GET",
            f"/v2/price-target-summary/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlPriceTargetSummary,
        )

    async def get_protocol_tvl(
        self,
        id: str,
        *,
        fields: str | None = None,
    ) -> models.GqlProtocolTvl:
        """A DeFi protocol's total value locked (DefiLlama, keyless)."""
        return await self._transport.request(
            "GET",
            f"/v2/crypto/coins/{path_seg(id)}/tvl",
            query=query_of({"fields": fields}),
            into=models.GqlProtocolTvl,
        )

    async def get_protocol_tvl_history(
        self,
        id: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlTvlPoint]:
        """A protocol's TVL history, oldest first."""
        return await self._transport.request(
            "GET",
            f"/v2/crypto/coins/{path_seg(id)}/tvl-history",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlTvlPoint],
        )

    async def get_quote(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
        logo: bool | None = None,
    ) -> models.GqlQuote:
        """Get quote for a symbol"""
        return await self._transport.request(
            "GET",
            f"/v2/quote/{path_seg(symbol)}",
            query=query_of({"fields": fields, "format": format, "lang": lang, "logo": logo}),
            into=models.GqlQuote,
        )

    async def get_quote_type(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlQuoteTypeData:
        """Get quote type"""
        return await self._transport.request(
            "GET",
            f"/v2/quote-type/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlQuoteTypeData,
        )

    async def get_quotes(
        self,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
        logo: bool | None = None,
        symbols: str,
    ) -> models.GqlQuotesBatch:
        """Get quotes for multiple symbols"""
        return await self._transport.request(
            "GET",
            "/v2/quotes",
            query=query_of({"fields": fields, "format": format, "lang": lang, "logo": logo, "symbols": symbols}),
            into=models.GqlQuotesBatch,
        )

    def iter_quotes(
        self,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
        logo: bool | None = None,
        symbols: str,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Get quotes for multiple symbols

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                "/v2/quotes",
                query=query_of({"fields": fields, "format": format, "lang": lang, "logo": logo, "symbols": symbols, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)

    async def get_rating_consensus(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlRatingConsensus:
        """Get consensus rating rollup"""
        return await self._transport.request(
            "GET",
            f"/v2/rating-consensus/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlRatingConsensus,
        )

    async def get_ratios_ttm(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlFinancialRatiosTtm:
        """Trailing-twelve-month financial ratios."""
        return await self._transport.request(
            "GET",
            f"/v2/ratios-ttm/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlFinancialRatiosTtm,
        )

    async def get_recommendations(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        limit: int | None = None,
    ) -> models.GqlRecommendation:
        """Get similar stock recommendations"""
        return await self._transport.request(
            "GET",
            f"/v2/recommendations/{path_seg(symbol)}",
            query=query_of({"fields": fields, "limit": limit}),
            into=models.GqlRecommendation,
        )

    async def get_risk(
        self,
        symbol: str,
        *,
        benchmark: str | None = None,
        fields: str | None = None,
        interval: models.Interval | None = None,
        range: models.TimeRange | None = None,
    ) -> models.GqlRiskSummary:
        """Risk analytics"""
        return await self._transport.request(
            "GET",
            f"/v2/risk/{path_seg(symbol)}",
            query=query_of({"benchmark": benchmark, "fields": fields, "interval": interval, "range": range}),
            into=models.GqlRiskSummary,
        )

    async def get_risk_factors(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> list[models.GqlRiskFactor]:
        """Get risk factors extracted from SEC filings"""
        return await self._transport.request(
            "GET",
            f"/v2/filings/{path_seg(symbol)}/risk-factors",
            query=query_of({"fields": fields}),
            into=list[models.GqlRiskFactor],
        )

    async def get_screeners(
        self,
        screener: models.Screener,
        *,
        count: int | None = None,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
    ) -> models.GqlScreenerResults:
        """Get screener results"""
        return await self._transport.request(
            "GET",
            f"/v2/screeners/{path_seg(screener)}",
            query=query_of({"count": count, "fields": fields, "format": format}),
            into=models.GqlScreenerResults,
        )

    async def get_sector(
        self,
        sector: models.Sector,
        *,
        fields: str | None = None,
        format: models.ValueFormat | None = None,
        lang: str | None = None,
    ) -> models.GqlSectorData:
        """Get sector data"""
        return await self._transport.request(
            "GET",
            f"/v2/sectors/{path_seg(sector)}",
            query=query_of({"fields": fields, "format": format, "lang": lang}),
            into=models.GqlSectorData,
        )

    async def get_sector_pe(
        self,
        *,
        fields: str | None = None,
    ) -> list[models.GqlMarketSectorPe]:
        """Get price/earnings ratios by sector"""
        return await self._transport.request(
            "GET",
            "/v2/sector-pe",
            query=query_of({"fields": fields}),
            into=list[models.GqlMarketSectorPe],
        )

    async def get_sector_performance(
        self,
        *,
        fields: str | None = None,
    ) -> list[models.GqlMarketSectorPerformance]:
        """Get aggregate performance for every sector"""
        return await self._transport.request(
            "GET",
            "/v2/sector-performance",
            query=query_of({"fields": fields}),
            into=list[models.GqlMarketSectorPerformance],
        )

    async def get_sector_performance_history(
        self,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlSectorPerformanceHistory]:
        """Sector performance per session."""
        return await self._transport.request(
            "GET",
            "/v2/sector-performance/history",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlSectorPerformanceHistory],
        )

    async def get_short_volume(
        self,
        symbol: str,
        *,
        cursor: str | None = None,
        fields: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlShortVolume]:
        """Daily FINRA short-sale volume for a symbol (keyless)."""
        return await self._transport.request(
            "GET",
            f"/v2/short-volume/{path_seg(symbol)}",
            query=query_of({"cursor": cursor, "fields": fields, "limit": limit}),
            into=list[models.GqlShortVolume],
        )

    async def get_spark(
        self,
        *,
        fields: str | None = None,
        interval: models.Interval | None = None,
        range: models.TimeRange | None = None,
        symbols: str,
    ) -> models.GqlSparkBatch:
        """Get batch sparkline data"""
        return await self._transport.request(
            "GET",
            "/v2/spark",
            query=query_of({"fields": fields, "interval": interval, "range": range, "symbols": symbols}),
            into=models.GqlSparkBatch,
        )

    async def get_splits(
        self,
        symbol: str,
        *,
        fields: str | None = None,
        range: models.TimeRange | None = None,
    ) -> list[models.GqlSplit]:
        """Get stock split history"""
        return await self._transport.request(
            "GET",
            f"/v2/splits/{path_seg(symbol)}",
            query=query_of({"fields": fields, "range": range}),
            into=list[models.GqlSplit],
        )

    async def get_symbol_details(
        self,
        symbol: str,
        *,
        fields: str | None = None,
    ) -> models.GqlSymbolDetails:
        """Reference detail for one symbol."""
        return await self._transport.request(
            "GET",
            f"/v2/symbol-details/{path_seg(symbol)}",
            query=query_of({"fields": fields}),
            into=models.GqlSymbolDetails,
        )

    async def get_transcript(
        self,
        symbol: str,
        *,
        lang: str | None = None,
        quarter: models.Quarter | None = None,
        year: int | None = None,
    ) -> models.GqlTranscript:
        """Get earnings transcript"""
        return await self._transport.request(
            "GET",
            f"/v2/transcripts/{path_seg(symbol)}",
            query=query_of({"lang": lang, "quarter": quarter, "year": year}),
            into=models.GqlTranscript,
        )

    async def get_transcripts(
        self,
        symbol: str,
        *,
        lang: str | None = None,
        limit: int | None = None,
    ) -> list[models.GqlTranscriptWithMeta]:
        """Get all earnings transcripts"""
        return await self._transport.request(
            "GET",
            f"/v2/transcripts/{path_seg(symbol)}/all",
            query=query_of({"lang": lang, "limit": limit}),
            into=list[models.GqlTranscriptWithMeta],
        )

    async def get_trending(
        self,
        *,
        fields: str | None = None,
        region: models.Region | None = None,
    ) -> list[models.GqlTrendingQuote]:
        """Get trending tickers"""
        return await self._transport.request(
            "GET",
            "/v2/trending",
            query=query_of({"fields": fields, "region": region}),
            into=list[models.GqlTrendingQuote],
        )

    async def health_check(
        self,
    ) -> models.HealthResponse:
        """Health check"""
        return await self._transport.request(
            "GET",
            "/v2/health",
            into=models.HealthResponse,
        )

    async def lookup(
        self,
        *,
        count: int | None = None,
        fields: str | None = None,
        lang: str | None = None,
        logo: bool | None = None,
        q: str,
        region: models.Region | None = None,
        type: models.LookupType | None = None,
    ) -> models.GqlLookupResults:
        """Look up symbols by type"""
        return await self._transport.request(
            "GET",
            "/v2/lookup",
            query=query_of({"count": count, "fields": fields, "lang": lang, "logo": logo, "q": q, "region": region, "type": type}),
            into=models.GqlLookupResults,
        )

    async def ping(
        self,
    ) -> models.PingResponse:
        """Ping endpoint"""
        return await self._transport.request(
            "GET",
            "/v2/ping",
            into=models.PingResponse,
        )

    async def post_backtest(
        self,
        symbol: str,
        body: models.BacktestRequest,
    ) -> models.GqlBacktestResult:
        """Run a strategy backtest"""
        return await self._transport.request(
            "POST",
            f"/v2/backtest/{path_seg(symbol)}",
            json_body=to_wire(body),
            into=models.GqlBacktestResult,
        )

    async def post_custom_screener(
        self,
        body: models.CustomScreenerRequest,
    ) -> models.GqlScreenerResults:
        """Custom screener query"""
        return await self._transport.request(
            "POST",
            "/v2/screeners/custom",
            json_body=to_wire(body),
            into=models.GqlScreenerResults,
        )

    async def search(
        self,
        *,
        cultural: bool | None = None,
        fields: str | None = None,
        fuzzy: bool | None = None,
        lang: str | None = None,
        logo: bool | None = None,
        news: int | None = None,
        q: str,
        quotes: int | None = None,
        region: models.Region | None = None,
        research: bool | None = None,
    ) -> models.GqlSearchResults:
        """Search symbols and companies"""
        return await self._transport.request(
            "GET",
            "/v2/search",
            query=query_of({"cultural": cultural, "fields": fields, "fuzzy": fuzzy, "lang": lang, "logo": logo, "news": news, "q": q, "quotes": quotes, "region": region, "research": research}),
            into=models.GqlSearchResults,
        )

    def iter_search(
        self,
        *,
        cultural: bool | None = None,
        fields: str | None = None,
        fuzzy: bool | None = None,
        lang: str | None = None,
        logo: bool | None = None,
        news: int | None = None,
        q: str,
        quotes: int | None = None,
        region: models.Region | None = None,
        research: bool | None = None,
        limit: int = 50,
    ) -> AsyncPager[typing.Any]:
        """Search symbols and companies

        Auto-paginates; iterate items or call `.pages()`.
        """
        async def fetch(cursor: str | None) -> typing.Any:
            return await self._transport.request(
                "GET",
                "/v2/search",
                query=query_of({"cultural": cultural, "fields": fields, "fuzzy": fuzzy, "lang": lang, "logo": logo, "news": news, "q": q, "quotes": quotes, "region": region, "research": research, "limit": limit, "cursor": cursor}),
            )

        return AsyncPager(fetch, typing.Any)