getanyapi 0.1.0__py3-none-any.whl

getanyapi/platforms/__init__.py

@@ -0,0 +1,89 @@
+# Generated - do not edit. Regenerate with: pnpm generate
+"""Lazy namespace registry.
+
+Maps a client attribute name to (module name, sync class, async class). The
+sync/async clients read this via __getattr__ to attach namespaces on first use,
+so `import getanyapi` stays fast (SPEC 3.1).
+"""
+
+from __future__ import annotations
+
+REGISTRY: dict[str, tuple[str, str, str]] = {
+    "ahrefs": ("ahrefs", "AhrefsNamespace", "AsyncAhrefsNamespace"),
+    "airbnb": ("airbnb", "AirbnbNamespace", "AsyncAirbnbNamespace"),
+    "alibaba": ("alibaba", "AlibabaNamespace", "AsyncAlibabaNamespace"),
+    "amazon": ("amazon", "AmazonNamespace", "AsyncAmazonNamespace"),
+    "appstore": ("appstore", "AppstoreNamespace", "AsyncAppstoreNamespace"),
+    "bluesky": ("bluesky", "BlueskyNamespace", "AsyncBlueskyNamespace"),
+    "booking": ("booking", "BookingNamespace", "AsyncBookingNamespace"),
+    "coinmarketcap": (
+        "coinmarketcap",
+        "CoinmarketcapNamespace",
+        "AsyncCoinmarketcapNamespace",
+    ),
+    "congress": ("congress", "CongressNamespace", "AsyncCongressNamespace"),
+    "dexscreener": ("dexscreener", "DexscreenerNamespace", "AsyncDexscreenerNamespace"),
+    "ebay": ("ebay", "EbayNamespace", "AsyncEbayNamespace"),
+    "email": ("email", "EmailNamespace", "AsyncEmailNamespace"),
+    "facebook": ("facebook", "FacebookNamespace", "AsyncFacebookNamespace"),
+    "fiverr": ("fiverr", "FiverrNamespace", "AsyncFiverrNamespace"),
+    "github": ("github", "GithubNamespace", "AsyncGithubNamespace"),
+    "glassdoor": ("glassdoor", "GlassdoorNamespace", "AsyncGlassdoorNamespace"),
+    "google": ("google", "GoogleNamespace", "AsyncGoogleNamespace"),
+    "google_ads": ("google_ads", "GoogleAdsNamespace", "AsyncGoogleAdsNamespace"),
+    "google_finance": (
+        "google_finance",
+        "GoogleFinanceNamespace",
+        "AsyncGoogleFinanceNamespace",
+    ),
+    "google_shopping": (
+        "google_shopping",
+        "GoogleShoppingNamespace",
+        "AsyncGoogleShoppingNamespace",
+    ),
+    "hackernews": ("hackernews", "HackernewsNamespace", "AsyncHackernewsNamespace"),
+    "indeed": ("indeed", "IndeedNamespace", "AsyncIndeedNamespace"),
+    "instagram": ("instagram", "InstagramNamespace", "AsyncInstagramNamespace"),
+    "linkedin": ("linkedin", "LinkedinNamespace", "AsyncLinkedinNamespace"),
+    "maps": ("maps", "MapsNamespace", "AsyncMapsNamespace"),
+    "pandaexpress": (
+        "pandaexpress",
+        "PandaexpressNamespace",
+        "AsyncPandaexpressNamespace",
+    ),
+    "person": ("person", "PersonNamespace", "AsyncPersonNamespace"),
+    "pinterest": ("pinterest", "PinterestNamespace", "AsyncPinterestNamespace"),
+    "playstore": ("playstore", "PlaystoreNamespace", "AsyncPlaystoreNamespace"),
+    "polymarket": ("polymarket", "PolymarketNamespace", "AsyncPolymarketNamespace"),
+    "realtor": ("realtor", "RealtorNamespace", "AsyncRealtorNamespace"),
+    "reddit": ("reddit", "RedditNamespace", "AsyncRedditNamespace"),
+    "redfin": ("redfin", "RedfinNamespace", "AsyncRedfinNamespace"),
+    "rednote": ("rednote", "RednoteNamespace", "AsyncRednoteNamespace"),
+    "sec": ("sec", "SecNamespace", "AsyncSecNamespace"),
+    "semrush": ("semrush", "SemrushNamespace", "AsyncSemrushNamespace"),
+    "snapchat": ("snapchat", "SnapchatNamespace", "AsyncSnapchatNamespace"),
+    "social": ("social", "SocialNamespace", "AsyncSocialNamespace"),
+    "spotify": ("spotify", "SpotifyNamespace", "AsyncSpotifyNamespace"),
+    "substack": ("substack", "SubstackNamespace", "AsyncSubstackNamespace"),
+    "threads": ("threads", "ThreadsNamespace", "AsyncThreadsNamespace"),
+    "tiktok": ("tiktok", "TiktokNamespace", "AsyncTiktokNamespace"),
+    "tiktok_shop": ("tiktok_shop", "TiktokShopNamespace", "AsyncTiktokShopNamespace"),
+    "tripadvisor": ("tripadvisor", "TripadvisorNamespace", "AsyncTripadvisorNamespace"),
+    "trustpilot": ("trustpilot", "TrustpilotNamespace", "AsyncTrustpilotNamespace"),
+    "truthsocial": ("truthsocial", "TruthsocialNamespace", "AsyncTruthsocialNamespace"),
+    "twitter": ("twitter", "TwitterNamespace", "AsyncTwitterNamespace"),
+    "upwork": ("upwork", "UpworkNamespace", "AsyncUpworkNamespace"),
+    "walmart": ("walmart", "WalmartNamespace", "AsyncWalmartNamespace"),
+    "web": ("web", "WebNamespace", "AsyncWebNamespace"),
+    "whatsapp": ("whatsapp", "WhatsappNamespace", "AsyncWhatsappNamespace"),
+    "yahoo_finance": (
+        "yahoo_finance",
+        "YahooFinanceNamespace",
+        "AsyncYahooFinanceNamespace",
+    ),
+    "yelp": ("yelp", "YelpNamespace", "AsyncYelpNamespace"),
+    "youtube": ("youtube", "YoutubeNamespace", "AsyncYoutubeNamespace"),
+    "zillow": ("zillow", "ZillowNamespace", "AsyncZillowNamespace"),
+}
+
+__all__ = ["REGISTRY"]

