@opensea/cli 0.4.1 → 1.0.0

package/dist/index.d.ts

@@ -1,161 +1,65 @@
-type Chain = "ethereum" | "polygon" | "base" | "blast" | "arbitrum" | "avalanche" | "optimism" | "solana" | "zora" | "sei" | "b3" | "bera_chain" | "ape_chain" | "flow" | "ronin" | "abstract" | "shape" | "unichain" | "gunzilla" | "hyperevm" | "somnia" | "monad";
+import { components } from '@opensea/api-types';
+
+/**
+ * API types for the OpenSea CLI.
+ *
+ * Types that match the OpenSea API spec are imported from @opensea/api-types.
+ * CLI-specific types (swap, search UI, token details) are defined locally.
+ */
+
+type Schemas = components["schemas"];
+type Chain = Schemas["ChainIdentifier"];
+type Fee = Schemas["Fee"];
+type PaymentToken = Schemas["PaymentToken"];
+type Price = Schemas["Price"];
+type Trait = Schemas["Trait"];
+type Contract = Schemas["Contract"];
+type Nft = Schemas["Nft"];
+type NftDetailed = Schemas["NftDetailed"];
+type Owner = Schemas["Owner"];
+type Rarity = Schemas["Rarity"];
+type CollectionRarity = Schemas["CollectionRarity"];
+type Order = Schemas["Order"];
+type Offer = Schemas["Offer"];
+type Listing = Schemas["Listing"];
+type ListingPrice = Schemas["ListingPrice"];
+type Payment = Schemas["Payment"];
+type Event = Schemas["Event"];
+type SaleEvent = Schemas["SaleEvent"];
+type TransferEvent = Schemas["TransferEvent"];
+type OrderEvent = Schemas["OrderEvent"];
+type SimpleAccount = Schemas["SimpleAccount"];
+type SocialMediaAccount = Schemas["SocialMediaAccount"];
+type ProtocolData = Schemas["ProtocolData"];
+type IntervalStat = Schemas["IntervalStat"];
+type Total = Schemas["Total"];
+type PricingCurrencies = Schemas["PricingCurrencies"];
+type CollectionResponse = Schemas["CollectionResponse"];
+type CollectionDetailedResponse = Schemas["CollectionDetailedResponse"];
+type CollectionPaginatedResponse = Schemas["CollectionPaginatedResponse"];
+type CollectionStatsResponse = Schemas["CollectionStatsResponse"];
+type NftResponse = Schemas["NftResponse"];
+type NftListResponse = Schemas["NftListResponse"];
+type OrdersResponse = Schemas["OrdersResponse"];
+type OffersResponse = Schemas["OffersResponse"];
+type ListingsResponse = Schemas["ListingsResponse"];
+type GetOrderResponse = Schemas["GetOrderResponse"];
+type AssetEventsResponse = Schemas["AssetEventsResponse"];
+type AccountResponse = Schemas["AccountResponse"];
+type ContractResponse = Schemas["ContractResponse"];
+type FulfillListingResponse = Schemas["FulfillListingResponse"];
+type DropResponse = Schemas["DropResponse"];
+type DropDetailedResponse = Schemas["DropDetailedResponse"];
+type DropStageResponse = Schemas["DropStageResponse"];
+type DropPaginatedResponse = Schemas["DropPaginatedResponse"];
+type DropMintRequest = Schemas["DropMintRequest"];
+type DropMintResponse = Schemas["DropMintResponse"];
+type AccountResolveResponse = Schemas["AccountResolveResponse"];
 type SafelistStatus = "not_requested" | "requested" | "approved" | "verified" | "disabled_top_trending";
 type CollectionOrderBy = "created_date" | "one_day_change" | "seven_day_volume" | "seven_day_change" | "num_owners" | "market_cap";
 type EventType = "sale" | "transfer" | "mint" | "listing" | "offer" | "trait_offer" | "collection_offer";
 type OrderSide = "ask" | "bid";
