@rareprotocol/rare-cli 0.4.1 → 1.0.0

package/dist/client.d.ts

@@ -1,43 +1,1606 @@
-import { Chain, Address, Hash, TransactionReceipt, PublicClient, WalletClient } from 'viem';
+import { Address, Hex as Hex$1, Hash, PublicClient, WalletClient } from 'viem';
+import { S as SupportedChain, C as CurrencyInput, a as CurrencyInfo, R as ResolvedCurrency } from './addresses-BE3luaB3.js';
+export { b as CurrencyName, c as CustomCurrencyInfo } from './addresses-BE3luaB3.js';
+import { I as IntegerInput, B as BatchTokenListArtifact, A as AmountInput, T as TimestampInput, a as TransactionResult, b as BatchTokenProofArtifact, c as BatchListingNamespace, d as BuildUtilsTreeParams, U as UtilsTreeArtifact, e as UtilsTreeProofParams, f as UtilsTreeProofArtifact, g as UtilsTreeProofVerifyParams, h as UtilsMerkleProofParams, i as UtilsMerkleProofArtifact, R as ResolvedCurrencyWithDecimals } from './batch-listing-Cu5Hoqxs.js';
+export { j as BatchListingBuyParams, k as BatchListingBuyResult, l as BatchListingCancelParams, m as BatchListingCancelResult, n as BatchListingCreateParams, o as BatchListingCreateResult, p as BatchListingProofArtifact, q as BatchListingRootArtifact, r as BatchListingSetAllowListParams, s as BatchListingSetAllowListResult, t as BatchListingStatus, u as BatchListingStatusParams, v as BatchListingTokenEntry, w as UtilsMerkleRootArtifact, x as UtilsMerkleTokenEntry, W as WalletAccount } from './batch-listing-Cu5Hoqxs.js';
 
-declare const supportedChains: readonly ["mainnet", "sepolia", "base", "base-sepolia"];
-type SupportedChain = (typeof supportedChains)[number];
-declare const viemChains: Record<SupportedChain, Chain>;
-declare const chainIds: Record<SupportedChain, number>;
-type ContractSet = {
-    factory: `0x${string}`;
-    auction: `0x${string}`;
-};
-declare const contractAddresses: Partial<Record<SupportedChain, ContractSet>>;
-declare function getContractAddresses(chain: SupportedChain): ContractSet;
-declare function isSupportedChain(value: string): value is SupportedChain;
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
 