getanyapi/platforms/ahrefs.py

@@ -0,0 +1,384 @@
+# Generated - do not edit. Regenerate with: pnpm generate
+"""Generated namespace module for the ahrefs platform."""
+
+from __future__ import annotations
+
+from typing import Literal, TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import NotRequired, Required, TypedDict, Unpack
+
+from ..types import RequestOptions, RunResult
+
+if TYPE_CHECKING:
+    from .._async_client import AsyncAnyAPI
+    from .._client import AnyAPI
+
+
+class AhrefsBacklinksInput(TypedDict, total=False):
+    """Input for Ahrefs Backlinks."""
+
+    mode: NotRequired[Literal["exact", "subdomains"]]
+    """Match scope: "exact" for the given URL only, or "subdomains" to include the domain and its subdomains. Default: subdomains."""
+    url: Required[str]
+    """The domain or page URL to find backlinks for (e.g. "ahrefs.com")."""
+
+
+class AhrefsKeywordIdeasInput(TypedDict, total=False):
+    """Input for Ahrefs Keyword Ideas."""
+
+    country: NotRequired[str]
+    """Two-letter country code that scopes the suggestions (e.g. us, gb, de). Default: us."""
+    keyword: Required[str]
+    """The seed keyword to expand into related suggestions (e.g. "coffee")."""
+
+
+class AhrefsKeywordsInput(TypedDict, total=False):
+    """Input for Ahrefs Keyword Difficulty."""
+
+    country: NotRequired[str]
+    """Two-letter country code that scopes volume and difficulty (e.g. us, gb, de). Default: us."""
+    keyword: Required[str]
+    """The search term to analyze (e.g. "seo tools")."""
+
+
+class AhrefsOverviewInput(TypedDict, total=False):
+    """Input for Ahrefs Domain Overview."""
+
+    mode: NotRequired[Literal["exact", "subdomains"]]
+    """Analysis scope: subdomains covers the whole domain, exact matches only the given URL. Default: subdomains."""
+    url: Required[str]
+    """The domain or page URL to analyze (e.g. ahrefs.com)."""
+
+
+class AhrefsBacklinksData(BaseModel):
+    items: list[AhrefsBacklinksItem] = Field(
+        description="Referring pages that link to the domain or URL."
+    )
+
+
+class AhrefsBacklinksItem(BaseModel):
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    anchor: str | None = Field(default=None, description="Anchor text of the link.")
+    context_after: str | None = Field(
+        default=None,
+        alias="contextAfter",
+        description="Text immediately after the anchor on the referring page.",
+    )
+    context_before: str | None = Field(
+        default=None,
+        alias="contextBefore",
+        description="Text immediately before the anchor on the referring page.",
+    )
+    domain_rating: float | None = Field(
+        default=None,
+        alias="domainRating",
+        description="Ahrefs Domain Rating (0-100) of the linking domain.",
+    )
+    title: str | None = Field(default=None, description="Title of the referring page.")
+    url_from: str = Field(
+        alias="urlFrom", description="URL of the referring page that contains the link."
+    )
+    url_to: str | None = Field(
+        default=None, alias="urlTo", description="Target URL the link points to."
+    )
+
+
+class AhrefsKeywordIdeasData(BaseModel):
+    items: list[AhrefsKeywordIdeasItem] = Field(
+        description="Keyword-idea records: the seed keyword and its related keyword suggestions, each with an Ahrefs difficulty and search-volume bucket."
+    )
+
+
+class AhrefsKeywordIdeasItem(BaseModel):
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    country: str | None = Field(
+        default=None,
+        description="Two-letter country code the suggestions are scoped to.",
+    )
+    ideas: list[AhrefsKeywordIdeasIdea] | None = Field(
+        default=None,
+        description="Related keyword suggestions for the seed term. Present whenever the upstream returns this record.",
+    )
+    search_engine: str | None = Field(
+        default=None,
+        alias="searchEngine",
+        description="Search engine the suggestions are drawn from (e.g. Google).",
+    )
+    source_keyword: str = Field(
+        alias="sourceKeyword",
+        description="The seed keyword the suggestions were expanded from.",
+    )
+
+
+class AhrefsKeywordIdeasIdea(BaseModel):
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    difficulty: str | None = Field(
+        default=None,
+        description="Relative Ahrefs difficulty bucket (a letter such as E, M, or H), not an exact number.",
+    )
+    keyword: str = Field(description="The suggested related keyword.")
+    updated_at: str | None = Field(
+        default=None,
+        alias="updatedAt",
+        description="Timestamp the suggestion metrics were last updated.",
+    )
+    volume: str | None = Field(
+        default=None,
+        description="Relative search-volume bucket (a letter grade), not an exact number.",
+    )
+
+
+class AhrefsKeywordsData(BaseModel):
+    items: list[AhrefsKeywordsItem] = Field(
+        description="Keyword-difficulty records: the difficulty score and the referring-domain gap needed to rank in the top 10."
+    )
+
+
+class AhrefsKeywordsItem(BaseModel):
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    country: str | None = Field(
+        default=None, description="Two-letter country code the metrics are scoped to."
+    )
+    difficulty: int | None = Field(
+        default=None, description="Ahrefs Keyword Difficulty, 0-100."
+    )
+    keyword: str
+    referring_domains_to_rank: int | None = Field(
+        default=None,
+        alias="referringDomainsToRank",
+        description="Estimated number of referring domains a page needs to rank in the top 10 for this keyword.",
+    )
+
+
+class AhrefsOverviewData(BaseModel):
+    items: list[AhrefsOverviewItem] = Field(
+        description="Domain authority records: the requested domain plus its Domain Rating, total backlinks, and referring-domain counts."
+    )
+
+
+class AhrefsOverviewItem(BaseModel):
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    backlinks: int | None = Field(
+        default=None, description="Total number of backlinks pointing to the domain."
+    )
+    dofollow_backlinks_pct: int | None = Field(
+        default=None,
+        alias="dofollowBacklinksPct",
+        description="Percentage (0-100) of backlinks that are dofollow.",
+    )
+    dofollow_referring_domains_pct: int | None = Field(
+        default=None,
+        alias="dofollowReferringDomainsPct",
+        description="Percentage (0-100) of referring domains that provide a dofollow link.",
+    )
+    domain: str = Field(description="The domain or URL the metrics are scoped to.")
+    domain_rating: float | None = Field(
+        default=None,
+        alias="domainRating",
+        description="Ahrefs Domain Rating, 0-100, measuring backlink-profile strength.",
+    )
+    mode: str | None = Field(
+        default=None,
+        description="Analysis scope used: subdomains (whole domain) or exact (the given URL only).",
+    )
+    referring_domains: int | None = Field(
+        default=None,
+        alias="referringDomains",
+        description="Number of unique referring domains linking to the domain.",
+    )
+
+
+class AhrefsNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AnyAPI") -> None:
+        self._client = client
+
+    def backlinks(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AhrefsBacklinksInput],
+    ) -> RunResult[AhrefsBacklinksData]:
+        """Ahrefs Backlinks
+
+        Get the referring pages linking to a domain or URL, each with the source
+        page, anchor text, linking domain rating, and page title. Transparent
+        per-request USD pricing.
+
+        Price: $0.0195 per request.
+
+        Example:
+            res = client.ahrefs.backlinks(mode="exact", url="ahrefs.com")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "ahrefs.backlinks", dict(input), options
+        )
+        return RunResult[AhrefsBacklinksData].model_validate(raw)
+
+    def keyword_ideas(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AhrefsKeywordIdeasInput],
+    ) -> RunResult[AhrefsKeywordIdeasData]:
+        """Ahrefs Keyword Ideas
+
+        Get related keyword suggestions for any seed term, each with an Ahrefs
+        difficulty and search-volume bucket. Transparent per-request USD pricing.
+
+        Price: $0.0015 per request plus $0.018 per result.
+
+        Example:
+            res = client.ahrefs.keyword_ideas(country="us", keyword="coffee")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "ahrefs.keyword_ideas", dict(input), options
+        )
+        return RunResult[AhrefsKeywordIdeasData].model_validate(raw)
+
+    def keywords(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AhrefsKeywordsInput],
+    ) -> RunResult[AhrefsKeywordsData]:
+        """Ahrefs Keyword Difficulty
+
+        Get the Ahrefs keyword-difficulty metrics for any search term: the
+        difficulty score (0-100) and the number of referring domains a page needs to
+        rank in the top 10 - as normalized JSON with transparent per-request USD
+        pricing.
+
+        Price: $0.0015 per request plus $0.018 per result.
+
+        Example:
+            res = client.ahrefs.keywords(country="us", keyword="seo tools")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "ahrefs.keywords", dict(input), options
+        )
+        return RunResult[AhrefsKeywordsData].model_validate(raw)
+
+    def overview(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AhrefsOverviewInput],
+    ) -> RunResult[AhrefsOverviewData]:
+        """Ahrefs Domain Overview
+
+        Get an SEO authority overview for any domain or URL: Domain Rating, total
+        backlinks, and referring domains - as normalized JSON with transparent
+        per-request USD pricing.
+
+        Price: $0.0015 per request plus $0.018 per result.
+
+        Example:
+            res = client.ahrefs.overview(mode="subdomains", url="ahrefs.com")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "ahrefs.overview", dict(input), options
+        )
+        return RunResult[AhrefsOverviewData].model_validate(raw)
+
+
+class AsyncAhrefsNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AsyncAnyAPI") -> None:
+        self._client = client
+
+    async def backlinks(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AhrefsBacklinksInput],
+    ) -> RunResult[AhrefsBacklinksData]:
+        """Ahrefs Backlinks
+
+        Get the referring pages linking to a domain or URL, each with the source
+        page, anchor text, linking domain rating, and page title. Transparent
+        per-request USD pricing.
+
+        Price: $0.0195 per request.
+
+        Example:
+            res = client.ahrefs.backlinks(mode="exact", url="ahrefs.com")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "ahrefs.backlinks", dict(input), options
+        )
+        return RunResult[AhrefsBacklinksData].model_validate(raw)
+
+    async def keyword_ideas(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AhrefsKeywordIdeasInput],
+    ) -> RunResult[AhrefsKeywordIdeasData]:
+        """Ahrefs Keyword Ideas
+
+        Get related keyword suggestions for any seed term, each with an Ahrefs
+        difficulty and search-volume bucket. Transparent per-request USD pricing.
+
+        Price: $0.0015 per request plus $0.018 per result.
+
+        Example:
+            res = client.ahrefs.keyword_ideas(country="us", keyword="coffee")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "ahrefs.keyword_ideas", dict(input), options
+        )
+        return RunResult[AhrefsKeywordIdeasData].model_validate(raw)
+
+    async def keywords(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AhrefsKeywordsInput],
+    ) -> RunResult[AhrefsKeywordsData]:
+        """Ahrefs Keyword Difficulty
+
+        Get the Ahrefs keyword-difficulty metrics for any search term: the
+        difficulty score (0-100) and the number of referring domains a page needs to
+        rank in the top 10 - as normalized JSON with transparent per-request USD
+        pricing.
+
+        Price: $0.0015 per request plus $0.018 per result.
+
+        Example:
+            res = client.ahrefs.keywords(country="us", keyword="seo tools")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "ahrefs.keywords", dict(input), options
+        )
+        return RunResult[AhrefsKeywordsData].model_validate(raw)
+
+    async def overview(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AhrefsOverviewInput],
+    ) -> RunResult[AhrefsOverviewData]:
+        """Ahrefs Domain Overview
+
+        Get an SEO authority overview for any domain or URL: Domain Rating, total
+        backlinks, and referring domains - as normalized JSON with transparent
+        per-request USD pricing.
+
+        Price: $0.0015 per request plus $0.018 per result.
+
+        Example:
+            res = client.ahrefs.overview(mode="subdomains", url="ahrefs.com")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "ahrefs.overview", dict(input), options
+        )
+        return RunResult[AhrefsOverviewData].model_validate(raw)