-interface Fee {
-    fee: number;
-    recipient: string;
-    required: boolean;
-}
-interface PaymentToken {
-    name: string;
-    symbol: string;
-    decimals: number;
-    address: string;
-    chain: Chain;
-    image_url?: string;
-    eth_price?: string;
-    usd_price?: string;
-}
-interface Collection {
-    name: string;
-    collection: string;
-    description: string;
-    image_url: string;
-    banner_image_url: string;
-    owner: string;
-    safelist_status: SafelistStatus;
-    category: string;
-    is_disabled: boolean;
-    is_nsfw: boolean;
-    trait_offers_enabled: boolean;
-    collection_offers_enabled: boolean;
-    opensea_url: string;
-    project_url: string;
-    wiki_url: string;
-    discord_url: string;
-    telegram_url: string;
-    twitter_username: string;
-    instagram_username: string;
-    contracts: {
-        address: string;
-        chain: Chain;
-    }[];
-    editors: string[];
-    fees: Fee[];
-    rarity: {
-        strategy_id: string;
-        strategy_version: string;
-        calculated_at: string;
-        max_rank: number;
-        tokens_scored: number;
-    } | null;
-    payment_tokens: PaymentToken[];
-    total_supply: number;
-    created_date: string;
-    required_zone?: string;
-}
-interface CollectionStats {
-    total: {
-        volume: number;
-        sales: number;
-        average_price: number;
-        num_owners: number;
-        market_cap: number;
-        floor_price: number;
-        floor_price_symbol: string;
-    };
-    intervals: {
-        interval: "one_day" | "seven_day" | "thirty_day";
-        volume: number;
-        volume_diff: number;
-        volume_change: number;
-        sales: number;
-        sales_diff: number;
-        average_price: number;
-    }[];
-}
-interface NFT {
-    identifier: string;
-    collection: string;
-    contract: string;
-    token_standard: string;
-    name: string;
-    description: string;
-    image_url: string;
-    metadata_url: string;
-    opensea_url: string;
-    updated_at: string;
-    is_disabled: boolean;
-    is_nsfw: boolean;
-    traits: Trait[] | null;
-    creator: string;
-    owners: {
-        address: string;
-        quantity: number;
-    }[];
-    rarity: {
-        strategy_id: string | null;
-        strategy_version: string | null;
-        rank: number | null;
-        score: number | null;
-        calculated_at: string;
-        max_rank: number | null;
-        tokens_scored: number | null;
-        ranking_features: {
-            unique_attribute_count: number;
-        } | null;
-    } | null;
-}
-interface Trait {
-    trait_type: string;
-    display_type: string;
-    max_value: string;
-    value: string | number;
-}
-interface Price {
-    currency: string;
-    decimals: number;
-    value: string;
-}
-interface Order {
-    order_hash: string;
-    chain: string;
-    protocol_data: Record<string, unknown>;
-    protocol_address: string;
-    price: Price;
-}
-interface Offer extends Order {
-    criteria?: {
-        collection: {
-            slug: string;
-        };
-        contract: {
-            address: string;
-        };
-        encoded_token_ids?: string;
-        trait?: {
-            type: string;
-            value: string;
-        };
-    };
-    status: string;
-}
-interface Listing extends Omit<Order, "price"> {
-    type: string;
-    price: {
-        current: Price;
-    };
-    remaining_quantity: number;
-    status: string;
-}
-interface EventPayment {
-    quantity: string;
-    token_address: string;
-    decimals: number;
-    symbol: string;
-}
+
 interface EventAsset {
     identifier: string;
     collection: string;
@@ -177,26 +81,6 @@ interface AssetEvent {
     quantity: number;
     [key: string]: unknown;
 }
-interface Contract {
-    address: string;
-    chain: string;
-    collection: string | null;
-    name: string;
-    contract_standard: string;
-}
-interface Account {
-    address: string;
-    username: string;
-    profile_image_url: string;
-    banner_image_url: string;
-    website: string;
-    social_media_accounts: {
-        platform: string;
-        username: string;
-    }[];
-    bio: string;
-    joined_date: string;
-}
 interface TraitCategories {
     [traitType: string]: "string" | "number" | "date";
 }
@@ -312,6 +196,63 @@ interface SearchResult {
 interface SearchResponse {
     results: SearchResult[];
 }
+interface ChainInfo {
+    chain: string;
+    name: string;
+    symbol: string;
+    supports_swaps: boolean;
+    block_explorer: string;
+    block_explorer_url: string;
+}
+interface ChainListResponse {
+    chains: ChainInfo[];
+}
+interface TokenBalance {
+    address: string;
+    chain: string;
+    name: string;
+    symbol: string;
+    image_url?: string;
+    usd_price: string;
+    decimals: number;
+    quantity: string;
+    usd_value: string;
+    opensea_url: string;
+}
+interface TokenBalancePaginatedResponse {
+    token_balances: TokenBalance[];
+    next?: string;
+}
+type TokenBalanceSortBy = "USD_VALUE" | "MARKET_CAP" | "ONE_DAY_VOLUME" | "PRICE" | "ONE_DAY_PRICE_CHANGE" | "SEVEN_DAY_PRICE_CHANGE";
+interface ValidateMetadataResponse {
+    assetIdentifier: {
+        chain: string;
+        contractAddress: string;
+        tokenId: string;
+    };
+    tokenUri?: string;
+    metadata?: {
+        name?: string;
+        description?: string;
+        originalImageUrl?: string;
+        processedImageUrl?: string;
+        originalAnimationUrl?: string;
+        processedAnimationUrl?: string;
+        externalUrl?: string;
+        backgroundColor?: string;
+        attributes: {
+            traitType: string;
+            value: string;
+            displayType?: string;
+        }[];
+    };
+    error?: {
+        errorType: string;
+        message: string;
+        url?: string;
+        statusCode?: number;
+    };
+}
 
 interface OpenSeaClientConfig {
     apiKey: string;
@@ -319,6 +260,8 @@ interface OpenSeaClientConfig {
     chain?: string;
     timeout?: number;
     verbose?: boolean;
+    maxRetries?: number;
+    retryBaseDelay?: number;
 }
 interface CommandOptions {
     apiKey?: string;
@@ -326,6 +269,13 @@ interface CommandOptions {
     format?: "json" | "table";
     raw?: boolean;
 }
+interface HealthResult {
+    status: "ok" | "error";
+    key_prefix: string;
+    authenticated: boolean;
+    rate_limited: boolean;
+    message: string;
+}
 
 declare class OpenSeaClient {
     private apiKey;
@@ -333,10 +283,15 @@ declare class OpenSeaClient {
     private defaultChain;
     private timeoutMs;
     private verbose;
+    private maxRetries;
+    private retryBaseDelay;
     constructor(config: OpenSeaClientConfig);
+    private get defaultHeaders();
     get<T>(path: string, params?: Record<string, unknown>): Promise<T>;
     post<T>(path: string, body?: Record<string, unknown>, params?: Record<string, unknown>): Promise<T>;
     getDefaultChain(): string;
+    getApiKeyPrefix(): string;
+    private fetchWithRetry;
 }
 declare class OpenSeaAPIError extends Error {
     statusCode: number;
@@ -345,12 +300,301 @@ declare class OpenSeaAPIError extends Error {
     constructor(statusCode: number, responseBody: string, path: string);
 }
 
+declare function checkHealth(client: OpenSeaClient): Promise<HealthResult>;
+
 type OutputFormat = "json" | "table" | "toon";
 declare function formatOutput(data: unknown, format: OutputFormat): string;
 
+/**
+ * Wallet adapter interface for signing and sending transactions.
+ *
+ * Abstracts away the signing backend so the CLI and SDK can work with
+ * any provider (Privy, Turnkey, Fireblocks, etc.) through a single API.
+ */
+interface TransactionRequest {
+    to: string;
+    data: string;
+    value: string;
+    chainId: number;
+}
+interface TransactionResult {
+    hash: string;
+}
+interface WalletAdapter {
+    /** Human-readable provider name for logging */
+    readonly name: string;
+    /** Get the wallet address */
+    getAddress(): Promise<string>;
+    /** Sign and send a transaction, returns the tx hash */
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResult>;
+    /** Optional hook called before each adapter request (for metrics/logging) */
+    onRequest?: (method: string, params: unknown) => void;
+    /** Optional hook called after each adapter response (for metrics/logging) */
+    onResponse?: (method: string, result: unknown, durationMs: number) => void;
+}
+
+/**
+ * AUTO-GENERATED by scripts/sync-chains.ts — DO NOT EDIT.
+ * Source of truth: OpenSea REST API + scripts/chain-data.json
+ * Run `pnpm sync-chains` to regenerate.
+ */
+declare const CHAIN_IDS: Record<string, number>;
+/**
+ * Resolve a chain identifier to a numeric EVM chain ID.
+ * Accepts a known chain name (e.g. "base") or a numeric string / number.
+ */
+declare function resolveChainId(chain: string | number): number;
+
+/**
+ * Fireblocks wallet adapter.
+ *
+ * Uses Fireblocks' REST API to sign and send transactions through their
+ * enterprise-grade custody infrastructure. Fireblocks provides MPC-based
+ * key management, transaction policy engine, and multi-level approval
+ * workflows suitable for institutional use.
+ *
+ * Required environment variables:
+ *   FIREBLOCKS_API_KEY       — Fireblocks API key
+ *   FIREBLOCKS_API_SECRET    — Fireblocks API secret (RSA private key, PEM-encoded)
+ *   FIREBLOCKS_VAULT_ID      — Fireblocks vault account ID
+ *
+ * Optional:
+ *   FIREBLOCKS_API_BASE_URL  — Override the Fireblocks API base URL
+ *                              (default: https://api.fireblocks.io)
+ *   FIREBLOCKS_ASSET_ID      — Override the Fireblocks asset ID
+ *                              (default: ETH — for EVM chains Fireblocks uses
+ *                              asset IDs like ETH, ETH_TEST5, MATIC, etc.)
+ *
+ * @see https://developers.fireblocks.com/docs/introduction
+ * @see https://developers.fireblocks.com/reference/api-overview
+ */
+
+interface FireblocksConfig {
+    apiKey: string;
+    apiSecret: string;
+    vaultId: string;
+    assetId?: string;
+    baseUrl?: string;
+}
+declare class FireblocksAdapter implements WalletAdapter {
+    readonly name = "fireblocks";
+    onRequest?: (method: string, params: unknown) => void;
+    onResponse?: (method: string, result: unknown, durationMs: number) => void;
+    private config;
+    private cachedAddress?;
+    constructor(config: FireblocksConfig);
+    /**
+     * Create a FireblocksAdapter from environment variables.
+     * Throws if any required variable is missing.
+     */
+    static fromEnv(): FireblocksAdapter;
+    private get baseUrl();
+    /**
+     * Create a JWT for Fireblocks API authentication.
+     *
+     * Fireblocks uses JWT tokens signed with the API secret (RSA private key).
+     * The JWT contains the API key as `sub`, a URI claim for the endpoint path,
+     * and a body hash for POST requests.
+     *
+     * @see https://developers.fireblocks.com/reference/signing-a-request-jwt-structure
+     */
+    private createJwt;
+    private pemToBuffer;
+    private hashBody;
+    private resolveAssetId;
+    getAddress(): Promise<string>;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResult>;
+    /**
+     * Poll a Fireblocks transaction until it reaches a terminal status.
+     * Fireblocks MPC signing + broadcast is asynchronous, so the initial
+     * POST returns a transaction ID that must be polled for the final hash.
+     */
+    private waitForTransaction;
+}
+
+/**
+ * Raw private key wallet adapter.
+ *
+ * WARNING: Using a raw private key is NOT recommended for production use.
+ * It provides no spending limits, no destination allowlists, and no
+ * human-in-the-loop approval. Prefer Privy, Turnkey, or Fireblocks
+ * for managed wallet security.
+ *
+ * This adapter sends transactions via eth_sendTransaction on the RPC node,
+ * which requires the node to manage the key (e.g. Hardhat, Anvil, Ganache).
+ * The PRIVATE_KEY env var is validated (format + address derivation) to
+ * confirm intent, but is NOT used for signing — the RPC node holds the key
+ * and signs server-side. This means this adapter only works with local dev
+ * nodes, not production RPC providers like Infura or Alchemy.
+ *
+ * Required environment variables:
+ *   PRIVATE_KEY      — Hex-encoded private key (validated for format;
+ *                      the RPC node must already have this key imported)
+ *   RPC_URL          — JSON-RPC endpoint URL (must be a local dev node)
+ *   WALLET_ADDRESS   — The wallet address corresponding to the private key
+ */
+
+interface PrivateKeyConfig {
+    /**
+     * The private key hex string. Validated at construction time to confirm
+     * the user intends to use raw key mode, but NOT used for signing.
+     * The RPC node (Hardhat/Anvil/Ganache) handles signing via eth_sendTransaction.
+     */
+    privateKey: string;
+    rpcUrl: string;
+    walletAddress: string;
+}
+declare class PrivateKeyAdapter implements WalletAdapter {
+    readonly name = "private-key";
+    onRequest?: (method: string, params: unknown) => void;
+    onResponse?: (method: string, result: unknown, durationMs: number) => void;
+    private config;
+    private hasWarned;
+    constructor(config: PrivateKeyConfig);
+    /**
+     * Create a PrivateKeyAdapter from environment variables.
+     * Validates the private key format and warns if the RPC URL looks
+     * like a hosted provider (which won't support eth_sendTransaction).
+     */
+    static fromEnv(): PrivateKeyAdapter;
+    getAddress(): Promise<string>;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResult>;
+}
+
+/**
+ * Privy wallet adapter.
+ *
+ * Uses Privy's server-side wallet API to sign and send transactions.
+ * Transactions are governed by Privy's programmable policy engine —
+ * policies (transaction limits, destination allowlists, chain restrictions)
+ * are evaluated in a trusted execution environment before any signing occurs.
+ *
+ * Required environment variables:
+ *   PRIVY_APP_ID      — Privy application ID
+ *   PRIVY_APP_SECRET  — Privy application secret
+ *   PRIVY_WALLET_ID   — Wallet ID to use for signing
+ *
+ * @see https://docs.privy.io/wallets/wallets/server-side-access
+ * @see https://docs.privy.io/controls/policies/overview
+ */
+
+interface PrivyConfig {
+    appId: string;
+    appSecret: string;
+    walletId: string;
+    baseUrl?: string;
+}
+declare class PrivyAdapter implements WalletAdapter {
+    readonly name = "privy";
+    onRequest?: (method: string, params: unknown) => void;
+    onResponse?: (method: string, result: unknown, durationMs: number) => void;
+    private config;
+    private cachedAddress?;
+    constructor(config: PrivyConfig);
+    /**
+     * Create a PrivyAdapter from environment variables.
+     * Throws if any required variable is missing.
+     */
+    static fromEnv(): PrivyAdapter;
+    private get baseUrl();
+    private get authHeaders();
+    getAddress(): Promise<string>;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResult>;
+}
+
+/**
+ * Turnkey wallet adapter.
+ *
+ * Uses Turnkey's API to sign and send transactions via their HSM-backed
+ * signing infrastructure. Turnkey provides non-custodial key management
+ * with policy controls, audit logging, and multi-party approval workflows.
+ *
+ * Authentication uses Turnkey's stamp scheme: each request body is hashed
+ * and signed with a P-256 ECDSA key, then the signature + public key are
+ * sent in the X-Stamp header.
+ *
+ * Required environment variables:
+ *   TURNKEY_API_PUBLIC_KEY  — Turnkey API public key (hex-encoded, compressed or uncompressed)
+ *   TURNKEY_API_PRIVATE_KEY — Turnkey API private key (hex-encoded P-256 private key)
+ *   TURNKEY_ORGANIZATION_ID — Turnkey organization ID
+ *   TURNKEY_WALLET_ADDRESS  — Ethereum address managed by Turnkey
+ *
+ * Required:
+ *   TURNKEY_RPC_URL          — RPC endpoint for gas estimation and broadcast (must match target chain)
+ *
+ * Optional:
+ *   TURNKEY_API_BASE_URL — Override the Turnkey API base URL (default: https://api.turnkey.com)
+ *   TURNKEY_PRIVATE_KEY_ID — Turnkey private key ID (for signing with a specific key)
+ *
+ * @see https://docs.turnkey.com/
+ * @see https://docs.turnkey.com/developer-tools/api-overview/stamps
+ */
+
+interface TurnkeyConfig {
+    apiPublicKey: string;
+    apiPrivateKey: string;
+    organizationId: string;
+    walletAddress: string;
+    rpcUrl: string;
+    privateKeyId?: string;
+    baseUrl?: string;
+}
+declare class TurnkeyAdapter implements WalletAdapter {
+    readonly name = "turnkey";
+    onRequest?: (method: string, params: unknown) => void;
+    onResponse?: (method: string, result: unknown, durationMs: number) => void;
+    private config;
+    constructor(config: TurnkeyConfig);
+    /**
+     * Create a TurnkeyAdapter from environment variables.
+     * Throws if any required variable is missing.
+     */
+    static fromEnv(): TurnkeyAdapter;
+    private get baseUrl();
+    /**
+     * Sign a Turnkey API request using the API key pair (P-256 ECDSA).
+     *
+     * Turnkey uses a stamp-based authentication scheme: the request body
+     * is hashed with SHA-256 and signed with the P-256 private key. The
+     * stamp JSON (publicKey + scheme + signature) is then base64url-encoded
+     * and sent in the X-Stamp header.
+     *
+     * @see https://docs.turnkey.com/developer-tools/api-overview/stamps
+     */
+    private stamp;
+    private signedRequest;
+    getAddress(): Promise<string>;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResult>;
+    /**
+     * Populate gas parameters via JSON-RPC calls to the target chain.
+     * Mirrors what ethers.js provider.populateTransaction() does internally.
+     *
+     * Makes three parallel RPC calls:
+     *   - eth_getTransactionCount (nonce)
+     *   - eth_estimateGas (gasLimit)
+     *   - eth_maxPriorityFeePerGas + eth_getBlockByNumber (fee data)
+     */
+    private estimateGasParams;
+    /** Make a single JSON-RPC call */
+    private rpcCall;
+}
+
+type WalletProvider = "privy" | "turnkey" | "fireblocks" | "private-key";
+declare const WALLET_PROVIDERS: WalletProvider[];
+/**
+ * Create a WalletAdapter from the current environment.
+ *
+ * When no provider is specified, auto-detects based on which
+ * environment variables are set. Priority: Turnkey > Fireblocks > PrivateKey > Privy.
+ * If no provider-specific vars are found, defaults to Privy.
+ */
+declare function createWalletFromEnv(provider?: WalletProvider): WalletAdapter;
+
 declare class OpenSeaCLI {
     private client;
+    readonly chains: ChainsAPI;
     readonly collections: CollectionsAPI;
+    readonly drops: DropsAPI;
     readonly nfts: NFTsAPI;
     readonly listings: ListingsAPI;
     readonly offers: OffersAPI;
@@ -359,12 +603,18 @@ declare class OpenSeaCLI {
     readonly tokens: TokensAPI;
     readonly search: SearchAPI;
     readonly swaps: SwapsAPI;
+    readonly health: HealthAPI;
     constructor(config: OpenSeaClientConfig);
 }
+declare class ChainsAPI {
+    private client;
+    constructor(client: OpenSeaClient);
+    list(): Promise<ChainListResponse>;
+}
 declare class CollectionsAPI {
     private client;
     constructor(client: OpenSeaClient);
-    get(slug: string): Promise<Collection>;
+    get(slug: string): Promise<CollectionDetailedResponse>;
     list(options?: {
         chain?: Chain;
         limit?: number;
@@ -373,41 +623,73 @@ declare class CollectionsAPI {
         creatorUsername?: string;
         includeHidden?: boolean;
     }): Promise<{
-        collections: Collection[];
+        collections: CollectionDetailedResponse[];
         next?: string;
     }>;
-    stats(slug: string): Promise<CollectionStats>;
+    stats(slug: string): Promise<CollectionStatsResponse>;
     traits(slug: string): Promise<GetTraitsResponse>;
+    trending(options?: {
+        timeframe?: string;
+        chains?: string[];
+        category?: string;
+        limit?: number;
+        next?: string;
+    }): Promise<CollectionPaginatedResponse>;
+    top(options?: {
+        sortBy?: string;
+        chains?: string[];
+        category?: string;
+        limit?: number;
+        next?: string;
+    }): Promise<CollectionPaginatedResponse>;
+}
+declare class DropsAPI {
+    private client;
+    constructor(client: OpenSeaClient);
+    list(options?: {
+        type?: string;
+        chains?: string[];
+        limit?: number;
+        next?: string;
+    }): Promise<DropPaginatedResponse>;
+    get(slug: string): Promise<DropDetailedResponse>;
+    mint(slug: string, options: {
+        minter: string;
+        quantity?: number;
+    }): Promise<DropMintResponse>;
 }
 declare class NFTsAPI {
     private client;
     constructor(client: OpenSeaClient);
     get(chain: Chain, address: string, identifier: string): Promise<{
-        nft: NFT;
+        nft: NftDetailed;
     }>;
     listByCollection(slug: string, options?: {
         limit?: number;
         next?: string;
     }): Promise<{
-        nfts: NFT[];
+        nfts: NftDetailed[];
         next?: string;
     }>;
     listByContract(chain: Chain, address: string, options?: {
         limit?: number;
         next?: string;
     }): Promise<{
-        nfts: NFT[];
+        nfts: NftDetailed[];
         next?: string;
     }>;
     listByAccount(chain: Chain, address: string, options?: {
         limit?: number;
         next?: string;
     }): Promise<{
-        nfts: NFT[];
+        nfts: NftDetailed[];
         next?: string;
     }>;
     refresh(chain: Chain, address: string, identifier: string): Promise<void>;
     getContract(chain: Chain, address: string): Promise<Contract>;
+    validateMetadata(chain: Chain, address: string, identifier: string, options?: {
+        ignoreCachedItemUrls?: boolean;
+    }): Promise<ValidateMetadataResponse>;
 }
 declare class ListingsAPI {
     private client;
@@ -499,7 +781,16 @@ declare class EventsAPI {
 declare class AccountsAPI {
     private client;
     constructor(client: OpenSeaClient);
-    get(address: string): Promise<Account>;
+    get(address: string): Promise<AccountResponse>;
+    tokens(address: string, options?: {
+        chains?: string[];
+        limit?: number;
+        sortBy?: TokenBalanceSortBy;
+        sortDirection?: "asc" | "desc";
+        disableSpamFiltering?: boolean;
+        next?: string;
+    }): Promise<TokenBalancePaginatedResponse>;
+    resolve(identifier: string): Promise<AccountResolveResponse>;
 }
 declare class TokensAPI {
     private client;
@@ -544,8 +835,42 @@ declare class SwapsAPI {
         slippage?: number;
         recipient?: string;
     }): Promise<SwapQuoteResponse>;
+    /**
+     * Get a swap quote and execute all transactions using the provided wallet adapter.
+     * Returns an array of transaction results (one per transaction in the quote).
+     *
+     * @param options - Swap parameters (chains, addresses, quantity, etc.)
+     * @param wallet - Wallet adapter to sign and send transactions
+     * @param callbacks - Optional callbacks for progress reporting and skipped txs
+     */
+    execute(options: {
+        fromChain: string;
+        fromAddress: string;
+        toChain: string;
+        toAddress: string;
+        quantity: string;
+        slippage?: number;
+        recipient?: string;
+        address?: string;
+    }, wallet: WalletAdapter, callbacks?: {
+        onQuote?: (quote: SwapQuoteResponse) => void;
+        onSending?: (tx: {
+            to: string;
+            chain: string;
+            chainId: number;
+        }) => void;
+        onSkipped?: (tx: {
+            chain: string;
+            reason: string;
+        }) => void;
+    }): Promise<TransactionResult[]>;
+}
+declare class HealthAPI {
+    private client;
+    constructor(client: OpenSeaClient);
+    check(): Promise<HealthResult>;
 }
 
 declare function formatToon(data: unknown): string;
 
-export { type Account, type AssetEvent, type Chain, type Collection, type CollectionOrderBy, type CollectionStats, type CommandOptions, type Contract, type EventAsset, type EventPayment, type EventType, type Fee, type GetTraitsResponse, type Listing, type NFT, type Offer, OpenSeaAPIError, OpenSeaCLI, OpenSeaClient, type OpenSeaClientConfig, type Order, type OrderSide, type OutputFormat, type PaymentToken, type Price, type SafelistStatus, type SearchAssetType, type SearchResponse, type SearchResult, type SearchResultAccount, type SearchResultCollection, type SearchResultNFT, type SearchResultToken, type SwapQuote, type SwapQuoteResponse, type SwapTransaction, type Token, type TokenDetails, type TokenSocials, type TokenStats, type Trait, type TraitCategories, type TraitCounts, formatOutput, formatToon };
+export { type AccountResponse as Account, type AccountResolveResponse, type AccountResponse, type AssetEvent, type AssetEventsResponse, CHAIN_IDS, type Chain, type ChainInfo, type ChainListResponse, type CollectionDetailedResponse as Collection, type CollectionDetailedResponse, type CollectionOrderBy, type CollectionPaginatedResponse, type CollectionRarity, type CollectionResponse, type CollectionStatsResponse as CollectionStats, type CollectionStatsResponse, type CommandOptions, type Contract, type ContractResponse, type DropDetailedResponse, type DropMintRequest, type DropMintResponse, type DropPaginatedResponse, type DropResponse, type DropStageResponse, type Event, type EventAsset, type Payment as EventPayment, type EventType, type Fee, FireblocksAdapter, type FulfillListingResponse, type GetOrderResponse, type GetTraitsResponse, type HealthResult, type IntervalStat, type Listing, type ListingPrice, type ListingsResponse, type NftDetailed as NFT, type Nft, type NftDetailed, type NftListResponse, type NftResponse, type Offer, type OffersResponse, OpenSeaAPIError, OpenSeaCLI, OpenSeaClient, type OpenSeaClientConfig, type Order, type OrderEvent, type OrderSide, type OrdersResponse, type OutputFormat, type Owner, type Payment, type PaymentToken, type Price, type PricingCurrencies, PrivateKeyAdapter, PrivyAdapter, type ProtocolData, type Rarity, type SafelistStatus, type SaleEvent, type SearchAssetType, type SearchResponse, type SearchResult, type SearchResultAccount, type SearchResultCollection, type SearchResultNFT, type SearchResultToken, type SimpleAccount, type SocialMediaAccount, type SwapQuote, type SwapQuoteResponse, type SwapTransaction, SwapsAPI, type Token, type TokenBalance, type TokenBalancePaginatedResponse, type TokenBalanceSortBy, type TokenDetails, type TokenSocials, type TokenStats, type Total, type Trait, type TraitCategories, type TraitCounts, type TransactionRequest, type TransactionResult, type TransferEvent, TurnkeyAdapter, type ValidateMetadataResponse, WALLET_PROVIDERS, type WalletAdapter, type WalletProvider, checkHealth, createWalletFromEnv, formatOutput, formatToon, resolveChainId };