-type SearchPageResponse = {
-    items: Record<string, unknown>[];
-    total: number;
-    hasNextPage: boolean;
-    nextCursor: number;
-};
-type NftSearchParams = {
-    query?: string;
-    take?: number;
-    cursor?: number;
-    sortBy?: string;
-    ownerAddresses?: string[];
-    creatorAddresses?: string[];
-    collectionIds?: string[];
-    contractAddresses?: string[];
-    auctionStates?: string[];
-    chainIds?: number[];
-};
-type CollectionSearchParams = {
-    query?: string;
-    take?: number;
-    cursor?: number;
-    sortBy?: string;
-    ownerAddresses?: string[];
+interface paths {
+    "/v1/nfts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List NFTs
+         * @description Search, filter, and list NFTs with rich query parameters
+         */
+        get: {
+            parameters: {
+                query?: {
+                    page?: number;
+                    perPage?: number;
+                    /** @description Full-text search */
+                    q?: string;
+                    /** @description Checksummed Ethereum address */
+                    creatorAddress?: components["schemas"]["EthereumAddress"];
+                    /** @description Checksummed Ethereum address */
+                    ownerAddress?: components["schemas"]["EthereumAddress"];
+                    /** @description Checksummed Ethereum address */
+                    contractAddress?: components["schemas"]["EthereumAddress"] & unknown;
+                    collectionId?: string;
+                    /** @description Supported blockchain network id */
+                    chainId?: components["schemas"]["ChainId"];
+                    listingType?: "SALE_PRICE" | "BATCH_SALE_PRICE";
+                    hasAuction?: boolean | null;
+                    auctionState?: "PENDING" | "RUNNING" | "UNSETTLED";
+                    auctionType?: "RESERVE_AUCTION" | "BATCH_RESERVE_AUCTION" | "SCHEDULED_AUCTION";
+                    /** @description Checksummed Ethereum address */
+                    auctionCreatorAddress?: components["schemas"]["EthereumAddress"];
+                    /** @description Checksummed Ethereum address */
+                    auctionBidderAddress?: components["schemas"]["EthereumAddress"];
+                    hasListing?: boolean | null;
+                    hasOffer?: boolean | null;
+                    /** @description Checksummed Ethereum address */
+                    offerBuyerAddress?: components["schemas"]["EthereumAddress"];
+                    isPrimarySale?: boolean | null;
+                    isSecondarySale?: boolean | null;
+                    priceMin?: number | null;
+                    priceMax?: number | null;
+                    /** @description Checksummed Ethereum address */
+                    currency?: components["schemas"]["EthereumAddress"] & unknown;
+                    mediaType?: "AUDIO" | "HTML" | "IMAGE" | "THREE_D" | "VIDEO";
+                    tags?: string[] | string;
+                    sortBy?: "newest" | "oldest" | "priceAsc" | "priceDesc" | "recentlySold" | "auctionEndingSoon" | "recentActivity" | "bidAsc" | "bidDesc";
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description List of NFTs */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: components["schemas"]["Nft"][];
+                            pagination: components["schemas"]["Pagination"];
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/nfts/{universalTokenId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get NFT
+         * @description Get a single NFT by its universal token ID
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Canonical NFT identifier in chainId-contractAddress-tokenId format. */
+                    universalTokenId: components["schemas"]["UniversalTokenId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description NFT detail */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: components["schemas"]["Nft"];
+                        };
+                    };
+                };
+                /** @description NFT not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/nfts/{universalTokenId}/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List NFT events
+         * @description Get events for a specific NFT
+         */
+        get: {
+            parameters: {
+                query?: {
+                    page?: number;
+                    perPage?: number;
+                    eventType?: ("CANCEL_AUCTION" | "CANCEL_OFFER" | "CLOSE_AUCTION" | "CREATE_NFT" | "CREATE_NFT_SUPPLY" | "CREATE_RESERVE_AUCTION" | "CREATE_SCHEDULED_AUCTION" | "END_AUCTION" | "MAKE_AUCTION_BID" | "MAKE_LISTING" | "MAKE_OFFER" | "SETTLE_AUCTION" | "START_AUCTION" | "TAKE_LISTING" | "TAKE_OFFER" | "TRANSFER_NFT" | "TRANSFER_NFT_SUPPLY")[];
+                    sortBy?: "newest" | "oldest";
+                };
+                header?: never;
+                path: {
+                    /** @description Canonical NFT identifier in chainId-contractAddress-tokenId format. */
+                    universalTokenId: components["schemas"]["UniversalTokenId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description List of NFT events */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: components["schemas"]["NftEvent"][];
+                            pagination: components["schemas"]["Pagination"];
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/nfts/metadata": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Pin NFT Metadata
+         * @description Assemble NFT metadata JSON from media assets and pin to IPFS via Filebase
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["CreateNftMetadataRequest"];
+                };
+            };
+            responses: {
+                /** @description Metadata pinned to IPFS */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CreateNftMetadataResponse"];
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/nfts/metadata/media/uploads": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create Media Upload
+         * @description Initiate a multipart upload to Filebase/IPFS, returning presigned URLs for each part
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["CreateMediaUploadRequest"];
+                };
+            };
+            responses: {
+                /** @description Multipart upload initiated */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CreateMediaUploadResponse"];
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/nfts/metadata/media/uploads/complete": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Complete Media Upload
+         * @description Complete a multipart upload, resolve IPFS CID, and return IPFS/gateway URLs
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["CompleteMediaUploadRequest"];
+                };
+            };
+            responses: {
+                /** @description Upload completed */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["IpfsUploadResponse"];
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/nfts/metadata/media/generate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate Media Metadata
+         * @description Call pipelines to extract media metadata (dimensions, size, type) from a URI
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["GenerateMediaRequest"];
+                };
+            };
+            responses: {
+                /** @description Media metadata generated */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GenerateMediaResponse"];
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/collections": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List collections
+         * @description Search, filter, and list collections
+         */
+        get: {
+            parameters: {
+                query?: {
+                    page?: number;
+                    perPage?: number;
+                    /** @description Full-text search */
+                    q?: string;
+                    /** @description Checksummed Ethereum address */
+                    ownerAddress?: components["schemas"]["EthereumAddress"];
+                    /** @description Supported blockchain network id */
+                    chainId?: components["schemas"]["ChainId"];
+                    sortBy?: "newest" | "oldest";
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description List of collections */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: components["schemas"]["Collection"][];
+                            pagination: components["schemas"]["Pagination"];
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/collections/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get collection
+         * @description Get a single collection by ID
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Collection detail */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: components["schemas"]["Collection"];
+                        };
+                    };
+                };
+                /** @description Collection not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/collections/{id}/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List collection events
+         * @description Get events across all NFTs in a collection
+         */
+        get: {
+            parameters: {
+                query?: {
+                    page?: number;
+                    perPage?: number;
+                    eventType?: ("CANCEL_AUCTION" | "CANCEL_OFFER" | "CLOSE_AUCTION" | "CREATE_NFT" | "CREATE_NFT_SUPPLY" | "CREATE_RESERVE_AUCTION" | "CREATE_SCHEDULED_AUCTION" | "END_AUCTION" | "MAKE_AUCTION_BID" | "MAKE_LISTING" | "MAKE_OFFER" | "SETTLE_AUCTION" | "START_AUCTION" | "TAKE_LISTING" | "TAKE_OFFER" | "TRANSFER_NFT" | "TRANSFER_NFT_SUPPLY")[];
+                    sortBy?: "newest" | "oldest";
+                };
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description List of collection events */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: components["schemas"]["NftEvent"][];
+                            pagination: components["schemas"]["Pagination"];
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/collections/import": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Import ERC-721 Collection
+         * @description Validate an ERC-721 contract on-chain and register it for indexing via pipelines
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["ImportCollectionRequest"];
+                };
+            };
+            responses: {
+                /** @description Collection imported or already exists */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ImportCollectionResponse"];
+                    };
+                };
+                /** @description Validation failed */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+                /** @description Collection already indexed */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                            collectionId: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/users/{address}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get user
+         * @description Get a user profile by Ethereum address
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Checksummed Ethereum address */
+                    address: components["schemas"]["EthereumAddress"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description User profile */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: components["schemas"]["UserProfile"];
+                        };
+                    };
+                };
+                /** @description User not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/tokens/price/{symbol}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Token Price
+         * @description Fetch the current USD price for a token by symbol (e.g., rare, eth, usdc)
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Token symbol (case-insensitive) */
+                    symbol: components["schemas"]["TokenSymbol"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Token price */
+                200: {
+                    headers: {
+                        "Cache-Control": string;
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TokenPriceResponse"];
+                    };
+                };
+                /** @description Token not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/merkle-roots/nfts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate NFT Merkle Root
+         * @description Generate and store an NFT merkle root via the pipelines service
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["GenerateNftMerkleRootRequest"];
+                };
+            };
+            responses: {
+                /** @description NFT merkle root generated */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GenerateNftMerkleRootResponse"];
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+                /** @description Pipelines request failed */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/merkle-roots/addresses": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate Address Merkle Root
+         * @description Generate and store an address merkle root via the pipelines service
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["GenerateAddressMerkleRootJsonRequest"];
+                    "multipart/form-data": components["schemas"]["GenerateAddressMerkleRootFormRequest"];
+                };
+            };
+            responses: {
+                /** @description Address merkle root generated */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GenerateAddressMerkleRootResponse"];
+                    };
+                };
+                /** @description Invalid request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+                /** @description Pipelines request failed */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/merkle-roots/nfts/proof": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate NFT Merkle Proof
+         * @description Resolve an NFT Merkle root and generate a token proof from the stored Merkle list
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["GenerateNftMerkleProofRequest"];
+                };
+            };
+            responses: {
+                /** @description NFT Merkle proof generated */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GenerateNftMerkleProofResponse"];
+                    };
+                };
+                /** @description Merkle root or NFT entry not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+                /** @description Multiple matching roots were found */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/merkle-roots/addresses/proof": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate Address Merkle Proof
+         * @description Generate an address proof from a stored Merkle root list
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["GenerateAddressMerkleProofRequest"];
+                };
+            };
+            responses: {
+                /** @description Address Merkle proof generated */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GenerateAddressMerkleProofResponse"];
+                    };
+                };
+                /** @description Merkle root or address entry not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+                /** @description Multiple matching roots were found */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            error: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+interface components {
+    schemas: {
+        Nft: {
+            /** @example 1-0xb932a70a57673d89f4acffbe830e8ed7f75fb9e0-12345 */
+            universalTokenId: string;
+            /** @example 0xb932a70a57673d89f4acffbe830e8ed7f75fb9e0 */
+            contractAddress: string;
+            /** @example 1 */
+            chainId: string;
+            /** @example 12345 */
+            tokenId: string;
+            /**
+             * @example ERC721
+             * @enum {string}
+             */
+            type: "ERC721" | "ERC1155";
+            creator: components["schemas"]["User"];
+            owner: components["schemas"]["User"];
+            owners?: {
+                /** @example 0xba5BDe662c17e2aDFF1075610382B9B691296350 */
+                address: string;
+                /** @example 1 */
+                balance: string;
+            }[];
+            metadata: {
+                /** @example Genesis */
+                name: string | null;
+                /** @example A unique digital artwork */
+                description: string | null;
+                /**
+                 * @example [
+                 *       "art",
+                 *       "digital"
+                 *     ]
+                 */
+                tags: string[];
+                /** @example image/png */
+                mediaType: string | null;
+                /** @example https://example.com/image.png */
+                imageUri: string | null;
+                /** @example null */
+                videoUri: string | null;
+            };
+            market: {
+                listings: components["schemas"]["Listing"][];
+                offers: components["schemas"]["Offer"][];
+                auctions: components["schemas"]["Auction"][];
+            };
+            lastSale: components["schemas"]["LastSale"];
+            attributes: {
+                /** @example Background */
+                property: string;
+                /** @example Blue */
+                value: string;
+            }[];
+            /** @example 1704067200 */
+            createdAt: number;
+        };
+        User: {
+            /** @example 0xba5BDe662c17e2aDFF1075610382B9B691296350 */
+            address: string;
+            /** @example satoshi */
+            username: string | null;
+            /** @example https://example.com/avatar.png */
+            avatar: string | null;
+            /** @example Satoshi Nakamoto */
+            fullName: string | null;
+        };
+        Listing: {
+            /** @example 0x1234567890abcdef1234567890abcdef12345678 */
+            contractAddress: string;
+            /**
+             * @example SALE_PRICE
+             * @enum {string}
+             */
+            type: "SALE_PRICE" | "BATCH_SALE_PRICE";
+            price: components["schemas"]["CryptoValue"];
+            /** @example 0xba5BDe662c17e2aDFF1075610382B9B691296350 */
+            seller: string;
+            /** @example 0xcf6398559ea0e93d7d7233ca93b09912da8ff57b45ebe7a3ede9c74d17a76f13 */
+            merkleRoot?: string;
+            allowlist?: {
+                root: string;
+            } | null;
+        };
+        CryptoValue: {
+            /** @example 1000000000000000000 */
+            cryptoAmount: string;
+            currency: components["schemas"]["Currency"];
+            /** @example 3500 */
+            usdAmount: number | null;
+        };
+        Currency: {
+            /** @example 0x0000000000000000000000000000000000000000 */
+            address: string;
+            /** @example ETH */
+            symbol: string;
+            /** @example 18 */
+            decimals: number;
+            /** @example 1 */
+            chainId: number;
+        };
+        Offer: {
+            /** @example 0x1234567890abcdef1234567890abcdef12345678 */
+            contractAddress: string;
+            /**
+             * @example OFFER
+             * @enum {string}
+             */
+            type: "OFFER" | "BATCH_OFFER";
+            price: components["schemas"]["CryptoValue"];
+            buyer: components["schemas"]["User"] & unknown;
+            /** @example 0xba5BDe662c17e2aDFF1075610382B9B691296350 */
+            buyerAddress: string;
+        };
+        Auction: {
+            /** @example 0x1234567890abcdef1234567890abcdef12345678 */
+            contractAddress: string;
+            /**
+             * @example RESERVE_AUCTION
+             * @enum {string}
+             */
+            type: "RESERVE_AUCTION" | "BATCH_RESERVE_AUCTION" | "SCHEDULED_AUCTION";
+            /**
+             * @example RUNNING
+             * @enum {string}
+             */
+            state: "PENDING" | "RUNNING" | "UNSETTLED";
+            /** @example 2024-01-01T00:00:00.000Z */
+            startTime: string | null;
+            /** @example 2024-01-02T00:00:00.000Z */
+            endTime: string | null;
+            /** @example 0x0000000000000000000000000000000000000000 */
+            currencyAddress: string;
+            /** @example 0xba5BDe662c17e2aDFF1075610382B9B691296350 */
+            sellerAddress: string;
+            currentBid: components["schemas"]["CryptoValue"] & unknown;
+            reservePrice: components["schemas"]["CryptoValue"] & unknown;
+            highestBidder: components["schemas"]["User"] & unknown;
+            /** @example 0xcf6398559ea0e93d7d7233ca93b09912da8ff57b45ebe7a3ede9c74d17a76f13 */
+            merkleRoot?: string;
+        };
+        LastSale: {
+            /** @example evt_123 */
+            eventId: string;
+            price: components["schemas"]["CryptoValue"];
+        } | null;
+        Pagination: {
+            /** @example 1 */
+            page: number;
+            /** @example 20 */
+            perPage: number;
+            /** @example 100 */
+            totalCount: number;
+            /** @example 5 */
+            totalPages: number;
+        };
+        /**
+         * @description Checksummed Ethereum address
+         * @example 0xba5BDe662c17e2aDFF1075610382B9B691296350
+         */
+        EthereumAddress: string;
+        /**
+         * @description Supported blockchain network id
+         * @example 1
+         */
+        ChainId: number;
+        /**
+         * @description Canonical NFT identifier in chainId-contractAddress-tokenId format.
+         * @example 1-0xb932a70a57673d89f4acffbe830e8ed7f75fb9e0-12345
+         */
+        UniversalTokenId: string;
+        NftEvent: components["schemas"]["SaleEvent"] | components["schemas"]["TransferEvent"] | components["schemas"]["CreationEvent"] | components["schemas"]["ListingEvent"] | components["schemas"]["OfferEvent"] | components["schemas"]["AuctionBidEvent"] | components["schemas"]["AuctionLifecycleEvent"];
+        SaleEvent: {
+            /** @example evt_123 */
+            eventId: string;
+            /** @example 2024-01-01T00:00:00.000Z */
+            createdAt: string;
+            /** @example 0xabc123 */
+            transactionHash: string | null;
+            /** @example 12345678 */
+            blockNumber: number | null;
+            /** @enum {string} */
+            eventType: "SETTLE_AUCTION" | "TAKE_LISTING" | "TAKE_OFFER";
+            buyer: components["schemas"]["User"];
+            seller: components["schemas"]["User"];
+            price: components["schemas"]["CryptoValue"];
+        };
+        TransferEvent: {
+            /** @example evt_123 */
+            eventId: string;
+            /** @example 2024-01-01T00:00:00.000Z */
+            createdAt: string;
+            /** @example 0xabc123 */
+            transactionHash: string | null;
+            /** @example 12345678 */
+            blockNumber: number | null;
+            /** @enum {string} */
+            eventType: "TRANSFER_NFT" | "TRANSFER_NFT_SUPPLY";
+            from: components["schemas"]["User"];
+            to: components["schemas"]["User"];
+            /** @example 1 */
+            amount?: string;
+        };
+        CreationEvent: {
+            /** @example evt_123 */
+            eventId: string;
+            /** @example 2024-01-01T00:00:00.000Z */
+            createdAt: string;
+            /** @example 0xabc123 */
+            transactionHash: string | null;
+            /** @example 12345678 */
+            blockNumber: number | null;
+            /** @enum {string} */
+            eventType: "CREATE_NFT" | "CREATE_NFT_SUPPLY";
+            creator: components["schemas"]["User"];
+            /** @example 100 */
+            amount?: string;
+        };
+        ListingEvent: {
+            /** @example evt_123 */
+            eventId: string;
+            /** @example 2024-01-01T00:00:00.000Z */
+            createdAt: string;
+            /** @example 0xabc123 */
+            transactionHash: string | null;
+            /** @example 12345678 */
+            blockNumber: number | null;
+            /** @enum {string} */
+            eventType: "MAKE_LISTING";
+            price: components["schemas"]["CryptoValue"];
+            targetBuyer: components["schemas"]["User"] & unknown;
+        };
+        OfferEvent: {
+            /** @example evt_123 */
+            eventId: string;
+            /** @example 2024-01-01T00:00:00.000Z */
+            createdAt: string;
+            /** @example 0xabc123 */
+            transactionHash: string | null;
+            /** @example 12345678 */
+            blockNumber: number | null;
+            /** @enum {string} */
+            eventType: "MAKE_OFFER" | "CANCEL_OFFER";
+            buyer: components["schemas"]["User"];
+            price: components["schemas"]["CryptoValue"];
+        };
+        AuctionBidEvent: {
+            /** @example evt_123 */
+            eventId: string;
+            /** @example 2024-01-01T00:00:00.000Z */
+            createdAt: string;
+            /** @example 0xabc123 */
+            transactionHash: string | null;
+            /** @example 12345678 */
+            blockNumber: number | null;
+            /** @enum {string} */
+            eventType: "MAKE_AUCTION_BID";
+            bidder: components["schemas"]["User"];
+            price: components["schemas"]["CryptoValue"];
+            previousBidder: components["schemas"]["User"] & unknown;
+            /** @example false */
+            extendsAuction: boolean;
+        };
+        AuctionLifecycleEvent: {
+            /** @example evt_123 */
+            eventId: string;
+            /** @example 2024-01-01T00:00:00.000Z */
+            createdAt: string;
+            /** @example 0xabc123 */
+            transactionHash: string | null;
+            /** @example 12345678 */
+            blockNumber: number | null;
+            /** @enum {string} */
+            eventType: "CREATE_RESERVE_AUCTION" | "CREATE_SCHEDULED_AUCTION" | "START_AUCTION" | "END_AUCTION" | "CANCEL_AUCTION" | "CLOSE_AUCTION";
+            seller: components["schemas"]["User"] & unknown;
+            buyer: components["schemas"]["User"] & unknown;
+            price: components["schemas"]["CryptoValue"] & unknown;
+            minimumBid: components["schemas"]["CryptoValue"] & unknown;
+            /** @example 2024-01-01T00:00:00.000Z */
+            startTime: string | null;
+        };
+        CreateNftMetadataResponse: {
+            cid: string;
+            ipfsUrl: string;
+            gatewayUrl: string;
+            metadata: {
+                name: string;
+                description: string;
+                image: string;
+                media: {
+                    uri: string;
+                    mimeType: string;
+                    size?: number;
+                    dimensions?: string;
+                };
+                animation_url?: string;
+                tags: string[];
+                attributes?: {
+                    trait_type: string;
+                    value: string | number | boolean;
+                    display_type?: string;
+                }[];
+            };
+        };
+        CreateNftMetadataRequest: {
+            /** @example My NFT */
+            name: string;
+            /** @example A beautiful artwork */
+            description: string;
+            /**
+             * @example [
+             *       "art",
+             *       "digital"
+             *     ]
+             */
+            tags: string[];
+            attributes?: {
+                trait_type: string;
+                value: string | number | boolean;
+                display_type?: string;
+            }[];
+            nftMedia: components["schemas"]["NftMediaInput"];
+        };
+        NftMediaInput: {
+            image: components["schemas"]["MediaAsset"];
+            video?: components["schemas"]["MediaAsset"];
+            threeD?: components["schemas"]["MediaAsset"];
+            html?: components["schemas"]["MediaAsset"];
+        };
+        MediaAsset: {
+            /**
+             * Format: uri
+             * @example ipfs://QmExample
+             */
+            url: string;
+            /** @example image/png */
+            mimeType: string;
+            /** @example 1024000 */
+            size: number;
+            dimensions?: {
+                width: number;
+                height: number;
+            };
+        };
+        CreateMediaUploadResponse: {
+            /** @example abc123 */
+            uploadId: string;
+            /** @example a1b2c3d4/artwork.png */
+            key: string;
+            /** @example superrare-ipfs */
+            bucket: string;
+            /** @example 10000000 */
+            partSize: number;
+            presignedUrls: string[];
+            /** @example https://superrare.myfilebase.com */
+            gatewayBaseUrl: string;
+        };
+        CreateMediaUploadRequest: {
+            /** @example 5000000 */
+            fileSize: number;
+            /** @example artwork.png */
+            filename?: string;
+        };
+        IpfsUploadResponse: {
+            /** @example QmExampleCid */
+            cid: string;
+            /** @example ipfs://QmExampleCid */
+            ipfsUrl: string;
+            /** @example https://superrare.myfilebase.com/ipfs/QmExampleCid */
+            gatewayUrl: string;
+        };
+        CompleteMediaUploadRequest: {
+            /** @example a1b2c3d4/artwork.png */
+            key: string;
+            /** @example abc123 */
+            uploadId: string;
+            /** @example superrare-ipfs */
+            bucket: string;
+            parts: {
+                ETag: string;
+                PartNumber: number;
+            }[];
+        };
+        GenerateMediaResponse: {
+            media: {
+                uri: string;
+                mimeType: string;
+                size?: number;
+                dimensions?: string;
+            };
+        };
+        GenerateMediaRequest: {
+            /** @example ipfs://QmMediaCid */
+            uri: string;
+            /** @example image/png */
+            mimeType: string;
+        };
+        Collection: {
+            /** @example col_123 */
+            collectionId: string;
+            /** @example SuperRare Genesis */
+            name: string | null;
+            /** @example The original SuperRare collection */
+            description: string | null;
+            /** @example SUPR */
+            symbol: string | null;
+            /** @example https://example.com/banner.png */
+            bannerImage: string | null;
+            /** @example https://example.com/preview.png */
+            previewImage: string | null;
+            owner: components["schemas"]["User"];
+            stats: {
+                /** @example 1000 */
+                tokenCount: number;
+                /** @example 250 */
+                collectorCount: number;
+                /** @example 500 */
+                floorPriceUsd: number | null;
+                /** @example 10000 */
+                topOfferUsd: number | null;
+                /** @example 5000000 */
+                saleVolumeUsd: number | null;
+            };
+            /**
+             * @example [
+             *       "Background",
+             *       "Eyes",
+             *       "Mouth"
+             *     ]
+             */
+            attributes: string[];
+            /**
+             * @example [
+             *       1
+             *     ]
+             */
+            chainIds: number[];
+            /** @example 1704067200 */
+            createdAt: number;
+        };
+        ImportCollectionResponse: {
+            imported: boolean;
+            collection?: {
+                name: string;
+                symbol: string;
+            };
+        };
+        ImportCollectionRequest: {
+            chainId: components["schemas"]["ChainId"];
+            contractAddress: components["schemas"]["EthereumAddress"];
+            ownerAddress: components["schemas"]["EthereumAddress"];
+        };
+        UserProfile: {
+            /** @example 0xba5BDe662c17e2aDFF1075610382B9B691296350 */
+            address: string;
+            /** @example satoshi */
+            username: string;
+            /** @example Satoshi Nakamoto */
+            fullName: string | null;
+            stats: {
+                /** @example 42 */
+                created: number;
+                /** @example 15 */
+                owned: number;
+                /** @example 1000 */
+                followerCount: number;
+                /** @example true */
+                isCollector: boolean;
+                /** @example true */
+                isCreator: boolean;
+            };
+        };
+        TokenPriceResponse: {
+            data: {
+                symbol: string;
+                priceUsd: number;
+                decimals: number;
+                chainId: number;
+                address: string;
+            };
+        };
+        /**
+         * @description Token symbol (case-insensitive)
+         * @example rare
+         */
+        TokenSymbol: string;
+        GenerateNftMerkleRootResponse: {
+            /** @example 0xcf6398559ea0e93d7d7233ca93b09912da8ff57b45ebe7a3ede9c74d17a76f13 */
+            merkleRoot: string;
+            /** @example 0xcf6398559ea0e93d7d7233ca93b09912da8ff57b45ebe7a3ede9c74d17a76f13.json */
+            key: string;
+        };
+        GenerateNftMerkleRootRequest: {
+            nfts: components["schemas"]["NftMerkleRootEntry"][];
+        };
+        NftMerkleRootEntry: {
+            contractAddress: components["schemas"]["EthereumAddress"];
+            /** @example 12345 */
+            tokenId: string | number;
+        };
+        GenerateAddressMerkleRootResponse: {
+            /** @example 0xcf6398559ea0e93d7d7233ca93b09912da8ff57b45ebe7a3ede9c74d17a76f13 */
+            merkleRoot: string;
+            locations: components["schemas"]["MerkleRootLocation"][];
+        };
+        MerkleRootLocation: {
+            /** @enum {string} */
+            storageTarget: "batch-listing" | "collection-allowlist";
+            bucket: string;
+            key: string;
+            /** Format: uri */
+            publicUrl: string;
+        };
+        GenerateAddressMerkleRootJsonRequest: {
+            addresses: components["schemas"]["EthereumAddress"][];
+            storageTarget?: components["schemas"]["MerkleRootStorageTarget"];
+        };
+        /**
+         * @description Storage destination for address merkle roots
+         * @default both
+         * @example both
+         * @enum {string}
+         */
+        MerkleRootStorageTarget: "batch-listing" | "collection-allowlist" | "both";
+        GenerateAddressMerkleRootFormRequest: {
+            /**
+             * Format: binary
+             * @description CSV file with an address column
+             */
+            file?: string;
+            storageTarget?: components["schemas"]["MerkleRootStorageTarget"];
+        };
+        GenerateNftMerkleProofResponse: {
+            /** @example 0xcf6398559ea0e93d7d7233ca93b09912da8ff57b45ebe7a3ede9c74d17a76f13 */
+            root: string;
+            /** @example 0x8Db4B93Fa258E1c265d46f861ae9EbDE0B938670 */
+            contractAddress: string;
+            /** @example 12345 */
+            tokenId: string;
+            /** @example 0x83a68bd27e04afae4b40e8647019086ae8b4915bb243a4cf186f6271e1e65341 */
+            leaf: string;
+            proof: string[];
+        };
+        GenerateNftMerkleProofRequest: {
+            /** @example 1 */
+            chainId: number;
+            contractAddress: components["schemas"]["EthereumAddress"];
+            /** @example 12345 */
+            tokenId: string | number;
+            /** @example 0xcf6398559ea0e93d7d7233ca93b09912da8ff57b45ebe7a3ede9c74d17a76f13 */
+            root?: string;
+            context?: components["schemas"]["NftMerkleProofContext"];
+            creator?: components["schemas"]["EthereumAddress"];
+        };
+        /**
+         * @description Market state context used when resolving a root from Typesense
+         * @example batch-listing
+         * @enum {string}
+         */
+        NftMerkleProofContext: "batch-listing" | "batch-auction" | "batch-offer";
+        GenerateAddressMerkleProofResponse: {
+            /** @example 0xcf6398559ea0e93d7d7233ca93b09912da8ff57b45ebe7a3ede9c74d17a76f13 */
+            root: string;
+            /** @example 0x8Db4B93Fa258E1c265d46f861ae9EbDE0B938670 */
+            address: string;
+            /** @example 0x83a68bd27e04afae4b40e8647019086ae8b4915bb243a4cf186f6271e1e65341 */
+            leaf: string;
+            proof: string[];
+        };
+        GenerateAddressMerkleProofRequest: {
+            /** @example 0xcf6398559ea0e93d7d7233ca93b09912da8ff57b45ebe7a3ede9c74d17a76f13 */
+            root: string;
+            address: components["schemas"]["EthereumAddress"];
+            storageTarget?: components["schemas"]["MerkleRootProofStorageTarget"];
+        };
+        /**
+         * @description Storage source for address merkle proof generation
+         * @default collection-allowlist
+         * @example collection-allowlist
+         * @enum {string}
+         */
+        MerkleRootProofStorageTarget: "batch-listing" | "collection-allowlist";
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+
+type EventSearchTargetParams = {
+    chain?: SupportedChain;
+    chainId?: IntegerInput;
+    contract?: Address;
+    tokenId?: IntegerInput;
+    collectionId?: string;
 };
 
+type NftListQuery = NonNullable<paths['/v1/nfts']['get']['parameters']['query']>;
+type CollectionListQuery = NonNullable<paths['/v1/collections']['get']['parameters']['query']>;
 type NftMediaEntry = {
     url: string;
     mimeType: string;
@@ -48,7 +1611,7 @@ type NftMediaEntry = {
     };
 };
 type NftAttribute = {
-    trait_type?: string;
+    trait_type: string;
     value: string | number;
     display_type?: 'number' | 'boost_number' | 'boost_percentage' | 'date';
     max_value?: number;
@@ -65,64 +1628,223 @@ type ImportErc721Params = {
     contract: Address;
     owner?: Address;
 };
+type NftSearchParams = {
+    query?: string;
+    page?: number;
+    perPage?: number;
+    sortBy?: NftListQuery['sortBy'];
+    ownerAddress?: string;
+    creatorAddress?: string;
+    contractAddress?: string;
+    collectionId?: string;
+    chainId?: number;
+    listingType?: NftListQuery['listingType'];
+    hasAuction?: boolean;
+    auctionState?: NftListQuery['auctionState'];
+    auctionCreatorAddress?: string;
+    auctionBidderAddress?: string;
+    hasListing?: boolean;
+    hasOffer?: boolean;
+    offerBuyerAddress?: string;
+    tags?: string[];
+    mediaType?: NftListQuery['mediaType'];
+};
+type CollectionSearchParams = {
+    query?: string;
+    page?: number;
+    perPage?: number;
+    sortBy?: CollectionListQuery['sortBy'];
+    ownerAddress?: string;
+    chainId?: number;
+};
 
-type IntegerInput = bigint | number | string;
-type AmountInput = bigint | number | string;
-interface RareClientConfig {
-    publicClient: PublicClient;
-    walletClient?: WalletClient;
-    account?: Address;
-}
-interface TransactionResult {
-    txHash: Hash;
-    receipt: TransactionReceipt;
-}
-interface DeployErc721Params {
-    name: string;
-    symbol: string;
-    maxTokens?: IntegerInput;
-}
-interface DeployErc721Result extends TransactionResult {
-    contract: Address | undefined;
-}
-interface MintToParams {
+type Nft = components['schemas']['Nft'];
+type Collection = components['schemas']['Collection'];
+type NftEvent = components['schemas']['NftEvent'];
+type UserProfile = components['schemas']['UserProfile'];
+type Pagination = components['schemas']['Pagination'];
+
+type SearchPageResponse<T> = {
+    data: T[];
+    pagination: Pagination;
+};
+type NftEventQuery = NonNullable<paths['/v1/nfts/{universalTokenId}/events']['get']['parameters']['query']>;
+type NftEventType = NonNullable<NftEventQuery['eventType']>[number];
+type NftEventOptions = {
+    page?: number;
+    perPage?: number;
+    eventType?: NftEventType | NftEventType[];
+    sortBy?: NftEventQuery['sortBy'];
+};
+type EventSearchParams = EventSearchTargetParams & NftEventOptions;
+
+type NftIdentityParams = {
+    chain?: SupportedChain;
+    chainId?: IntegerInput;
     contract: Address;
-    tokenUri: string;
-    to?: Address;
-    royaltyReceiver?: Address;
-}
-interface MintToResult extends TransactionResult {
-    tokenId: bigint | undefined;
-}
-interface AuctionCreateParams {
+    tokenId: IntegerInput;
+};
+
+type BatchAuctionRootSource = {
+    root: Hex$1;
+    artifact?: BatchTokenListArtifact;
+} | {
+    artifact: BatchTokenListArtifact;
+    root?: Hex$1;
+};
+type BatchAuctionCreateParams = BatchAuctionRootSource & {
+    price: AmountInput;
+    currency?: CurrencyInput;
+    endTime: TimestampInput;
+    splitAddresses?: Address[];
+    splitRatios?: number[];
+    autoApprove?: boolean;
+};
+type BatchAuctionCreateResult = {
+    batchAuctionHouse: Address;
+    creator: Address;
+    root: Hex$1;
+    currency: Address;
+    reserveAmount: bigint;
+    duration: bigint;
+    nonce: number;
+    approvalTxHashes: Hash[];
+} & TransactionResult;
+type BatchAuctionCancelParams = {
+    root?: Hex$1;
+    artifact?: BatchTokenListArtifact;
+};
+type BatchAuctionRootsParams = {
+    creator?: Address;
+};
+type BatchAuctionCancelResult = {
+    batchAuctionHouse: Address;
+    creator: Address;
+    root: Hex$1;
+} & TransactionResult;
+type BatchAuctionBidParams = {
+    creator: Address;
+    root?: Hex$1;
+    proof?: readonly Hex$1[];
+    proofArtifact?: BatchTokenProofArtifact;
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: CurrencyInput;
+    price: AmountInput;
+    autoApprove?: boolean;
+};
+type BatchAuctionBidResult = {
+    batchAuctionHouse: Address;
+    bidder: Address;
+    creator: Address;
+    contract: Address;
+    tokenId: bigint;
+    root: Hex$1;
+    currency: Address;
+    amount: bigint;
+    nonce: number;
+    requiredPayment: bigint;
+    approvalTxHash?: Hash;
+} & TransactionResult;
+type BatchAuctionSettleParams = {
     contract: Address;
     tokenId: IntegerInput;
-    startingPrice: AmountInput;
-    duration: IntegerInput;
-    currency?: Address;
+};
+type BatchAuctionSettleResult = {
+    batchAuctionHouse: Address;
+    seller: Address;
+    bidder: Address;
+    contract: Address;
+    tokenId: bigint;
+    currency: Address;
+    amount: bigint;
+    marketplaceFee: number;
+} & TransactionResult;
+type BatchAuctionStatusParams = {
+    contract: Address;
+    tokenId: IntegerInput;
+    creator?: Address;
+    root?: Hex$1;
+    artifact?: BatchTokenListArtifact;
+    proof?: readonly Hex$1[];
+    proofArtifact?: BatchTokenProofArtifact;
+};
+type BatchAuctionStatus = {
+    seller: Address;
+    root: Hex$1 | null;
+    currency: Address;
+    reserveAmount: bigint;
+    duration: bigint;
+    creationBlock: bigint;
+    startingTime: bigint;
+    endTime: bigint | null;
+    splitAddresses: Address[];
+    splitRatios: number[];
+    hasRootConfig: boolean;
+    rootNonce: number | null;
+    tokenNonce: number | null;
+    tokenNonceConsumed: boolean | null;
+    hasAuction: boolean;
+    started: boolean;
+    ended: boolean;
+    settlementEligible: boolean;
+    currentBidder: Address | null;
+    currentBid: bigint;
+    currentBidCurrency: Address;
+    currentBidMarketplaceFee: number;
+    minimumNextBid: bigint;
+    state: 'NONE' | 'CONFIGURED' | 'RESERVE_NOT_MET' | 'ACTIVE' | 'ENDED' | 'USED';
+    isEth: boolean;
+};
+type BatchAuctionNamespace = {
+    create: (params: BatchAuctionCreateParams) => Promise<BatchAuctionCreateResult>;
+    cancel: (params: BatchAuctionCancelParams) => Promise<BatchAuctionCancelResult>;
+    roots: (params?: BatchAuctionRootsParams) => Promise<Hex$1[]>;
+    bid: (params: BatchAuctionBidParams) => Promise<BatchAuctionBidResult>;
+    settle: (params: BatchAuctionSettleParams) => Promise<BatchAuctionSettleResult>;
+    status: (params: BatchAuctionStatusParams) => Promise<BatchAuctionStatus>;
+};
+
+type AuctionCreateParams = {
+    contract: Address;
+    tokenId: IntegerInput;
+    price: AmountInput;
+    endTime: TimestampInput;
+    currency?: CurrencyInput;
+    auctionType?: 'reserve' | 'scheduled';
+    startTime?: TimestampInput;
     splitAddresses?: Address[];
     splitRatios?: number[];
     autoApprove?: boolean;
-}
-interface AuctionBidParams {
+};
+type AuctionCreateResult = TransactionResult & {
+    approvalTxHash?: Hash;
+    auctionType: 'reserve' | 'scheduled';
+    startTime: bigint;
+};
+type AuctionBidParams = {
     contract: Address;
     tokenId: IntegerInput;
-    amount: AmountInput;
-    currency?: Address;
-}
-interface AuctionSettleParams {
+    price: AmountInput;
+    currency?: CurrencyInput;
+    autoApprove?: boolean;
+};
+type AuctionBidResult = TransactionResult & {
+    approvalTxHash?: Hash;
+};
+type AuctionSettleParams = {
     contract: Address;
     tokenId: IntegerInput;
-}
-interface AuctionCancelParams {
+};
+type AuctionCancelParams = {
     contract: Address;
     tokenId: IntegerInput;
-}
-interface AuctionStatusParams {
+};
+type AuctionStatusParams = {
     contract: Address;
     tokenId: IntegerInput;
-}
-interface AuctionStatus {
+};
+type AuctionStatus = {
     seller: Address;
     creationBlock: bigint;
     startingTime: bigint;
@@ -130,2095 +1852,1040 @@ interface AuctionStatus {
     currency: Address;
     minimumBid: bigint;
     auctionType: `0x${string}`;
+    auctionTypeName: 'reserve' | 'scheduled' | 'none' | 'unknown';
     splitAddresses: Address[];
     splitRatios: number[];
     isEth: boolean;
+    hasAuction: boolean;
     started: boolean;
     endTime: bigint | null;
     status: 'PENDING' | 'RUNNING' | 'ENDED';
-}
-interface OfferCreateParams {
+    state: 'NONE' | 'RESERVE_NOT_MET' | 'SCHEDULED' | 'ACTIVE' | 'ENDED';
+    currentBidder: Address | null;
+    currentBid: bigint;
+    currentBidCurrency: Address;
+    currentBidMarketplaceFee: number;
+    minimumNextBid: bigint;
+    settlementEligible: boolean;
+};
+type AuctionMarketplaceNamespace = {
+    create: (params: AuctionCreateParams) => Promise<AuctionCreateResult>;
+    bid: (params: AuctionBidParams) => Promise<AuctionBidResult>;
+    settle: (params: AuctionSettleParams) => Promise<TransactionResult>;
+    cancel: (params: AuctionCancelParams) => Promise<TransactionResult>;
+    status: (params: AuctionStatusParams) => Promise<AuctionStatus>;
+};
+type AuctionNamespace = AuctionMarketplaceNamespace & {
+    batch: BatchAuctionNamespace;
+};
+
+declare const lazySovereignCollectionContractTypes: readonly ["lazy", "lazy-royalty-guard", "lazy-deadman-royalty-guard"];
+type LazySovereignCollectionContractType = (typeof lazySovereignCollectionContractTypes)[number];
+
+type DeployErc721Params = {
+    name: string;
+    symbol: string;
+    maxTokens?: IntegerInput;
+};
+type DeployErc721Result = {
+    contract: Address;
+} & TransactionResult;
+type DeployLazyBatchMintParams = {
+    name: string;
+    symbol: string;
+    maxTokens?: IntegerInput;
+};
+type DeployLazyBatchMintResult = {
+    contract: Address;
+} & TransactionResult;
+type DeployLazyErc721Params = {
+    name: string;
+    symbol: string;
+    maxTokens: IntegerInput;
+    contractType?: LazySovereignCollectionContractType;
+};
+type DeployLazyErc721Result = {
+    contract: Address;
+    factory: Address;
+    contractType: LazySovereignCollectionContractType;
+    nextStep: string;
+} & TransactionResult;
+type CollectionMintBatchParams = {
+    contract: Address;
+    baseUri: string;
+    amount: IntegerInput;
+};
+type CollectionMintBatchResult = {
+    contract: Address;
+    baseUri: string;
+    tokenCount: bigint;
+    fromTokenId: bigint;
+    toTokenId: bigint;
+    owner: Address;
+} & TransactionResult;
+type CollectionPrepareLazyMintParams = {
+    contract: Address;
+    baseUri: string;
+    amount: IntegerInput;
+    minter?: Address;
+};
+type CollectionPrepareLazyMintResult = {
+    contract: Address;
+    baseUri: string;
+    tokenCount: bigint;
+    fromTokenId?: bigint;
+    toTokenId?: bigint;
+    minter?: Address;
+} & TransactionResult;
+type CollectionTokenCreatorParams = {
     contract: Address;
     tokenId: IntegerInput;
-    currency?: Address;
-    amount: AmountInput;
-    convertible?: boolean;
-}
-interface OfferCancelParams {
+};
+type CollectionTokenCreatorResult = {
+    contract: Address;
+    tokenId: bigint;
+    creator: Address;
+};
+type CollectionRoyaltyInfoParams = {
     contract: Address;
     tokenId: IntegerInput;
-    currency?: Address;
-}
-interface OfferAcceptParams {
+    price?: IntegerInput;
+};
+type CollectionRoyaltyInfoResult = {
+    contract: Address;
+    tokenId: bigint;
+    salePrice: bigint;
+    receiver: Address;
+    royaltyAmount: bigint;
+    defaultReceiver?: Address;
+    defaultPercentage?: bigint;
+};
+type CollectionSetDefaultRoyaltyReceiverParams = {
+    contract: Address;
+    receiver: Address;
+};
+type CollectionSetDefaultRoyaltyReceiverResult = {
+    contract: Address;
+    receiver: Address;
+} & TransactionResult;
+type CollectionSetDefaultRoyaltyPercentageParams = {
+    contract: Address;
+    percentage: IntegerInput;
+};
+type CollectionSetDefaultRoyaltyPercentageResult = {
+    contract: Address;
+    percentage: number;
+} & TransactionResult;
+type CollectionSetTokenRoyaltyReceiverParams = {
     contract: Address;
     tokenId: IntegerInput;
-    currency?: Address;
-    amount: AmountInput;
+    receiver: Address;
+};
+type CollectionSetTokenRoyaltyReceiverResult = {
+    contract: Address;
+    tokenId: bigint;
+    receiver: Address;
+} & TransactionResult;
+type CollectionMintConfigParams = {
+    contract: Address;
+};
+type CollectionMintConfigResult = {
+    contract: Address;
+    tokenCount: bigint;
+    baseUri: string;
+    lockedMetadata: boolean;
+};
+type CollectionUpdateBaseUriParams = {
+    contract: Address;
+    baseUri: string;
+};
+type CollectionUpdateBaseUriResult = {
+    contract: Address;
+    baseUri: string;
+} & TransactionResult;
+type CollectionUpdateTokenUriParams = {
+    contract: Address;
+    tokenId: IntegerInput;
+    tokenUri: string;
+};
+type CollectionUpdateTokenUriResult = {
+    contract: Address;
+    tokenId: bigint;
+    tokenUri: string;
+} & TransactionResult;
+type CollectionLockBaseUriParams = {
+    contract: Address;
+};
+type CollectionLockBaseUriResult = {
+    contract: Address;
+    baseUri: string;
+} & TransactionResult;
+type CollectionMintParams = {
+    contract: Address;
+    tokenUri: string;
+    to?: Address;
+    royaltyReceiver?: Address;
+};
+type CollectionMintResult = {
+    tokenId: bigint;
+} & TransactionResult;
+type CollectionDeployNamespace = {
+    erc721: (params: DeployErc721Params) => Promise<DeployErc721Result>;
+    lazyErc721: (params: DeployLazyErc721Params) => Promise<DeployLazyErc721Result>;
+    lazyBatchMint: (params: DeployLazyBatchMintParams) => Promise<DeployLazyBatchMintResult>;
+};
+type CollectionNamespace = {
+    get: (id: string) => Promise<Collection>;
+    deploy: CollectionDeployNamespace;
+    mint: (params: CollectionMintParams) => Promise<CollectionMintResult>;
+    mintBatch: (params: CollectionMintBatchParams) => Promise<CollectionMintBatchResult>;
+    prepareLazyMint: (params: CollectionPrepareLazyMintParams) => Promise<CollectionPrepareLazyMintResult>;
+    getTokenCreator: (params: CollectionTokenCreatorParams) => Promise<CollectionTokenCreatorResult>;
+    royalty: {
+        status: (params: CollectionRoyaltyInfoParams) => Promise<CollectionRoyaltyInfoResult>;
+    };
+    metadata: {
+        status: (params: CollectionMintConfigParams) => Promise<CollectionMintConfigResult>;
+    };
+    setDefaultRoyaltyReceiver: (params: CollectionSetDefaultRoyaltyReceiverParams) => Promise<CollectionSetDefaultRoyaltyReceiverResult>;
+    setDefaultRoyaltyPercentage: (params: CollectionSetDefaultRoyaltyPercentageParams) => Promise<CollectionSetDefaultRoyaltyPercentageResult>;
+    setTokenRoyaltyReceiver: (params: CollectionSetTokenRoyaltyReceiverParams) => Promise<CollectionSetTokenRoyaltyReceiverResult>;
+    updateBaseUri: (params: CollectionUpdateBaseUriParams) => Promise<CollectionUpdateBaseUriResult>;
+    updateTokenUri: (params: CollectionUpdateTokenUriParams) => Promise<CollectionUpdateTokenUriResult>;
+    lockBaseUri: (params: CollectionLockBaseUriParams) => Promise<CollectionLockBaseUriResult>;
+};
+
+type LiquidFactoryConfig = {
+    baseToken: Address;
+    maxTotalSupplyWei: bigint;
+    creatorLaunchRewardWei: bigint;
+    curvePoolSupplyWei: bigint;
+    minRareLiquidityWei: bigint;
+    maxTotalSupplyTokens: string;
+    creatorLaunchRewardTokens: string;
+    curvePoolSupplyTokens: string;
+    minRareLiquidityTokens: string;
+    lpTickLower: number;
+    lpTickUpper: number;
+    poolTickSpacing: number;
+};
+
+type CurvePresetKey = 'low-demand' | 'medium-demand' | 'high-demand';
+type LiquidCurveSegment = {
+    tickLower: number;
+    tickUpper: number;
+    numPositions: number;
+    shares: string;
+};
+type LiquidCurveSegmentSummary = {
+    tickLower: number;
+    tickUpper: number;
+    numPositions: number;
+    shares: string;
+    startTokenPriceUsd?: number;
+    endTokenPriceUsd?: number;
+};
+type LiquidCurvePreview = {
+    totalPositions: number;
+    totalShare: number;
+    curvePoolSupplyTokens: string;
+    maxTotalSupplyTokens: string;
+    creatorLaunchRewardTokens: string;
+    baseToken: Address;
+    rarePriceUsd?: number;
+    segments: LiquidCurveSegmentSummary[];
+};
+
+type GeneratePresetCurvesParams = {
+    preset: CurvePresetKey;
+    totalSupply?: AmountInput;
+};
+type GeneratePresetCurvesResult = {
+    preset: CurvePresetKey;
+    rarePriceUsd: number;
+    curves: LiquidCurveSegment[];
+    preview: LiquidCurvePreview;
+};
+type ValidateLiquidCurvesParams = {
+    curves: LiquidCurveSegment[];
+    totalSupply?: AmountInput;
+};
+type DeployLiquidEditionParams = {
+    name: string;
+    symbol: string;
+    tokenUri: string;
+    initialRareLiquidity?: AmountInput;
+    totalSupply?: AmountInput;
+    curves: LiquidCurveSegment[];
+};
+type DeployLiquidEditionResult = {
+    contract: Address;
+    tokenUri: string;
+    curves: LiquidCurveSegment[];
+} & TransactionResult;
+type LiquidEditionPoolKey = {
+    currency0: Address;
+    currency1: Address;
+    fee: number;
+    tickSpacing: number;
+    hooks: Address;
+};
+type LiquidEditionPoolInfo = {
+    contract: Address;
+    poolId: Hex$1;
+    poolKey: LiquidEditionPoolKey;
+};
+type LiquidEditionMarketState = {
+    rarePerToken: bigint;
+    tokenPerRare: bigint;
+    sqrtPriceX96: bigint;
+    currentTick: number;
+    liquidity: bigint;
+    currentSupply: bigint;
+};
+type LiquidEditionCurrentPrice = {
+    contract: Address;
+    rarePerToken: bigint;
+    tokenPerRare: bigint;
+};
+type LiquidEditionTelemetry = {
+    contract: Address;
+    name: string;
+    symbol: string;
+    decimals: number;
+    totalSupply: bigint;
+    maxTotalSupply: bigint;
+    poolLaunchSupply: bigint;
+    creatorLaunchReward: bigint;
+    baseToken: Address;
+    tokenCreator: Address;
+    initialTokenUri: string;
+    tokenUri: string;
+    renderContract: Address;
+    poolManager: Address;
+    pool: LiquidEditionPoolInfo;
+    lpTickLower: number;
+    lpTickUpper: number;
+    lpLiquidity: bigint;
+    totalLiquidity: bigint;
+    marketState: LiquidEditionMarketState;
+    currentPrice: LiquidEditionCurrentPrice;
+};
+type SetLiquidEditionRenderContractParams = {
+    contract: Address;
+    renderContract: Address;
+};
+type SetLiquidEditionRenderContractResult = {
+    contract: Address;
+    renderContract: Address;
+} & TransactionResult;
+type LiquidEditionNamespace = {
+    getFactoryConfig: () => Promise<LiquidFactoryConfig>;
+    generatePresetCurves: (params: GeneratePresetCurvesParams) => Promise<GeneratePresetCurvesResult>;
+    validateCurves: (params: ValidateLiquidCurvesParams) => Promise<LiquidCurvePreview>;
+    deploy: {
+        multiCurve: (params: DeployLiquidEditionParams) => Promise<DeployLiquidEditionResult>;
+    };
+    getTokenUri: (params: {
+        contract: Address;
+    }) => Promise<string>;
+    getRenderContract: (params: {
+        contract: Address;
+    }) => Promise<Address>;
+    setRenderContract: (params: SetLiquidEditionRenderContractParams) => Promise<SetLiquidEditionRenderContractResult>;
+    getPoolInfo: (params: {
+        contract: Address;
+    }) => Promise<LiquidEditionPoolInfo>;
+    getMarketState: (params: {
+        contract: Address;
+    }) => Promise<LiquidEditionMarketState>;
+    getCurrentPrice: (params: {
+        contract: Address;
+    }) => Promise<LiquidEditionCurrentPrice>;
+    status: (params: {
+        contract: Address;
+    }) => Promise<LiquidEditionTelemetry>;
+};
+
+type ReleaseConfigureParams = {
+    contract: Address;
+    currency?: CurrencyInput;
+    price: AmountInput;
+    startTime?: TimestampInput;
+    maxMints: IntegerInput;
     splitAddresses?: Address[];
     splitRatios?: number[];
-}
-interface OfferStatusParams {
+};
+type ReleaseConfigureResult = {
+    rareMinter: Address;
+    contract: Address;
+    currencyAddress: Address;
+    price: bigint;
+    startTime: bigint;
+    maxMints: bigint;
+    splitRecipients: Address[];
+    splitRatios: number[];
+} & TransactionResult;
+type ReleaseMintDirectSaleParams = {
+    contract: Address;
+    quantity?: IntegerInput;
+    currency?: CurrencyInput;
+    price?: AmountInput;
+    proof?: readonly Hash[];
+    recipient?: Address;
+    autoApprove?: boolean;
+};
+type ReleaseMintDirectSaleResult = {
+    rareMinter: Address;
     contract: Address;
-    tokenId: IntegerInput;
-    currency?: Address;
-}
-interface OfferStatus {
     buyer: Address;
-    amount: bigint;
-    timestamp: bigint;
-    marketplaceFee: number;
-    convertible: boolean;
-    hasOffer: boolean;
-}
-interface ListingCreateParams {
+    recipient: Address;
+    quantity: number;
+    currencyAddress: Address;
+    price: bigint;
+    totalPrice: bigint;
+    requiredPayment: bigint;
+    approvalTxHash?: Hash;
+    allowlistRequired: boolean;
+    tokenIdStart: bigint;
+    tokenIdEnd: bigint;
+    tokenIds: bigint[];
+} & TransactionResult;
+type ReleaseAllowlistInputFormat = 'csv' | 'json';
+type ReleaseAllowlistWalletProof = {
+    address: Address;
+    leaf: Hex$1;
+    proof: Hex$1[];
+};
+type ReleaseAllowlistArtifact = {
+    kind: 'rare-release-allowlist-v1';
+    version: 1;
+    leafEncoding: 'keccak256(address)';
+    tree: 'sorted-addresses-sort-pairs';
+    root: Hex$1;
+    wallets: ReleaseAllowlistWalletProof[];
+};
+type ReleaseAllowlistConfig = {
+    rareMinter: Address;
+    contract: Address;
+    root: Hash;
+    endTimestamp: bigint;
+    active: boolean;
+    now: bigint;
+};
+type ReleaseLimitConfig = {
+    rareMinter: Address;
+    contract: Address;
+    limit: bigint;
+    enabled: boolean;
+};
+type ReleaseSetAllowlistConfigParams = {
+    contract: Address;
+    root?: Hash;
+    artifact?: ReleaseAllowlistArtifact;
+    endTime: TimestampInput;
+};
+type ReleaseSetAllowlistConfigResult = {
+    config: ReleaseAllowlistConfig;
+} & TransactionResult;
+type ReleaseSetLimitParams = {
+    contract: Address;
+    limit: IntegerInput;
+};
+type ReleaseSetLimitResult = {
+    config: ReleaseLimitConfig;
+} & TransactionResult;
+type ReleaseStatusParams = {
+    contract: Address;
+    account?: Address;
+};
+type ReleaseStatus = {
+    rareMinter: Address;
+    contract: Address;
+    configured: boolean;
+    seller: Address;
+    currencyAddress: Address;
+    currencyDecimals: number | null;
+    price: bigint;
+    startTime: bigint;
+    maxMints: bigint;
+    splitRecipients: Address[];
+    splitRatios: number[];
+    allowlistRoot: `0x${string}`;
+    allowlistEndTimestamp: bigint;
+    allowlistActive: boolean;
+    requiresAllowlist: boolean;
+    mintLimit: bigint;
+    txLimit: bigint;
+    account: Address | null;
+    accountMints: bigint | null;
+    accountTxs: bigint | null;
+    totalSupply: bigint | null;
+    maxSupply: bigint | null;
+    remainingSupply: bigint | null;
+    soldOut: boolean | null;
+    started: boolean;
+    currentlyMintable: boolean;
+    isEth: boolean;
+    now: bigint;
+};
+type ReleaseAllowlistNamespace = {
+    build: (params: {
+        input: string;
+        format: ReleaseAllowlistInputFormat;
+    }) => ReleaseAllowlistArtifact;
+    parse: (params: {
+        input: string;
+    }) => ReleaseAllowlistArtifact;
+    proof: (params: {
+        artifact: ReleaseAllowlistArtifact;
+        address: Address;
+    }) => ReleaseAllowlistWalletProof | null;
+    getConfig: (params: {
+        contract: Address;
+    }) => Promise<ReleaseAllowlistConfig>;
+    setConfig: (params: ReleaseSetAllowlistConfigParams) => Promise<ReleaseSetAllowlistConfigResult>;
+    clear: (params: {
+        contract: Address;
+    }) => Promise<ReleaseSetAllowlistConfigResult>;
+};
+type ReleaseLimitsNamespace = {
+    getMint: (params: {
+        contract: Address;
+    }) => Promise<ReleaseLimitConfig>;
+    setMint: (params: ReleaseSetLimitParams) => Promise<ReleaseSetLimitResult>;
+    getTx: (params: {
+        contract: Address;
+    }) => Promise<ReleaseLimitConfig>;
+    setTx: (params: ReleaseSetLimitParams) => Promise<ReleaseSetLimitResult>;
+};
+type ReleaseNamespace = {
+    allowlist: ReleaseAllowlistNamespace;
+    limits: ReleaseLimitsNamespace;
+    configure: (params: ReleaseConfigureParams) => Promise<ReleaseConfigureResult>;
+    mint: (params: ReleaseMintDirectSaleParams) => Promise<ReleaseMintDirectSaleResult>;
+    status: (params: ReleaseStatusParams) => Promise<ReleaseStatus>;
+};
+
+type ListingCreateParams = {
     contract: Address;
     tokenId: IntegerInput;
-    currency?: Address;
+    currency?: CurrencyInput;
     price: AmountInput;
     target?: Address;
     splitAddresses?: Address[];
     splitRatios?: number[];
     autoApprove?: boolean;
-}
-interface ListingCancelParams {
+};
+type ListingCreateResult = TransactionResult & {
+    approvalTxHash?: Hash;
+};
+type ListingCancelParams = {
     contract: Address;
     tokenId: IntegerInput;
     target?: Address;
-}
-interface ListingBuyParams {
+};
+type ListingBuyParams = {
     contract: Address;
     tokenId: IntegerInput;
-    currency?: Address;
-    amount: AmountInput;
-}
-interface ListingStatusParams {
+    currency?: CurrencyInput;
+    price: AmountInput;
+    autoApprove?: boolean;
+};
+type ListingBuyResult = TransactionResult & {
+    approvalTxHash?: Hash;
+};
+type ListingStatusParams = {
     contract: Address;
     tokenId: IntegerInput;
     target?: Address;
-}
-interface ListingStatus {
+};
+type ListingStatus = {
     seller: Address;
     currencyAddress: Address;
     amount: bigint;
     hasListing: boolean;
     isEth: boolean;
-}
-interface TokenContractInfo {
+    target: Address;
+    splitAddresses: Address[];
+    splitRatios: number[];
+    canBuy: boolean | null;
+};
+type ListingMarketplaceNamespace = {
+    create: (params: ListingCreateParams) => Promise<ListingCreateResult>;
+    cancel: (params: ListingCancelParams) => Promise<TransactionResult>;
+    buy: (params: ListingBuyParams) => Promise<ListingBuyResult>;
+    status: (params: ListingStatusParams) => Promise<ListingStatus>;
+};
+type ListingNamespace = ListingMarketplaceNamespace & {
+    release: ReleaseNamespace;
+    batch: BatchListingNamespace;
+};
+
+type BatchOfferRootSource = {
+    root: Hex$1;
+    artifact?: BatchTokenListArtifact;
+} | {
+    artifact: BatchTokenListArtifact;
+    root?: Hex$1;
+};
+type BatchOfferCreateParams = BatchOfferRootSource & {
+    price: AmountInput;
+    currency?: CurrencyInput;
+    endTime: TimestampInput;
+    autoApprove?: boolean;
+};
+type BatchOfferCreateResult = {
+    batchOfferCreator: Address;
+    creator: Address;
+    root: Hex$1;
+    amount: bigint;
+    currency: Address;
+    expiry: bigint;
+    requiredPayment: bigint;
+    approvalTxHash?: Hash;
+} & TransactionResult;
+type BatchOfferRevokeParams = BatchOfferRootSource | {
+    contract: Address;
+    tokenId: IntegerInput;
+    root?: Hex$1;
+    artifact?: BatchTokenListArtifact;
+};
+type BatchOfferRevokeResult = {
+    batchOfferCreator: Address;
+    creator: Address;
+    root: Hex$1;
+    amount: bigint;
+    currency: Address;
+} & TransactionResult;
+type BatchOfferAcceptParams = {
+    creator: Address;
+    root?: Hex$1;
+    proof?: readonly Hex$1[];
+    proofArtifact?: BatchTokenProofArtifact;
+    contract: Address;
+    tokenId: IntegerInput;
+    splitAddresses?: Address[];
+    splitRatios?: number[];
+    autoApprove?: boolean;
+};
+type BatchOfferAcceptResult = {
+    batchOfferCreator: Address;
+    seller: Address;
+    buyer: Address;
+    creator: Address;
+    contract: Address;
+    tokenId: bigint;
+    root: Hex$1;
+    currency: Address;
+    amount: bigint;
+    approvalTxHash?: Hash;
+} & TransactionResult;
+type BatchOfferStatusParams = {
+    creator: Address;
+    root?: Hex$1;
+    artifact?: BatchTokenListArtifact;
+};
+type BatchOfferStatus = {
+    creator: Address;
+    root: Hex$1;
+    amount: bigint;
+    currency: Address;
+    expiry: bigint;
+    feePercentage: bigint;
+    hasOffer: boolean;
+    expired: boolean;
+    revoked: boolean | null;
+    fillable: boolean;
+    state: 'NONE' | 'ACTIVE' | 'EXPIRED';
+    isEth: boolean;
+};
+type BatchOfferNamespace = {
+    create: (params: BatchOfferCreateParams) => Promise<BatchOfferCreateResult>;
+    revoke: (params: BatchOfferRevokeParams) => Promise<BatchOfferRevokeResult>;
+    accept: (params: BatchOfferAcceptParams) => Promise<BatchOfferAcceptResult>;
+    status: (params: BatchOfferStatusParams) => Promise<BatchOfferStatus>;
+};
+
+type OfferCreateParams = {
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: CurrencyInput;
+    price: AmountInput;
+    autoApprove?: boolean;
+};
+type OfferCreateResult = TransactionResult & {
+    approvalTxHash?: Hash;
+};
+type OfferCancelParams = {
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: CurrencyInput;
+};
+type OfferAcceptParams = {
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: CurrencyInput;
+    price: AmountInput;
+    splitAddresses?: Address[];
+    splitRatios?: number[];
+    autoApprove?: boolean;
+};
+type OfferAcceptResult = TransactionResult & {
+    approvalTxHash?: Hash;
+};
+type OfferStatusParams = {
+    contract: Address;
+    tokenId: IntegerInput;
+    currency?: CurrencyInput;
+};
+type OfferStatus = {
+    buyer: Address;
+    amount: bigint;
+    timestamp: bigint;
+    marketplaceFee: number;
+    hasOffer: boolean;
+    currency: Address;
+    tokenOwner: Address | null;
+    cancellableAfter: bigint | null;
+    canAccept: boolean | null;
+    canCancel: boolean | null;
+};
+type OfferMarketplaceNamespace = {
+    create: (params: OfferCreateParams) => Promise<OfferCreateResult>;
+    cancel: (params: OfferCancelParams) => Promise<TransactionResult>;
+    accept: (params: OfferAcceptParams) => Promise<OfferAcceptResult>;
+    status: (params: OfferStatusParams) => Promise<OfferStatus>;
+};
+type OfferNamespace = OfferMarketplaceNamespace & {
+    batch: BatchOfferNamespace;
+};
+
+type Hex = `0x${string}`;
+type RouterBuyParams = {
+    token: Address;
+    amountIn: AmountInput;
+    minAmountOut: AmountInput;
+    commands: `0x${string}`;
+    inputs: readonly `0x${string}`[];
+    recipient?: Address;
+    deadline?: IntegerInput;
+};
+type RouterSellParams = {
+    token: Address;
+    amountIn: AmountInput;
+    minAmountOut: AmountInput;
+    commands: `0x${string}`;
+    inputs: readonly `0x${string}`[];
+    recipient?: Address;
+    deadline?: IntegerInput;
+};
+type RouterSwapTokensParams = {
+    tokenIn: Address;
+    amountIn: AmountInput;
+    tokenOut: Address;
+    minAmountOut: AmountInput;
+    commands: `0x${string}`;
+    inputs: readonly `0x${string}`[];
+    recipient?: Address;
+    deadline?: IntegerInput;
+};
+type BuyRareParams = {
+    amountIn: AmountInput;
+    minAmountOut?: AmountInput;
+    slippageBps?: IntegerInput;
+    recipient?: Address;
+    deadline?: IntegerInput;
+};
+type TokenTradeRouteMode = 'auto' | 'local' | 'uniswap';
+type TokenTradeExecutionRoute = TokenTradeRouteMode | 'raw';
+type TokenTradeBaseParams = {
+    token: Address;
+    amountIn: AmountInput;
+    minAmountOut?: AmountInput;
+    slippageBps?: IntegerInput;
+    recipient?: Address;
+    deadline?: IntegerInput;
+};
+type TokenTradeQuoteParams = TokenTradeBaseParams & {
+    route?: TokenTradeRouteMode;
+};
+type TokenTradeRawRouteParams = Omit<TokenTradeBaseParams, 'minAmountOut' | 'slippageBps'> & {
+    route: 'raw';
+    minAmountOut: AmountInput;
+    commands: Hex;
+    inputs: readonly Hex[];
+};
+type BuyTokenParams = TokenTradeQuoteParams | TokenTradeRawRouteParams;
+type SellTokenParams = TokenTradeQuoteParams | TokenTradeRawRouteParams;
+type TokenTradeRouteSource = 'liquid-edition' | 'known-pool' | 'uniswap-api' | 'raw';
+type TokenTradeExecution = 'liquid-router' | 'uniswap-api' | 'raw-router';
+type TokenTradeQuoteBase = {
+    amountIn: bigint;
+    estimatedAmountOut: bigint;
+    minAmountOut: bigint;
+    tokenIn: Address;
+    tokenOut: Address;
+    inputDecimals: number;
+    outputDecimals: number;
+    slippageBps: number;
+    routeDescription: string;
+};
+type LiquidRouterTokenTradeQuote = {
+    routeSource: Extract<TokenTradeRouteSource, 'liquid-edition' | 'known-pool'>;
+    execution: 'liquid-router';
+    commands: `0x${string}`;
+    inputs: readonly `0x${string}`[];
+} & TokenTradeQuoteBase;
+type UniswapApiTokenTradeQuote = {
+    routeSource: 'uniswap-api';
+    execution: 'uniswap-api';
+} & TokenTradeQuoteBase;
+type TokenTradeQuote = LiquidRouterTokenTradeQuote | UniswapApiTokenTradeQuote;
+type TokenTradeResult = {
+    estimatedAmountOut: bigint;
+    minAmountOut: bigint;
+    routeSource: TokenTradeRouteSource;
+    execution: TokenTradeExecution;
+    commands?: Hex;
+    inputs?: readonly Hex[];
+    approvalTxHash?: Hex;
+    approvalResetTxHash?: Hex;
+} & TransactionResult;
+type BuyRareQuote = {
+    ethAmount: bigint;
+    rareAddress: Address;
+    estimatedRareOut: bigint;
+    minRareOut: bigint;
+    slippageBps: number;
+    commands: `0x${string}`;
+    inputs: readonly `0x${string}`[];
+};
+type BuyRareResult = {
+    estimatedRareOut: bigint;
+    minRareOut: bigint;
+    commands: `0x${string}`;
+    inputs: readonly `0x${string}`[];
+} & TransactionResult;
+type SwapNamespace = {
+    buy: (params: RouterBuyParams) => Promise<TransactionResult>;
+    sell: (params: RouterSellParams) => Promise<TransactionResult>;
+    swapTokens: (params: RouterSwapTokensParams) => Promise<TransactionResult>;
+    quoteBuyToken: (params: TokenTradeQuoteParams) => Promise<TokenTradeQuote>;
+    buyToken: (params: BuyTokenParams) => Promise<TokenTradeResult>;
+    quoteSellToken: (params: TokenTradeQuoteParams) => Promise<TokenTradeQuote>;
+    sellToken: (params: SellTokenParams) => Promise<TokenTradeResult>;
+    quoteBuyRare: (params: BuyRareParams) => Promise<BuyRareQuote>;
+    buyRare: (params: BuyRareParams) => Promise<BuyRareResult>;
+};
+
+type TokenContractInfo = {
     contract: Address;
     chain: SupportedChain;
     name: string;
     symbol: string;
-    totalSupply: bigint;
-}
-interface TokenInfo {
+    totalSupply: bigint | null;
+};
+type TokenInfo = {
     contract: Address;
     tokenId: bigint;
     owner: Address;
     tokenUri: string;
-}
-interface RareClient {
-    chain: SupportedChain;
-    chainId: number;
-    contracts: {
-        factory: Address;
-        auction: Address;
-    };
-    deploy: {
-        erc721(params: DeployErc721Params): Promise<DeployErc721Result>;
-    };
-    mint: {
-        mintTo(params: MintToParams): Promise<MintToResult>;
-    };
-    auction: {
-        create(params: AuctionCreateParams): Promise<TransactionResult & {
-            approvalTxHash?: Hash;
-        }>;
-        bid(params: AuctionBidParams): Promise<TransactionResult>;
-        settle(params: AuctionSettleParams): Promise<TransactionResult>;
-        cancel(params: AuctionCancelParams): Promise<TransactionResult>;
-        getStatus(params: AuctionStatusParams): Promise<AuctionStatus>;
-    };
-    offer: {
-        create(params: OfferCreateParams): Promise<TransactionResult>;
-        cancel(params: OfferCancelParams): Promise<TransactionResult>;
-        accept(params: OfferAcceptParams): Promise<TransactionResult>;
-        getStatus(params: OfferStatusParams): Promise<OfferStatus>;
-    };
-    listing: {
-        create(params: ListingCreateParams): Promise<TransactionResult & {
-            approvalTxHash?: Hash;
-        }>;
-        cancel(params: ListingCancelParams): Promise<TransactionResult>;
-        buy(params: ListingBuyParams): Promise<TransactionResult>;
-        getStatus(params: ListingStatusParams): Promise<ListingStatus>;
-    };
-    search: {
-        nfts(params?: NftSearchParams): Promise<SearchPageResponse>;
-        collections(params?: CollectionSearchParams): Promise<SearchPageResponse>;
-    };
-    media: {
-        upload(buffer: Uint8Array, filename: string): Promise<NftMediaEntry>;
-        pinMetadata(opts: PinMetadataParams): Promise<string>;
-    };
-    import: {
-        erc721(params: ImportErc721Params): Promise<void>;
+};
+type TokenStatus = {
+    contract: TokenContractInfo;
+    token?: TokenInfo;
+};
+type TokenNamespace = {
+    status: (params: {
+        contract: Address;
+        tokenId?: IntegerInput;
+    }) => Promise<TokenStatus>;
+    getPrice: (symbol: string) => Promise<{
+        symbol: string;
+        priceUsd: number;
+        decimals: number;
+        chainId: number;
+        address: string;
+    }>;
+};
+
+type UtilsNamespace = {
+    tree: {
+        build: (params: BuildUtilsTreeParams) => UtilsTreeArtifact;
+        proof: (params: UtilsTreeProofParams) => UtilsTreeProofArtifact;
+        verify: (params: UtilsTreeProofVerifyParams) => boolean;
     };
-    token: {
-        getContractInfo(params: {
-            contract: Address;
-        }): Promise<TokenContractInfo>;
-        getTokenInfo(params: {
-            contract: Address;
-            tokenId: IntegerInput;
-        }): Promise<TokenInfo>;
+    merkle: {
+        proof: (params: UtilsMerkleProofParams) => UtilsMerkleProofArtifact;
     };
-}
-declare function createRareClient(config: RareClientConfig): RareClient;
+};
+
+/**
+ * Configuration for {@link createRareClient}.
+ */
+type RareClientConfig = {
+    /**
+     * Viem public client with an explicit supported chain. The RARE SDK uses this
+     * chain for every read and write on the returned client.
+     */
+    publicClient: PublicClient;
+    /**
+     * Optional viem wallet client for contract writes and signed flows.
+     */
+    walletClient?: WalletClient;
+    /**
+     * Optional account address used by SDK flows that need a default owner or
+     * sender when the wallet client does not expose an account.
+     */
+    account?: Address;
+    /**
+     * Optional Rare API base URL. Defaults to the production Rare API.
+     */
+    apiBaseUrl?: string;
+    /**
+     * Optional fetch implementation for API-backed SDK methods.
+     */
+    apiFetch?: typeof fetch;
+};
+type RareClientNftSearchParams = Omit<NftSearchParams, 'chainId'>;
+type RareClientCollectionSearchParams = Omit<CollectionSearchParams, 'chainId'>;
+type RareClientEventSearchParams = Omit<EventSearchParams, 'chain' | 'chainId'>;
+type RareClientNftGetParams = Omit<NftIdentityParams, 'chain' | 'chainId'>;
+type RareClientContracts = {
+    factory: Address;
+    auction: Address;
+    sovereignFactory?: Address;
+    lazySovereignFactory?: Address;
+    rareMinter?: Address;
+    lazyBatchMintFactory?: Address;
+    batchListing?: Address;
+    batchOfferCreator?: Address;
+    batchAuctionHouse?: Address;
+    marketplaceSettings?: Address;
+    erc20ApprovalManager?: Address;
+    erc721ApprovalManager?: Address;
+    liquidFactory?: Address;
+    swapRouter?: Address;
+    v4Quoter?: Address;
+};
+type SearchNamespace = {
+    nfts: (params?: RareClientNftSearchParams) => Promise<SearchPageResponse<Nft>>;
+    collections: (params?: RareClientCollectionSearchParams) => Promise<SearchPageResponse<Collection>>;
+    events: (params: RareClientEventSearchParams) => Promise<SearchPageResponse<NftEvent>>;
+};
+type NftNamespace = {
+    get: (params: RareClientNftGetParams) => Promise<Nft>;
+};
+type UserNamespace = {
+    get: (address: string) => Promise<UserProfile>;
+};
+type MediaNamespace = {
+    upload: (buffer: Uint8Array, filename: string) => Promise<NftMediaEntry>;
+    pinMetadata: (opts: PinMetadataParams) => Promise<string>;
+};
+type ImportNamespace = {
+    erc721: (params: ImportErc721Params) => Promise<void>;
+};
+type CurrencyNamespace = {
+    list: () => CurrencyInfo[];
+    resolve: (input: CurrencyInput) => ResolvedCurrency;
+    resolveDecimals: (input: CurrencyInput) => Promise<ResolvedCurrencyWithDecimals>;
+};
+/**
+ * Chain-bound RARE SDK surface returned by {@link createRareClient}.
+ */
+type RareClient = {
+    /**
+     * Supported RARE chain inferred from the viem public client.
+     */
+    chain: SupportedChain;
+    /**
+     * Numeric chain ID for {@link chain}.
+     */
+    chainId: number;
+    /**
+     * RARE contract addresses available on the client chain.
+     */
+    contracts: RareClientContracts;
+    liquidEdition: LiquidEditionNamespace;
+    swap: SwapNamespace;
+    auction: AuctionNamespace;
+    offer: OfferNamespace;
+    listing: ListingNamespace;
+    utils: UtilsNamespace;
+    search: SearchNamespace;
+    nft: NftNamespace;
+    collection: CollectionNamespace;
+    user: UserNamespace;
+    media: MediaNamespace;
+    import: ImportNamespace;
+    token: TokenNamespace;
+    currency: CurrencyNamespace;
+};
 
-declare const factoryAbi: readonly [{
-    readonly type: "constructor";
-    readonly inputs: readonly [{
-        readonly name: "_sovereignBatchMintImplementation";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "createSovereignBatchMint";
-    readonly inputs: readonly [{
-        readonly name: "_name";
-        readonly type: "string";
-        readonly internalType: "string";
-    }, {
-        readonly name: "_symbol";
-        readonly type: "string";
-        readonly internalType: "string";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "createSovereignBatchMint";
-    readonly inputs: readonly [{
-        readonly name: "_name";
-        readonly type: "string";
-        readonly internalType: "string";
-    }, {
-        readonly name: "_symbol";
-        readonly type: "string";
-        readonly internalType: "string";
-    }, {
-        readonly name: "_maxTokens";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "owner";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "renounceOwnership";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setSovereignBatchMint";
-    readonly inputs: readonly [{
-        readonly name: "_sovereignNFT";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "sovereignNFT";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "transferOwnership";
-    readonly inputs: readonly [{
-        readonly name: "newOwner";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "event";
-    readonly name: "OwnershipTransferred";
-    readonly inputs: readonly [{
-        readonly name: "previousOwner";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "newOwner";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "SovereignBatchMintCreated";
-    readonly inputs: readonly [{
-        readonly name: "contractAddress";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "owner";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }];
-    readonly anonymous: false;
-}];
+/**
+ * Creates a chain-bound RARE SDK client from viem clients.
+ *
+ * The returned client derives its RARE network from `config.publicClient.chain`.
+ * Read-only namespaces such as `search`, `nft`, `collection.get`, `token`,
+ * and `currency` only require a public client. Write flows such as minting,
+ * listings, offers, auctions, imports, releases, and swaps require a wallet
+ * client and may also use `config.account` when the viem wallet client does
+ * not expose one directly.
+ *
+ * Create a separate RareClient for each chain you want to read or write. SDK
+ * methods intentionally reject per-call `chain` or `chainId` overrides when
+ * the client already knows its chain.
+ *
+ * See the generated [SDK Client Methods](/sdk/client-methods) page for the
+ * flat list of callable `rare.*` methods exposed by the returned client.
+ *
+ * @example
+ * ```ts
+ * import { createPublicClient, createWalletClient, http } from 'viem';
+ * import { privateKeyToAccount } from 'viem/accounts';
+ * import { sepolia } from 'viem/chains';
+ * import { createRareClient } from '@rareprotocol/rare-cli/client';
+ *
+ * const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
+ * const publicClient = createPublicClient({
+ *   chain: sepolia,
+ *   transport: http(process.env.RPC_URL),
+ * });
+ * const walletClient = createWalletClient({
+ *   account,
+ *   chain: sepolia,
+ *   transport: http(process.env.RPC_URL),
+ * });
+ *
+ * const rare = createRareClient({ publicClient, walletClient });
+ *
+ * const nfts = await rare.search.nfts({ query: 'portrait', perPage: 10 });
+ * const token = await rare.nft.get({
+ *   contract: '0x...',
+ *   tokenId: '1',
+ * });
+ * ```
+ */
+declare function createRareClient(config: RareClientConfig): RareClient;
 
-declare const auctionAbi: readonly [{
-    readonly type: "function";
-    readonly name: "COLDIE_AUCTION";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bytes32";
-        readonly internalType: "bytes32";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "NO_AUCTION";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bytes32";
-        readonly internalType: "bytes32";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "SCHEDULED_AUCTION";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bytes32";
-        readonly internalType: "bytes32";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "acceptOffer";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_splitAddresses";
-        readonly type: "address[]";
-        readonly internalType: "address payable[]";
-    }, {
-        readonly name: "_splitRatios";
-        readonly type: "uint8[]";
-        readonly internalType: "uint8[]";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "approvedTokenRegistry";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "contract IApprovedTokenRegistry";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "auctionBids";
-    readonly inputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "bidder";
-        readonly type: "address";
-        readonly internalType: "address payable";
-    }, {
-        readonly name: "currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "amount";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "marketplaceFee";
-        readonly type: "uint8";
-        readonly internalType: "uint8";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "auctionLengthExtension";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "bid";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "payable";
-}, {
-    readonly type: "function";
-    readonly name: "buy";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "payable";
-}, {
-    readonly type: "function";
-    readonly name: "cancelAuction";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "cancelOffer";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "configureAuction";
-    readonly inputs: readonly [{
-        readonly name: "_auctionType";
-        readonly type: "bytes32";
-        readonly internalType: "bytes32";
-    }, {
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_startingAmount";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_lengthOfAuction";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_startTime";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_splitAddresses";
-        readonly type: "address[]";
-        readonly internalType: "address payable[]";
-    }, {
-        readonly name: "_splitRatios";
-        readonly type: "uint8[]";
-        readonly internalType: "uint8[]";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "convertOfferToAuction";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_lengthOfAuction";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_splitAddresses";
-        readonly type: "address[]";
-        readonly internalType: "address payable[]";
-    }, {
-        readonly name: "_splitRatios";
-        readonly type: "uint8[]";
-        readonly internalType: "uint8[]";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "getAuctionDetails";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "";
-        readonly type: "bytes32";
-        readonly internalType: "bytes32";
-    }, {
-        readonly name: "";
-        readonly type: "address[]";
-        readonly internalType: "address payable[]";
-    }, {
-        readonly name: "";
-        readonly type: "uint8[]";
-        readonly internalType: "uint8[]";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "getSalePrice";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_target";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "";
-        readonly type: "address[]";
-        readonly internalType: "address payable[]";
-    }, {
-        readonly name: "";
-        readonly type: "uint8[]";
-        readonly internalType: "uint8[]";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "initialize";
-    readonly inputs: readonly [{
-        readonly name: "_marketplaceSettings";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_royaltyRegistry";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_royaltyEngine";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_superRareMarketplace";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_superRareAuctionHouse";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_spaceOperatorRegistry";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_approvedTokenRegistry";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_payments";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_stakingRegistry";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_networkBeneficiary";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "marketplaceSettings";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "contract IMarketplaceSettings";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "maxAuctionLength";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "minimumBidIncreasePercentage";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint8";
-        readonly internalType: "uint8";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "networkBeneficiary";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "offer";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_convertible";
-        readonly type: "bool";
-        readonly internalType: "bool";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "payable";
-}, {
-    readonly type: "function";
-    readonly name: "offerCancelationDelay";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "owner";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "payments";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "contract IPayments";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "removeSalePrice";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_target";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "renounceOwnership";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "royaltyEngine";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "contract IRoyaltyEngineV1";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "royaltyRegistry";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "contract IRoyaltyRegistry";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "setApprovedTokenRegistry";
-    readonly inputs: readonly [{
-        readonly name: "_approvedTokenRegistry";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setAuctionLengthExtension";
-    readonly inputs: readonly [{
-        readonly name: "_auctionLengthExtension";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setMarketplaceSettings";
-    readonly inputs: readonly [{
-        readonly name: "_marketplaceSettings";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setMaxAuctionLength";
-    readonly inputs: readonly [{
-        readonly name: "_maxAuctionLength";
-        readonly type: "uint8";
-        readonly internalType: "uint8";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setMinimumBidIncreasePercentage";
-    readonly inputs: readonly [{
-        readonly name: "_minimumBidIncreasePercentage";
-        readonly type: "uint8";
-        readonly internalType: "uint8";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setNetworkBeneficiary";
-    readonly inputs: readonly [{
-        readonly name: "_networkBeneficiary";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setOfferCancelationDelay";
-    readonly inputs: readonly [{
-        readonly name: "_offerCancelationDelay";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setPayments";
-    readonly inputs: readonly [{
-        readonly name: "_payments";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setRoyaltyEngine";
-    readonly inputs: readonly [{
-        readonly name: "_royaltyEngine";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setRoyaltyRegistry";
-    readonly inputs: readonly [{
-        readonly name: "_royaltyRegistry";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setSalePrice";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_listPrice";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_target";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_splitAddresses";
-        readonly type: "address[]";
-        readonly internalType: "address payable[]";
-    }, {
-        readonly name: "_splitRatios";
-        readonly type: "uint8[]";
-        readonly internalType: "uint8[]";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setSpaceOperatorRegistry";
-    readonly inputs: readonly [{
-        readonly name: "_spaceOperatorRegistry";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setStakingRegistry";
-    readonly inputs: readonly [{
-        readonly name: "_stakingRegistry";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setSuperRareAuctionHouse";
-    readonly inputs: readonly [{
-        readonly name: "_superRareAuctionHouse";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "setSuperRareMarketplace";
-    readonly inputs: readonly [{
-        readonly name: "_superRareMarketplace";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "settleAuction";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "spaceOperatorRegistry";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "contract ISpaceOperatorRegistry";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "stakingRegistry";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "superRareAuctionHouse";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "superRareMarketplace";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "tokenAuctions";
-    readonly inputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "auctionCreator";
-        readonly type: "address";
-        readonly internalType: "address payable";
-    }, {
-        readonly name: "creationBlock";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "startingTime";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "lengthOfAuction";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "minimumBid";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "auctionType";
-        readonly type: "bytes32";
-        readonly internalType: "bytes32";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "tokenCurrentOffers";
-    readonly inputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "buyer";
-        readonly type: "address";
-        readonly internalType: "address payable";
-    }, {
-        readonly name: "amount";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "timestamp";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "marketplaceFee";
-        readonly type: "uint8";
-        readonly internalType: "uint8";
-    }, {
-        readonly name: "convertible";
-        readonly type: "bool";
-        readonly internalType: "bool";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "tokenSalePrices";
-    readonly inputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "seller";
-        readonly type: "address";
-        readonly internalType: "address payable";
-    }, {
-        readonly name: "currencyAddress";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "amount";
-        readonly type: "uint256";
-        readonly internalType: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "transferOwnership";
-    readonly inputs: readonly [{
-        readonly name: "newOwner";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "event";
-    readonly name: "AcceptOffer";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_bidder";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_seller";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly indexed: false;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_splitAddresses";
-        readonly type: "address[]";
-        readonly indexed: false;
-        readonly internalType: "address payable[]";
-    }, {
-        readonly name: "_splitRatios";
-        readonly type: "uint8[]";
-        readonly indexed: false;
-        readonly internalType: "uint8[]";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "AuctionBid";
-    readonly inputs: readonly [{
-        readonly name: "_contractAddress";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_bidder";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly indexed: true;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly indexed: false;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_startedAuction";
-        readonly type: "bool";
-        readonly indexed: false;
-        readonly internalType: "bool";
-    }, {
-        readonly name: "_newAuctionLength";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_previousBidder";
-        readonly type: "address";
-        readonly indexed: false;
-        readonly internalType: "address";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "AuctionSettled";
-    readonly inputs: readonly [{
-        readonly name: "_contractAddress";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_bidder";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_seller";
-        readonly type: "address";
-        readonly indexed: false;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly indexed: true;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly indexed: false;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "CancelAuction";
-    readonly inputs: readonly [{
-        readonly name: "_contractAddress";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly indexed: true;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_auctionCreator";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "CancelOffer";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_bidder";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "Initialized";
-    readonly inputs: readonly [{
-        readonly name: "version";
-        readonly type: "uint8";
-        readonly indexed: false;
-        readonly internalType: "uint8";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "NewAuction";
-    readonly inputs: readonly [{
-        readonly name: "_contractAddress";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly indexed: true;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_auctionCreator";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly indexed: false;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_startingTime";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_minimumBid";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_lengthOfAuction";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "OfferPlaced";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_bidder";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_convertible";
-        readonly type: "bool";
-        readonly indexed: false;
-        readonly internalType: "bool";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "OwnershipTransferred";
-    readonly inputs: readonly [{
-        readonly name: "previousOwner";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "newOwner";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "SetSalePrice";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_target";
-        readonly type: "address";
-        readonly indexed: false;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_splitRecipients";
-        readonly type: "address[]";
-        readonly indexed: false;
-        readonly internalType: "address payable[]";
-    }, {
-        readonly name: "_splitRatios";
-        readonly type: "uint8[]";
-        readonly indexed: false;
-        readonly internalType: "uint8[]";
-    }];
-    readonly anonymous: false;
-}, {
-    readonly type: "event";
-    readonly name: "Sold";
-    readonly inputs: readonly [{
-        readonly name: "_originContract";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_buyer";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_seller";
-        readonly type: "address";
-        readonly indexed: true;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_currencyAddress";
-        readonly type: "address";
-        readonly indexed: false;
-        readonly internalType: "address";
-    }, {
-        readonly name: "_amount";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }, {
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-        readonly indexed: false;
-        readonly internalType: "uint256";
-    }];
-    readonly anonymous: false;
-}];
+declare class NftApprovalRequiredError extends Error {
+    readonly nftAddress: Address;
+    readonly operator: Address;
+    constructor(params: {
+        nftAddress: Address;
+        operator: Address;
+    });
+}
 
-declare const tokenAbi: readonly [{
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "owner";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "approved";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly internalType: "uint256";
-        readonly name: "tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "Approval";
-    readonly type: "event";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "owner";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "operator";
-        readonly type: "address";
-    }, {
-        readonly indexed: false;
-        readonly internalType: "bool";
-        readonly name: "approved";
-        readonly type: "bool";
-    }];
-    readonly name: "ApprovalForAll";
-    readonly type: "event";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly internalType: "uint256";
-        readonly name: "fromTokenId";
-        readonly type: "uint256";
-    }, {
-        readonly indexed: false;
-        readonly internalType: "uint256";
-        readonly name: "toTokenId";
-        readonly type: "uint256";
-    }, {
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "fromAddress";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "toAddress";
-        readonly type: "address";
-    }];
-    readonly name: "ConsecutiveTransfer";
-    readonly type: "event";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "user";
-        readonly type: "address";
-    }];
-    readonly name: "ContractDisabled";
-    readonly type: "event";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "previousOwner";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "newOwner";
-        readonly type: "address";
-    }];
-    readonly name: "OwnershipTransferred";
-    readonly type: "event";
-}, {
-    readonly anonymous: false;
-    readonly inputs: readonly [{
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly internalType: "address";
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly indexed: true;
-        readonly internalType: "uint256";
-        readonly name: "tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "Transfer";
-    readonly type: "event";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "string";
-        readonly name: "_uri";
-        readonly type: "string";
-    }];
-    readonly name: "addNewToken";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "approve";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "owner";
-        readonly type: "address";
-    }];
-    readonly name: "balanceOf";
-    readonly outputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "baseURI";
-    readonly outputs: readonly [{
-        readonly internalType: "string";
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "string";
-        readonly name: "_baseURI";
-        readonly type: "string";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "_numberOfTokens";
-        readonly type: "uint256";
-    }];
-    readonly name: "batchMint";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "burn";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "calcIERC721CreatorInterfaceId";
-    readonly outputs: readonly [{
-        readonly internalType: "bytes4";
-        readonly name: "";
-        readonly type: "bytes4";
-    }];
-    readonly stateMutability: "pure";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "defaultRoyaltyPercentage";
-    readonly outputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "defaultRoyaltyReceiver";
-    readonly outputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "";
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "deleteToken";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "disableContract";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "disabled";
-    readonly outputs: readonly [{
-        readonly internalType: "bool";
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "getApproved";
-    readonly outputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "";
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "string";
-        readonly name: "_name";
-        readonly type: "string";
-    }, {
-        readonly internalType: "string";
-        readonly name: "_symbol";
-        readonly type: "string";
-    }, {
-        readonly internalType: "address";
-        readonly name: "_creator";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "_maxTokens";
-        readonly type: "uint256";
-    }];
-    readonly name: "init";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "owner";
-        readonly type: "address";
-    }, {
-        readonly internalType: "address";
-        readonly name: "operator";
-        readonly type: "address";
-    }];
-    readonly name: "isApprovedForAll";
-    readonly outputs: readonly [{
-        readonly internalType: "bool";
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "maxTokens";
-    readonly outputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "string";
-        readonly name: "_uri";
-        readonly type: "string";
-    }, {
-        readonly internalType: "address";
-        readonly name: "_receiver";
-        readonly type: "address";
-    }, {
-        readonly internalType: "address";
-        readonly name: "_royaltyReceiver";
-        readonly type: "address";
-    }];
-    readonly name: "mintTo";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "name";
-    readonly outputs: readonly [{
-        readonly internalType: "string";
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "owner";
-    readonly outputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "";
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "ownerOf";
-    readonly outputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "";
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "renounceOwnership";
-    readonly outputs: readonly [];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "_salePrice";
-        readonly type: "uint256";
-    }];
-    readonly name: "royaltyInfo";
-    readonly outputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "receiver";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "royaltyAmount";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly internalType: "address";
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "safeTransferFrom";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly internalType: "address";
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "tokenId";
-        readonly type: "uint256";
-    }, {
-        readonly internalType: "bytes";
-        readonly name: "_data";
-        readonly type: "bytes";
-    }];
-    readonly name: "safeTransferFrom";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "operator";
-        readonly type: "address";
-    }, {
-        readonly internalType: "bool";
-        readonly name: "approved";
-        readonly type: "bool";
-    }];
-    readonly name: "setApprovalForAll";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "_receiver";
-        readonly type: "address";
-    }];
-    readonly name: "setDefaultRoyaltyReceiver";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "_receiver";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "setRoyaltyReceiverForToken";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "bytes4";
-        readonly name: "interfaceId";
-        readonly type: "bytes4";
-    }];
-    readonly name: "supportsInterface";
-    readonly outputs: readonly [{
-        readonly internalType: "bool";
-        readonly name: "";
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "symbol";
-    readonly outputs: readonly [{
-        readonly internalType: "string";
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "index";
-        readonly type: "uint256";
-    }];
-    readonly name: "tokenByIndex";
-    readonly outputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly name: "tokenCreator";
-    readonly outputs: readonly [{
-        readonly internalType: "address payable";
-        readonly name: "";
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "owner";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "index";
-        readonly type: "uint256";
-    }];
-    readonly name: "tokenOfOwnerByIndex";
-    readonly outputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "_tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "tokenURI";
-    readonly outputs: readonly [{
-        readonly internalType: "string";
-        readonly name: "";
-        readonly type: "string";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [];
-    readonly name: "totalSupply";
-    readonly outputs: readonly [{
-        readonly internalType: "uint256";
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "from";
-        readonly type: "address";
-    }, {
-        readonly internalType: "address";
-        readonly name: "to";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "tokenId";
-        readonly type: "uint256";
-    }];
-    readonly name: "transferFrom";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "";
-        readonly type: "address";
-    }];
-    readonly name: "transferOwnership";
-    readonly outputs: readonly [];
-    readonly stateMutability: "view";
-    readonly type: "function";
-}];
+declare class PaymentApprovalRequiredError extends Error {
+    readonly requiredAmount: bigint;
+    readonly spenderAddress: Address;
+    constructor(params: {
+        requiredAmount: bigint;
+        spenderAddress: Address;
+    });
+}
 
-export { type CollectionSearchParams, type ImportErc721Params, type NftAttribute, type NftMediaEntry, type NftSearchParams, type PinMetadataParams, type RareClient, type RareClientConfig, type SearchPageResponse, type SupportedChain, auctionAbi, chainIds, contractAddresses, createRareClient, factoryAbi, getContractAddresses, isSupportedChain, tokenAbi, viemChains };
+export { AmountInput, type AuctionBidParams, type AuctionBidResult, type AuctionCancelParams, type AuctionCreateParams, type AuctionCreateResult, type AuctionMarketplaceNamespace, type AuctionNamespace, type AuctionSettleParams, type AuctionStatus, type AuctionStatusParams, type BatchAuctionBidParams, type BatchAuctionBidResult, type BatchAuctionCancelParams, type BatchAuctionCancelResult, type BatchAuctionCreateParams, type BatchAuctionCreateResult, type BatchAuctionNamespace, type BatchAuctionRootSource, type BatchAuctionRootsParams, type BatchAuctionSettleParams, type BatchAuctionSettleResult, type BatchAuctionStatus, type BatchAuctionStatusParams, BatchListingNamespace, type BatchOfferAcceptParams, type BatchOfferAcceptResult, type BatchOfferCreateParams, type BatchOfferCreateResult, type BatchOfferNamespace, type BatchOfferRevokeParams, type BatchOfferRevokeResult, type BatchOfferRootSource, type BatchOfferStatus, type BatchOfferStatusParams, BuildUtilsTreeParams, type BuyRareParams, type BuyRareQuote, type BuyRareResult, type BuyTokenParams, type Collection, type CollectionDeployNamespace, type CollectionLockBaseUriParams, type CollectionLockBaseUriResult, type CollectionMintBatchParams, type CollectionMintBatchResult, type CollectionMintConfigParams, type CollectionMintConfigResult, type CollectionMintParams, type CollectionMintResult, type CollectionNamespace, type CollectionPrepareLazyMintParams, type CollectionPrepareLazyMintResult, type CollectionRoyaltyInfoParams, type CollectionRoyaltyInfoResult, type CollectionSearchParams, type CollectionSetDefaultRoyaltyPercentageParams, type CollectionSetDefaultRoyaltyPercentageResult, type CollectionSetDefaultRoyaltyReceiverParams, type CollectionSetDefaultRoyaltyReceiverResult, type CollectionSetTokenRoyaltyReceiverParams, type CollectionSetTokenRoyaltyReceiverResult, type CollectionTokenCreatorParams, type CollectionTokenCreatorResult, type CollectionUpdateBaseUriParams, type CollectionUpdateBaseUriResult, type CollectionUpdateTokenUriParams, type CollectionUpdateTokenUriResult, CurrencyInfo, CurrencyInput, type CurrencyNamespace, type CurvePresetKey, type DeployErc721Params, type DeployErc721Result, type DeployLazyBatchMintParams, type DeployLazyBatchMintResult, type DeployLazyErc721Params, type DeployLazyErc721Result, type DeployLiquidEditionParams, type DeployLiquidEditionResult, type EventSearchParams, type GeneratePresetCurvesParams, type GeneratePresetCurvesResult, type ImportErc721Params, type ImportNamespace, IntegerInput, type LiquidCurvePreview, type LiquidCurveSegment, type LiquidEditionCurrentPrice, type LiquidEditionMarketState, type LiquidEditionNamespace, type LiquidEditionPoolInfo, type LiquidEditionPoolKey, type LiquidEditionTelemetry, type LiquidFactoryConfig, type LiquidRouterTokenTradeQuote, type ListingBuyParams, type ListingBuyResult, type ListingCancelParams, type ListingCreateParams, type ListingCreateResult, type ListingMarketplaceNamespace, type ListingNamespace, type ListingStatus, type ListingStatusParams, type MediaNamespace, type Nft, NftApprovalRequiredError, type NftAttribute, type NftEvent, type NftMediaEntry, type NftNamespace, type NftSearchParams, type OfferAcceptParams, type OfferAcceptResult, type OfferCancelParams, type OfferCreateParams, type OfferCreateResult, type OfferMarketplaceNamespace, type OfferNamespace, type OfferStatus, type OfferStatusParams, type Pagination, PaymentApprovalRequiredError, type PinMetadataParams, type RareClient, type RareClientCollectionSearchParams, type RareClientConfig, type RareClientContracts, type RareClientEventSearchParams, type RareClientNftGetParams, type RareClientNftSearchParams, type ReleaseAllowlistArtifact, type ReleaseAllowlistConfig, type ReleaseAllowlistInputFormat, type ReleaseAllowlistNamespace, type ReleaseAllowlistWalletProof, type ReleaseConfigureParams, type ReleaseConfigureResult, type ReleaseLimitConfig, type ReleaseLimitsNamespace, type ReleaseMintDirectSaleParams, type ReleaseMintDirectSaleResult, type ReleaseNamespace, type ReleaseSetAllowlistConfigParams, type ReleaseSetAllowlistConfigResult, type ReleaseSetLimitParams, type ReleaseSetLimitResult, type ReleaseStatus, type ReleaseStatusParams, ResolvedCurrency, ResolvedCurrencyWithDecimals, type RouterBuyParams, type RouterSellParams, type RouterSwapTokensParams, type SearchNamespace, type SearchPageResponse, type SellTokenParams, type SetLiquidEditionRenderContractParams, type SetLiquidEditionRenderContractResult, type SwapNamespace, TimestampInput, type TokenContractInfo, type TokenInfo, type TokenNamespace, type TokenStatus, type TokenTradeBaseParams, type TokenTradeExecution, type TokenTradeExecutionRoute, type TokenTradeQuote, type TokenTradeQuoteBase, type TokenTradeQuoteParams, type TokenTradeRawRouteParams, type TokenTradeResult, type TokenTradeRouteMode, type TokenTradeRouteSource, TransactionResult, type UniswapApiTokenTradeQuote, type UserNamespace, type UserProfile, UtilsMerkleProofArtifact, UtilsMerkleProofParams, type UtilsNamespace, UtilsTreeArtifact, UtilsTreeProofArtifact, UtilsTreeProofParams, UtilsTreeProofVerifyParams, type ValidateLiquidCurvesParams, createRareClient };