getanyapi/platforms/airbnb.py

@@ -0,0 +1,120 @@
+# Generated - do not edit. Regenerate with: pnpm generate
+"""Generated namespace module for the airbnb platform."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import NotRequired, Required, TypedDict, Unpack
+
+from ..types import RequestOptions, RunResult
+
+if TYPE_CHECKING:
+    from .._async_client import AsyncAnyAPI
+    from .._client import AnyAPI
+
+
+class AirbnbSearchInput(TypedDict, total=False):
+    """Input for Airbnb Search."""
+
+    adults: NotRequired[int]
+    """Number of adult guests (e.g. 2)."""
+    checkIn: NotRequired[str]
+    """Check-in date in YYYY-MM-DD format (e.g. 2026-07-01)."""
+    checkOut: NotRequired[str]
+    """Check-out date in YYYY-MM-DD format (e.g. 2026-07-05)."""
+    currency: NotRequired[str]
+    """Currency code for prices (e.g. EUR). Default: USD."""
+    limit: NotRequired[int]
+    """Maximum number of results to return (1-20, default 20). You are billed per result returned, so a lower limit costs less. Range: 1 to 20."""
+    location: Required[str]
+    """Location to search listings in (e.g. London)."""
+
+
+class AirbnbSearchData(BaseModel):
+    items: list[AirbnbSearchItem] = Field(
+        description="Listing records: name, nightly price, rating, location, host info, and availability details."
+    )
+
+
+class AirbnbSearchItem(BaseModel):
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    host_name: str | None = Field(default=None, alias="hostName")
+    id: str = Field(description="Airbnb listing identifier.")
+    image: str | None = Field(
+        default=None,
+        description="Primary listing image URL. Present whenever the upstream returns this record.",
+    )
+    is_available: bool | None = Field(default=None, alias="isAvailable")
+    is_superhost: bool | None = Field(default=None, alias="isSuperhost")
+    latitude: float | None = None
+    location: str | None = Field(default=None, description="Location subtitle.")
+    longitude: float | None = None
+    person_capacity: int | None = Field(default=None, alias="personCapacity")
+    price: str | None = Field(default=None, description="Nightly price label.")
+    property_type: str | None = Field(default=None, alias="propertyType")
+    rating: float | None = Field(
+        default=None, description="Guest satisfaction rating (0-5)."
+    )
+    reviews_count: int | None = Field(default=None, alias="reviewsCount")
+    room_type: str | None = Field(default=None, alias="roomType")
+    title: str
+    url: str
+
+
+class AirbnbNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AnyAPI") -> None:
+        self._client = client
+
+    def search(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AirbnbSearchInput],
+    ) -> RunResult[AirbnbSearchData]:
+        """Airbnb Search
+
+        Search Airbnb listings by location and dates and get results (name, price,
+        rating, host) as normalized JSON with flat per-request USD pricing.
+
+        Price: $0.00008 per request plus $0.0015 per result.
+
+        Example:
+            res = client.airbnb.search(limit=3, location="San Diego")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "airbnb.search", dict(input), options
+        )
+        return RunResult[AirbnbSearchData].model_validate(raw)
+
+
+class AsyncAirbnbNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AsyncAnyAPI") -> None:
+        self._client = client
+
+    async def search(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AirbnbSearchInput],
+    ) -> RunResult[AirbnbSearchData]:
+        """Airbnb Search
+
+        Search Airbnb listings by location and dates and get results (name, price,
+        rating, host) as normalized JSON with flat per-request USD pricing.
+
+        Price: $0.00008 per request plus $0.0015 per result.
+
+        Example:
+            res = client.airbnb.search(limit=3, location="San Diego")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "airbnb.search", dict(input), options
+        )
+        return RunResult[AirbnbSearchData].model_validate(raw)

getanyapi/platforms/alibaba.py

@@ -0,0 +1,95 @@
+# Generated - do not edit. Regenerate with: pnpm generate
+"""Generated namespace module for the alibaba platform."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import NotRequired, Required, TypedDict, Unpack
+
+from ..types import RequestOptions, RunResult
+
+if TYPE_CHECKING:
+    from .._async_client import AsyncAnyAPI
+    from .._client import AnyAPI
+
+
+class AlibabaSearchInput(TypedDict, total=False):
+    """Input for Alibaba Search."""
+
+    limit: NotRequired[int]
+    """Maximum number of results to return (1-25, default 25). You are billed per result returned, so a lower limit costs less. Range: 1 to 25."""
+    query: Required[str]
+    """Keywords to search for on Alibaba (e.g. "bluetooth speaker wholesale")."""
+
+
+class AlibabaSearchData(BaseModel):
+    items: list[AlibabaSearchItem] = Field(
+        description="Matching Alibaba wholesale listings: title, price range, minimum order quantity, supplier name, and listing URL."
+    )
+
+
+class AlibabaSearchItem(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    title: str
+    url: str
+
+
+class AlibabaNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AnyAPI") -> None:
+        self._client = client
+
+    def search(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AlibabaSearchInput],
+    ) -> RunResult[AlibabaSearchData]:
+        """Alibaba Search
+
+        Search Alibaba by keyword and get up to 25 wholesale listings - title, price
+        range, minimum order, and supplier - in one normalized, flat-priced
+        response.
+
+        Price: $0.0012 per result.
+
+        Example:
+            res = client.alibaba.search(limit=3, query="bluetooth speaker")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "alibaba.search", dict(input), options
+        )
+        return RunResult[AlibabaSearchData].model_validate(raw)
+
+
+class AsyncAlibabaNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AsyncAnyAPI") -> None:
+        self._client = client
+
+    async def search(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[AlibabaSearchInput],
+    ) -> RunResult[AlibabaSearchData]:
+        """Alibaba Search
+
+        Search Alibaba by keyword and get up to 25 wholesale listings - title, price
+        range, minimum order, and supplier - in one normalized, flat-priced
+        response.
+
+        Price: $0.0012 per result.
+
+        Example:
+            res = client.alibaba.search(limit=3, query="bluetooth speaker")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "alibaba.search", dict(input), options
+        )
+        return RunResult[AlibabaSearchData].model_validate(raw)