@0xsequence/marketplace-sdk 0.0.1 → 0.1.0

package/dist/react/hooks/index.d.ts

@@ -1,174 +1,1393 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
 import * as _0xsequence_indexer from '@0xsequence/indexer';
-import { MetadataOptions, Page } from '@0xsequence/indexer';
-import { C as ChainId, Q as QueryArg } from '../../types-BrAQ8-w4.js';
+import { Page, SortOrder } from '@0xsequence/indexer';
+import * as _0xsequence_network from '@0xsequence/network';
+import { Q as QueryArgSchema, c as ChainId } from '../../types-BzZVURNL.js';
 import { S as SdkConfig } from '../../sdk-config-xWkdBdrL.js';
+import { Hex, Address } from 'viem';
+import { z } from 'zod';
+import { P as PropertyType, M as MarketplaceKind, b as OrderSide, w as Currency, o as CollectibleOrder, aC as GetCollectibleHighestOfferReturn, i as Page$1, aW as ListCollectiblesReturn, S as SortOrder$1, aK as ListCollectibleOffersReturn, aE as GetCollectibleLowestListingReturn, z as Step, D as CreateReq, aP as GenerateListingTransactionArgs, aR as GenerateOfferTransactionArgs, C as ContractType } from '../../marketplace.gen-Ceofb9Cs.js';
 import * as _0xsequence_metadata from '@0xsequence/metadata';
-import { w as Currency, o as CollectibleOrder, aB as GetCollectibleHighestOfferArgs, aC as GetCollectibleHighestOfferReturn, aV as ListCollectiblesArgs, i as Page$1, aW as ListCollectiblesReturn, ax as ListOffersForCollectibleArgs, aK as ListCollectibleOffersReturn, aD as GetCollectibleLowestListingArgs, aE as GetCollectibleLowestListingReturn, z as Step, D as CreateReq, aP as GenerateListingTransactionArgs, aR as GenerateOfferTransactionArgs, C as ContractType } from '../../marketplace.gen-Ceofb9Cs.js';
 import { c as getMarketplaceClient, S as SequenceMarketplace } from '../../services-BIwQ1C1c.js';
-import { M as MarketplaceConfig } from '../../marketplace-config-DZbtyrma.js';
-import { Hex, Address } from 'viem';
-import '@0xsequence/network';
+import { M as MarketplaceConfig } from '../../marketplace-config-Bbxl-uKX.js';
 
-type UseBalanceOfCollectibleArgs = {
+declare const fetchBalanceOfCollectibleSchema: z.ZodObject<{
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    collectableId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodString>;
+    userAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    collectableId: string;
+    userAddress: `0x${string}`;
+}, {
+    chainId: string | number;
     collectionAddress: string;
+    collectableId: string | number;
     userAddress: string;
-    tokenId: string;
-    chainId: ChainId;
-} & QueryArg;
-declare const balanceOfCollectibleOptions: (args: UseBalanceOfCollectibleArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<_0xsequence_indexer.TokenBalance, Error, _0xsequence_indexer.TokenBalance, ("collectable" | "details" | "userBalances" | SdkConfig | UseBalanceOfCollectibleArgs)[]>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<_0xsequence_indexer.TokenBalance, ("collectable" | "details" | "userBalances" | SdkConfig | UseBalanceOfCollectibleArgs)[], never> | undefined;
+}>;
+type FetchBalanceOfCollectibleArgs = z.input<typeof fetchBalanceOfCollectibleSchema>;
+interface BalanceOfCollectibleOptions extends Omit<FetchBalanceOfCollectibleArgs, 'userAddress'> {
+    userAddress?: Hex;
+    query?: z.infer<typeof QueryArgSchema>;
+}
+declare const balanceOfCollectibleOptions: (args: BalanceOfCollectibleOptions, config: SdkConfig) => _tanstack_react_query.UseQueryOptions<_0xsequence_indexer.TokenBalance, Error, _0xsequence_indexer.TokenBalance, ("collectable" | "details" | "userBalances" | SdkConfig | BalanceOfCollectibleOptions)[]> & {
+    initialData?: _0xsequence_indexer.TokenBalance | _tanstack_react_query.InitialDataFunction<_0xsequence_indexer.TokenBalance> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("collectable" | "details" | "userBalances" | SdkConfig | UseBalanceOfCollectibleArgs)[], _0xsequence_indexer.TokenBalance>;
+    queryKey: _tanstack_react_query.DataTag<("collectable" | "details" | "userBalances" | SdkConfig | BalanceOfCollectibleOptions)[], _0xsequence_indexer.TokenBalance>;
 };
-declare const useBalanceOfCollectible: (args: UseBalanceOfCollectibleArgs) => _tanstack_react_query.UseQueryResult<_0xsequence_indexer.TokenBalance, Error>;
+declare const useBalanceOfCollectible: (args: BalanceOfCollectibleOptions) => _tanstack_react_query.UseQueryResult<_0xsequence_indexer.TokenBalance, Error>;
 
-type UseCollectibleArgs = {
-    chainId: ChainId;
+declare const UseCountOfCollectableSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, {
+    filter: z.ZodObject<{
+        includeEmpty: z.ZodBoolean;
+        searchText: z.ZodOptional<z.ZodString>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodNativeEnum<typeof PropertyType>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            values: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }, {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }>, "many">>;
+        marketplaces: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof MarketplaceKind>, "many">>;
+        inAccounts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        notInAccounts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        ordersCreatedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        ordersNotCreatedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        includeEmpty: boolean;
+        searchText?: string | undefined;
+        properties?: {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }[] | undefined;
+        marketplaces?: MarketplaceKind[] | undefined;
+        inAccounts?: string[] | undefined;
+        notInAccounts?: string[] | undefined;
+        ordersCreatedBy?: string[] | undefined;
+        ordersNotCreatedBy?: string[] | undefined;
+    }, {
+        includeEmpty: boolean;
+        searchText?: string | undefined;
+        properties?: {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }[] | undefined;
+        marketplaces?: MarketplaceKind[] | undefined;
+        inAccounts?: string[] | undefined;
+        notInAccounts?: string[] | undefined;
+        ordersCreatedBy?: string[] | undefined;
+        ordersNotCreatedBy?: string[] | undefined;
+    }>;
+    side: z.ZodNativeEnum<typeof OrderSide>;
+}>, "strip", z.ZodTypeAny, {
+    filter: {
+        includeEmpty: boolean;
+        searchText?: string | undefined;
+        properties?: {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }[] | undefined;
+        marketplaces?: MarketplaceKind[] | undefined;
+        inAccounts?: string[] | undefined;
+        notInAccounts?: string[] | undefined;
+        ordersCreatedBy?: string[] | undefined;
+        ordersNotCreatedBy?: string[] | undefined;
+    };
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    side: OrderSide;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    filter: {
+        includeEmpty: boolean;
+        searchText?: string | undefined;
+        properties?: {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }[] | undefined;
+        marketplaces?: MarketplaceKind[] | undefined;
+        inAccounts?: string[] | undefined;
+        notInAccounts?: string[] | undefined;
+        ordersCreatedBy?: string[] | undefined;
+        ordersNotCreatedBy?: string[] | undefined;
+    };
+    chainId: string | number;
+    collectionAddress: string;
+    side: OrderSide;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, {
+    filter: z.ZodUndefined;
+    side: z.ZodUndefined;
+}>, "strip", z.ZodTypeAny, {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    filter?: undefined;
+    side?: undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
+    collectionAddress: string;
+    filter?: undefined;
+    side?: undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>]>;
+type UseCountOfCollectablesArgs = z.infer<typeof UseCountOfCollectableSchema>;
+type UseContOfCollectableReturn = Awaited<ReturnType<typeof fetchCountOfCollectables>>;
+declare const fetchCountOfCollectables: (args: UseCountOfCollectablesArgs, config: SdkConfig) => Promise<number>;
+declare const countOfCollectablesOptions: (args: UseCountOfCollectablesArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<number, Error, number, ("collectable" | "counts" | {
+    filter: {
+        includeEmpty: boolean;
+        searchText?: string | undefined;
+        properties?: {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }[] | undefined;
+        marketplaces?: MarketplaceKind[] | undefined;
+        inAccounts?: string[] | undefined;
+        notInAccounts?: string[] | undefined;
+        ordersCreatedBy?: string[] | undefined;
+        ordersNotCreatedBy?: string[] | undefined;
+    };
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    side: OrderSide;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+} | {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    filter?: undefined;
+    side?: undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+})[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<number, ("collectable" | "counts" | {
+        filter: {
+            includeEmpty: boolean;
+            searchText?: string | undefined;
+            properties?: {
+                type: PropertyType;
+                name: string;
+                values?: any[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+            }[] | undefined;
+            marketplaces?: MarketplaceKind[] | undefined;
+            inAccounts?: string[] | undefined;
+            notInAccounts?: string[] | undefined;
+            ordersCreatedBy?: string[] | undefined;
+            ordersNotCreatedBy?: string[] | undefined;
+        };
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        side: OrderSide;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    } | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        filter?: undefined;
+        side?: undefined;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], never> | undefined;
+} & {
+    queryKey: _tanstack_react_query.DataTag<("collectable" | "counts" | {
+        filter: {
+            includeEmpty: boolean;
+            searchText?: string | undefined;
+            properties?: {
+                type: PropertyType;
+                name: string;
+                values?: any[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+            }[] | undefined;
+            marketplaces?: MarketplaceKind[] | undefined;
+            inAccounts?: string[] | undefined;
+            notInAccounts?: string[] | undefined;
+            ordersCreatedBy?: string[] | undefined;
+            ordersNotCreatedBy?: string[] | undefined;
+        };
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        side: OrderSide;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    } | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        filter?: undefined;
+        side?: undefined;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], number>;
+};
+declare const useCountOfCollectables: (args: UseCountOfCollectablesArgs) => _tanstack_react_query.UseQueryResult<number, Error>;
+
+declare const UseCollectibleSchema: z.ZodObject<{
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    collectibleId: z.ZodString;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    collectibleId: string;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
     collectionAddress: string;
     collectibleId: string;
-} & QueryArg;
-type UseCollectibleReturn = ReturnType<typeof fetchCollectible>;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseCollectibleArgs = z.infer<typeof UseCollectibleSchema>;
+type UseCollectibleReturn = Awaited<ReturnType<typeof fetchCollectible>>;
 declare const fetchCollectible: (args: UseCollectibleArgs, config: SdkConfig) => Promise<_0xsequence_metadata.TokenMetadata>;
-declare const collectibleOptions: (args: UseCollectibleArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<_0xsequence_metadata.TokenMetadata, Error, _0xsequence_metadata.TokenMetadata, ("collectable" | "details" | SdkConfig | UseCollectibleArgs)[]>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<_0xsequence_metadata.TokenMetadata, ("collectable" | "details" | SdkConfig | UseCollectibleArgs)[], never> | undefined;
+declare const collectibleOptions: (args: UseCollectibleArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<_0xsequence_metadata.TokenMetadata, Error, _0xsequence_metadata.TokenMetadata, ("collectable" | "details" | SdkConfig | {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    collectibleId: string;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+})[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<_0xsequence_metadata.TokenMetadata, ("collectable" | "details" | SdkConfig | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        collectibleId: string;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], never> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("collectable" | "details" | SdkConfig | UseCollectibleArgs)[], _0xsequence_metadata.TokenMetadata>;
+    queryKey: _tanstack_react_query.DataTag<("collectable" | "details" | SdkConfig | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        collectibleId: string;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], _0xsequence_metadata.TokenMetadata>;
 };
 declare const useCollectible: (args: UseCollectibleArgs) => _tanstack_react_query.UseQueryResult<_0xsequence_metadata.TokenMetadata, Error>;
 
-type UseCollectionArgs = {
-    chainId: ChainId;
+declare const UseCollectionSchema: z.ZodObject<{
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
     collectionAddress: string;
-} & QueryArg;
-type UseCollectionReturn = ReturnType<typeof fetchCollection>;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseCollectionArgs = z.input<typeof UseCollectionSchema>;
+type UseCollectionReturn = Awaited<ReturnType<typeof fetchCollection>>;
 declare const fetchCollection: (args: UseCollectionArgs, config: SdkConfig) => Promise<_0xsequence_metadata.ContractInfo>;
-declare const collectionOptions: (args: UseCollectionArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<_0xsequence_metadata.ContractInfo, Error, _0xsequence_metadata.ContractInfo, ("collections" | "detail" | SdkConfig | UseCollectionArgs)[]>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<_0xsequence_metadata.ContractInfo, ("collections" | "detail" | SdkConfig | UseCollectionArgs)[], never> | undefined;
+declare const collectionOptions: (args: UseCollectionArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<_0xsequence_metadata.ContractInfo, Error, _0xsequence_metadata.ContractInfo, ("collections" | "detail" | SdkConfig | {
+    chainId: string | number;
+    collectionAddress: string;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+})[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<_0xsequence_metadata.ContractInfo, ("collections" | "detail" | SdkConfig | {
+        chainId: string | number;
+        collectionAddress: string;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], never> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("collections" | "detail" | SdkConfig | UseCollectionArgs)[], _0xsequence_metadata.ContractInfo>;
+    queryKey: _tanstack_react_query.DataTag<("collections" | "detail" | SdkConfig | {
+        chainId: string | number;
+        collectionAddress: string;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], _0xsequence_metadata.ContractInfo>;
 };
 declare const useCollection: (args: UseCollectionArgs) => _tanstack_react_query.UseQueryResult<_0xsequence_metadata.ContractInfo, Error>;
 
 declare function useConfig(): SdkConfig;
 
-type UseCurrenciesArgs = {
-    chainId: ChainId;
-    collectionAddress?: string;
-    includeNativeCurrency?: boolean;
-} & QueryArg;
-type UseCurrenciesReturn = ReturnType<typeof fetchCurrencies>;
+declare const UseCurrenciesArgsSchema: z.ZodObject<{
+    chainId: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, string, string | number>;
+    collectionAddress: z.ZodOptional<z.ZodEffects<z.ZodString, `0x${string}`, string>>;
+    includeNativeCurrency: z.ZodOptional<z.ZodBoolean>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    chainId: string;
+    collectionAddress?: `0x${string}` | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    includeNativeCurrency?: boolean | undefined;
+}, {
+    chainId: string | number;
+    collectionAddress?: string | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    includeNativeCurrency?: boolean | undefined;
+}>;
+type UseCurrenciesArgs = z.input<typeof UseCurrenciesArgsSchema>;
+type UseCurrenciesReturn = Awaited<ReturnType<typeof fetchCurrencies>>;
 declare const fetchCurrencies: (chainId: ChainId, config: SdkConfig) => Promise<Currency[]>;
-declare const currenciesOptions: (args: UseCurrenciesArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<Currency[], Error, Currency[], ChainId[]>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<Currency[], ChainId[], never> | undefined;
+declare const currenciesOptions: (args: UseCurrenciesArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<Currency[], Error, Currency[], (string | number)[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<Currency[], (string | number)[], never> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<ChainId[], Currency[]>;
+    queryKey: _tanstack_react_query.DataTag<(string | number)[], Currency[]>;
 };
 declare const useCurrencies: (args: UseCurrenciesArgs) => _tanstack_react_query.UseQueryResult<Currency[], Error>;
 
-type UseFiltersArgs = {
-    chainId: ChainId;
+declare const UseFiltersSchema: z.ZodObject<{
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
     collectionAddress: string;
-} & QueryArg;
-type UseFilterReturn = ReturnType<typeof fetchFilters>;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseFiltersArgs = z.infer<typeof UseFiltersSchema>;
+type UseFilterReturn = Awaited<ReturnType<typeof fetchFilters>>;
 declare const fetchFilters: (args: UseFiltersArgs, config: SdkConfig) => Promise<_0xsequence_metadata.PropertyFilter[]>;
-declare const filtersOptions: (args: UseFiltersArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<_0xsequence_metadata.PropertyFilter[], Error, _0xsequence_metadata.PropertyFilter[], ("filter" | "collectable" | SdkConfig | UseFiltersArgs)[]>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<_0xsequence_metadata.PropertyFilter[], ("filter" | "collectable" | SdkConfig | UseFiltersArgs)[], never> | undefined;
+declare const filtersOptions: (args: UseFiltersArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<_0xsequence_metadata.PropertyFilter[], Error, _0xsequence_metadata.PropertyFilter[], ("filter" | "collectable" | SdkConfig | {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+})[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<_0xsequence_metadata.PropertyFilter[], ("filter" | "collectable" | SdkConfig | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], never> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("filter" | "collectable" | SdkConfig | UseFiltersArgs)[], _0xsequence_metadata.PropertyFilter[]>;
+    queryKey: _tanstack_react_query.DataTag<("filter" | "collectable" | SdkConfig | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], _0xsequence_metadata.PropertyFilter[]>;
 };
 declare const useFilters: (args: UseFiltersArgs) => _tanstack_react_query.UseQueryResult<_0xsequence_metadata.PropertyFilter[], Error>;
 
-type UseFloorOrder = {
+declare const UseFloorOrderSchema: z.ZodObject<{
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
     chainId: string;
+    collectionAddress: `0x${string}`;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
     collectionAddress: string;
-};
-declare const floorOrderOptions: (args: UseFloorOrder, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<CollectibleOrder, Error, CollectibleOrder, ("collectable" | "floorOrders" | SdkConfig | UseFloorOrder)[]>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<CollectibleOrder, ("collectable" | "floorOrders" | SdkConfig | UseFloorOrder)[], never> | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseFloorOrderArgs = z.infer<typeof UseFloorOrderSchema>;
+type UseFloorOrderReturn = Awaited<ReturnType<typeof fetchFloorOrder>>;
+declare const fetchFloorOrder: (args: UseFloorOrderArgs, config: SdkConfig) => Promise<CollectibleOrder>;
+declare const floorOrderOptions: (args: UseFloorOrderArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<CollectibleOrder, Error, CollectibleOrder, ("collectable" | "floorOrders" | SdkConfig | {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+})[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<CollectibleOrder, ("collectable" | "floorOrders" | SdkConfig | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], never> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("collectable" | "floorOrders" | SdkConfig | UseFloorOrder)[], CollectibleOrder>;
+    queryKey: _tanstack_react_query.DataTag<("collectable" | "floorOrders" | SdkConfig | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], CollectibleOrder>;
 };
-declare const useFloorOrder: (args: UseFloorOrder) => _tanstack_react_query.UseQueryResult<CollectibleOrder, Error>;
+declare const useFloorOrder: (args: UseFloorOrderArgs) => _tanstack_react_query.UseQueryResult<CollectibleOrder, Error>;
 
-type UseHighestOfferArgs = Omit<GetCollectibleHighestOfferArgs, 'contractAddress'> & {
-    collectionAddress: string;
+declare const UseHighestOfferArgsSchema: z.ZodObject<z.objectUtil.extendShape<Omit<{
+    contractAddress: z.ZodString;
+    tokenId: z.ZodString;
+    filter: z.ZodOptional<z.ZodObject<{
+        createdBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        marketplace: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof MarketplaceKind>, "many">>;
+        currencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    }, {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    }>>;
+}, "contractAddress">, {
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}>, "strip", z.ZodTypeAny, {
     chainId: string;
-} & QueryArg;
-type UseHighestOfferReturn = ReturnType<typeof fetchHighestOffer>;
+    collectionAddress: `0x${string}`;
+    tokenId: string;
+    filter?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
+    collectionAddress: string;
+    tokenId: string;
+    filter?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseHighestOfferArgs = z.infer<typeof UseHighestOfferArgsSchema>;
+type UseHighestOfferReturn = Awaited<ReturnType<typeof fetchHighestOffer>>;
 declare const fetchHighestOffer: (args: UseHighestOfferArgs, config: SdkConfig) => Promise<GetCollectibleHighestOfferReturn>;
-declare const highestOfferOptions: (args: UseHighestOfferArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetCollectibleHighestOfferReturn, Error, GetCollectibleHighestOfferReturn, ("collectable" | "details" | "highestOffers" | SdkConfig | UseHighestOfferArgs)[]>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<GetCollectibleHighestOfferReturn, ("collectable" | "details" | "highestOffers" | SdkConfig | UseHighestOfferArgs)[], never> | undefined;
+declare const highestOfferOptions: (args: UseHighestOfferArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetCollectibleHighestOfferReturn, Error, GetCollectibleHighestOfferReturn, ("collectable" | "details" | "highestOffers" | SdkConfig | {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    tokenId: string;
+    filter?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+})[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<GetCollectibleHighestOfferReturn, ("collectable" | "details" | "highestOffers" | SdkConfig | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        tokenId: string;
+        filter?: {
+            currencies?: string[] | undefined;
+            marketplace?: MarketplaceKind[] | undefined;
+            createdBy?: string[] | undefined;
+        } | undefined;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], never> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("collectable" | "details" | "highestOffers" | SdkConfig | UseHighestOfferArgs)[], GetCollectibleHighestOfferReturn>;
+    queryKey: _tanstack_react_query.DataTag<("collectable" | "details" | "highestOffers" | SdkConfig | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        tokenId: string;
+        filter?: {
+            currencies?: string[] | undefined;
+            marketplace?: MarketplaceKind[] | undefined;
+            createdBy?: string[] | undefined;
+        } | undefined;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], GetCollectibleHighestOfferReturn>;
 };
 declare const useHighestOffer: (args: UseHighestOfferArgs) => _tanstack_react_query.UseQueryResult<GetCollectibleHighestOfferReturn, Error>;
 
-type UseTokenBalancesArgs = {
-    chainId: ChainId;
-    accountAddress?: string;
-    contractAddress?: string;
-    tokenId?: string;
-    includeMetadata?: boolean;
-    metadataOptions?: MetadataOptions;
-    includeCollectionTokens?: boolean;
-    page?: Page;
-} & QueryArg;
-type UseFetchTokenBalancesReturn = ReturnType<typeof fetchTokenBalances>;
-declare const fetchTokenBalances: (args: UseTokenBalancesArgs, page: Page, config: SdkConfig) => Promise<_0xsequence_indexer.GetTokenBalancesReturn>;
-declare const tokenBalancesOptions: (args: UseTokenBalancesArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseInfiniteQueryOptions<_0xsequence_indexer.GetTokenBalancesReturn, Error, _tanstack_react_query.InfiniteData<_0xsequence_indexer.GetTokenBalancesReturn, unknown>, _0xsequence_indexer.GetTokenBalancesReturn, ("balances" | "tokenBalances" | SdkConfig | UseTokenBalancesArgs)[], any>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<_0xsequence_indexer.GetTokenBalancesReturn, ("balances" | "tokenBalances" | SdkConfig | UseTokenBalancesArgs)[], any> | undefined;
+declare const metadataOptionsSchema: z.ZodObject<{
+    verifiedOnly: z.ZodOptional<z.ZodBoolean>;
+    unverifiedOnly: z.ZodOptional<z.ZodBoolean>;
+    includeContracts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    verifiedOnly?: boolean | undefined;
+    unverifiedOnly?: boolean | undefined;
+    includeContracts?: string[] | undefined;
+}, {
+    verifiedOnly?: boolean | undefined;
+    unverifiedOnly?: boolean | undefined;
+    includeContracts?: string[] | undefined;
+}>;
+declare const useListBalancesArgsSchema: z.ZodObject<{
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodNumber>;
+    accountAddress: z.ZodOptional<z.ZodEffects<z.ZodString, `0x${string}`, string>>;
+    contractAddress: z.ZodOptional<z.ZodEffects<z.ZodString, `0x${string}`, string>>;
+    tokenId: z.ZodOptional<z.ZodString>;
+    includeMetadata: z.ZodOptional<z.ZodBoolean>;
+    metadataOptions: z.ZodOptional<z.ZodObject<{
+        verifiedOnly: z.ZodOptional<z.ZodBoolean>;
+        unverifiedOnly: z.ZodOptional<z.ZodBoolean>;
+        includeContracts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        verifiedOnly?: boolean | undefined;
+        unverifiedOnly?: boolean | undefined;
+        includeContracts?: string[] | undefined;
+    }, {
+        verifiedOnly?: boolean | undefined;
+        unverifiedOnly?: boolean | undefined;
+        includeContracts?: string[] | undefined;
+    }>>;
+    includeCollectionTokens: z.ZodOptional<z.ZodBoolean>;
+    page: z.ZodOptional<z.ZodObject<{
+        page: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodString>;
+        before: z.ZodOptional<z.ZodAny>;
+        after: z.ZodOptional<z.ZodAny>;
+        sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            order: z.ZodNativeEnum<typeof SortOrder>;
+        }, "strip", z.ZodTypeAny, {
+            order: SortOrder;
+            column: string;
+        }, {
+            order: SortOrder;
+            column: string;
+        }>, "many">>;
+        pageSize: z.ZodOptional<z.ZodNumber>;
+        more: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        sort?: {
+            order: SortOrder;
+            column: string;
+        }[] | undefined;
+        page?: number | undefined;
+        column?: string | undefined;
+        pageSize?: number | undefined;
+        more?: boolean | undefined;
+        before?: any;
+        after?: any;
+    }, {
+        sort?: {
+            order: SortOrder;
+            column: string;
+        }[] | undefined;
+        page?: number | undefined;
+        column?: string | undefined;
+        pageSize?: number | undefined;
+        more?: boolean | undefined;
+        before?: any;
+        after?: any;
+    }>>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    page?: {
+        sort?: {
+            order: SortOrder;
+            column: string;
+        }[] | undefined;
+        page?: number | undefined;
+        column?: string | undefined;
+        pageSize?: number | undefined;
+        more?: boolean | undefined;
+        before?: any;
+        after?: any;
+    } | undefined;
+    tokenId?: string | undefined;
+    contractAddress?: `0x${string}` | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    accountAddress?: `0x${string}` | undefined;
+    includeMetadata?: boolean | undefined;
+    metadataOptions?: {
+        verifiedOnly?: boolean | undefined;
+        unverifiedOnly?: boolean | undefined;
+        includeContracts?: string[] | undefined;
+    } | undefined;
+    includeCollectionTokens?: boolean | undefined;
+}, {
+    chainId: string | number;
+    page?: {
+        sort?: {
+            order: SortOrder;
+            column: string;
+        }[] | undefined;
+        page?: number | undefined;
+        column?: string | undefined;
+        pageSize?: number | undefined;
+        more?: boolean | undefined;
+        before?: any;
+        after?: any;
+    } | undefined;
+    tokenId?: string | undefined;
+    contractAddress?: string | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    accountAddress?: string | undefined;
+    includeMetadata?: boolean | undefined;
+    metadataOptions?: {
+        verifiedOnly?: boolean | undefined;
+        unverifiedOnly?: boolean | undefined;
+        includeContracts?: string[] | undefined;
+    } | undefined;
+    includeCollectionTokens?: boolean | undefined;
+}>;
+type UseFetchTokenBalancesReturn = Awaited<ReturnType<typeof fetchBalances>>;
+type UseListBalancesArgs = z.input<typeof useListBalancesArgsSchema>;
+declare const fetchBalances: (args: UseListBalancesArgs, page: Page, config: SdkConfig) => Promise<_0xsequence_indexer.GetTokenBalancesReturn>;
+declare const listBalancesOptions: (args: UseListBalancesArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseInfiniteQueryOptions<_0xsequence_indexer.GetTokenBalancesReturn, Error, _tanstack_react_query.InfiniteData<_0xsequence_indexer.GetTokenBalancesReturn, unknown>, _0xsequence_indexer.GetTokenBalancesReturn, ("balances" | "tokenBalances" | SdkConfig | {
+    chainId: string | number;
+    page?: {
+        sort?: {
+            order: SortOrder;
+            column: string;
+        }[] | undefined;
+        page?: number | undefined;
+        column?: string | undefined;
+        pageSize?: number | undefined;
+        more?: boolean | undefined;
+        before?: any;
+        after?: any;
+    } | undefined;
+    tokenId?: string | undefined;
+    contractAddress?: string | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    accountAddress?: string | undefined;
+    includeMetadata?: boolean | undefined;
+    metadataOptions?: {
+        verifiedOnly?: boolean | undefined;
+        unverifiedOnly?: boolean | undefined;
+        includeContracts?: string[] | undefined;
+    } | undefined;
+    includeCollectionTokens?: boolean | undefined;
+})[], any>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<_0xsequence_indexer.GetTokenBalancesReturn, ("balances" | "tokenBalances" | SdkConfig | {
+        chainId: string | number;
+        page?: {
+            sort?: {
+                order: SortOrder;
+                column: string;
+            }[] | undefined;
+            page?: number | undefined;
+            column?: string | undefined;
+            pageSize?: number | undefined;
+            more?: boolean | undefined;
+            before?: any;
+            after?: any;
+        } | undefined;
+        tokenId?: string | undefined;
+        contractAddress?: string | undefined;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        accountAddress?: string | undefined;
+        includeMetadata?: boolean | undefined;
+        metadataOptions?: {
+            verifiedOnly?: boolean | undefined;
+            unverifiedOnly?: boolean | undefined;
+            includeContracts?: string[] | undefined;
+        } | undefined;
+        includeCollectionTokens?: boolean | undefined;
+    })[], any> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("balances" | "tokenBalances" | SdkConfig | UseTokenBalancesArgs)[], _tanstack_react_query.InfiniteData<_0xsequence_indexer.GetTokenBalancesReturn, unknown>>;
+    queryKey: _tanstack_react_query.DataTag<("balances" | "tokenBalances" | SdkConfig | {
+        chainId: string | number;
+        page?: {
+            sort?: {
+                order: SortOrder;
+                column: string;
+            }[] | undefined;
+            page?: number | undefined;
+            column?: string | undefined;
+            pageSize?: number | undefined;
+            more?: boolean | undefined;
+            before?: any;
+            after?: any;
+        } | undefined;
+        tokenId?: string | undefined;
+        contractAddress?: string | undefined;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        accountAddress?: string | undefined;
+        includeMetadata?: boolean | undefined;
+        metadataOptions?: {
+            verifiedOnly?: boolean | undefined;
+            unverifiedOnly?: boolean | undefined;
+            includeContracts?: string[] | undefined;
+        } | undefined;
+        includeCollectionTokens?: boolean | undefined;
+    })[], _tanstack_react_query.InfiniteData<_0xsequence_indexer.GetTokenBalancesReturn, unknown>>;
 };
-declare const useTokenBalances: (args: UseTokenBalancesArgs) => _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<_0xsequence_indexer.GetTokenBalancesReturn, unknown>, Error>;
+declare const useListBalances: (args: UseListBalancesArgs) => _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<_0xsequence_indexer.GetTokenBalancesReturn, unknown>, Error>;
 
-type UseListCollectiblesArgs = Omit<ListCollectiblesArgs, 'contractAddress'> & {
+declare const UseListCollectiblesArgsSchema: z.ZodObject<z.objectUtil.extendShape<Omit<{
+    side: z.ZodNativeEnum<typeof OrderSide>;
+    contractAddress: z.ZodString;
+    filter: z.ZodOptional<z.ZodObject<{
+        includeEmpty: z.ZodBoolean;
+        searchText: z.ZodOptional<z.ZodString>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodNativeEnum<typeof PropertyType>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            values: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }, {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }>, "many">>;
+        marketplaces: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof MarketplaceKind>, "many">>;
+        inAccounts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        notInAccounts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        ordersCreatedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        ordersNotCreatedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        includeEmpty: boolean;
+        searchText?: string | undefined;
+        properties?: {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }[] | undefined;
+        marketplaces?: MarketplaceKind[] | undefined;
+        inAccounts?: string[] | undefined;
+        notInAccounts?: string[] | undefined;
+        ordersCreatedBy?: string[] | undefined;
+        ordersNotCreatedBy?: string[] | undefined;
+    }, {
+        includeEmpty: boolean;
+        searchText?: string | undefined;
+        properties?: {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }[] | undefined;
+        marketplaces?: MarketplaceKind[] | undefined;
+        inAccounts?: string[] | undefined;
+        notInAccounts?: string[] | undefined;
+        ordersCreatedBy?: string[] | undefined;
+        ordersNotCreatedBy?: string[] | undefined;
+    }>>;
+    page: z.ZodOptional<z.ZodObject<{
+        page: z.ZodNumber;
+        pageSize: z.ZodNumber;
+        more: z.ZodOptional<z.ZodBoolean>;
+        sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            order: z.ZodNativeEnum<typeof SortOrder$1>;
+        }, "strip", z.ZodTypeAny, {
+            order: SortOrder$1;
+            column: string;
+        }, {
+            order: SortOrder$1;
+            column: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    }, {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    }>>;
+}, "contractAddress">, {
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}>, "strip", z.ZodTypeAny, {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    side: OrderSide;
+    filter?: {
+        includeEmpty: boolean;
+        searchText?: string | undefined;
+        properties?: {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }[] | undefined;
+        marketplaces?: MarketplaceKind[] | undefined;
+        inAccounts?: string[] | undefined;
+        notInAccounts?: string[] | undefined;
+        ordersCreatedBy?: string[] | undefined;
+        ordersNotCreatedBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    } | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
     collectionAddress: string;
-    chainId: ChainId;
-};
-type UseListCollectiblesReturn = ReturnType<typeof fetchCollectibles>;
-declare const fetchCollectibles: (args: UseListCollectiblesArgs, page: Page$1, marketplaceClient: ReturnType<typeof getMarketplaceClient>) => Promise<ListCollectiblesReturn>;
-declare const listCollectiblesOptions: (args: UseListCollectiblesArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseInfiniteQueryOptions<ListCollectiblesReturn, Error, _tanstack_react_query.InfiniteData<ListCollectiblesReturn, unknown>, ListCollectiblesReturn, (SequenceMarketplace | "collectable" | "list" | UseListCollectiblesArgs)[], {
+    side: OrderSide;
+    filter?: {
+        includeEmpty: boolean;
+        searchText?: string | undefined;
+        properties?: {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }[] | undefined;
+        marketplaces?: MarketplaceKind[] | undefined;
+        inAccounts?: string[] | undefined;
+        notInAccounts?: string[] | undefined;
+        ordersCreatedBy?: string[] | undefined;
+        ordersNotCreatedBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    } | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseListCollectiblesArgs = z.infer<typeof UseListCollectiblesArgsSchema>;
+type UseListCollectiblesReturn = Awaited<ReturnType<typeof fetchCollectibles>>;
+declare const fetchCollectibles: (args: UseListCollectiblesArgs, page: Page$1, marketplaceClient: Awaited<ReturnType<typeof getMarketplaceClient>>) => Promise<ListCollectiblesReturn>;
+declare const listCollectiblesOptions: (args: UseListCollectiblesArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseInfiniteQueryOptions<ListCollectiblesReturn, Error, _tanstack_react_query.InfiniteData<ListCollectiblesReturn, unknown>, ListCollectiblesReturn, (SequenceMarketplace | "collectable" | "list" | {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    side: OrderSide;
+    filter?: {
+        includeEmpty: boolean;
+        searchText?: string | undefined;
+        properties?: {
+            type: PropertyType;
+            name: string;
+            values?: any[] | undefined;
+            min?: number | undefined;
+            max?: number | undefined;
+        }[] | undefined;
+        marketplaces?: MarketplaceKind[] | undefined;
+        inAccounts?: string[] | undefined;
+        notInAccounts?: string[] | undefined;
+        ordersCreatedBy?: string[] | undefined;
+        ordersNotCreatedBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    } | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+})[], {
     page: number;
     pageSize: number;
 }>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<ListCollectiblesReturn, (SequenceMarketplace | "collectable" | "list" | UseListCollectiblesArgs)[], {
+    queryFn?: _tanstack_react_query.QueryFunction<ListCollectiblesReturn, (SequenceMarketplace | "collectable" | "list" | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        side: OrderSide;
+        filter?: {
+            includeEmpty: boolean;
+            searchText?: string | undefined;
+            properties?: {
+                type: PropertyType;
+                name: string;
+                values?: any[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+            }[] | undefined;
+            marketplaces?: MarketplaceKind[] | undefined;
+            inAccounts?: string[] | undefined;
+            notInAccounts?: string[] | undefined;
+            ordersCreatedBy?: string[] | undefined;
+            ordersNotCreatedBy?: string[] | undefined;
+        } | undefined;
+        page?: {
+            page: number;
+            pageSize: number;
+            sort?: {
+                order: SortOrder$1;
+                column: string;
+            }[] | undefined;
+            more?: boolean | undefined;
+        } | undefined;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], {
         page: number;
         pageSize: number;
     }> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<(SequenceMarketplace | "collectable" | "list" | UseListCollectiblesArgs)[], _tanstack_react_query.InfiniteData<ListCollectiblesReturn, unknown>>;
+    queryKey: _tanstack_react_query.DataTag<(SequenceMarketplace | "collectable" | "list" | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        side: OrderSide;
+        filter?: {
+            includeEmpty: boolean;
+            searchText?: string | undefined;
+            properties?: {
+                type: PropertyType;
+                name: string;
+                values?: any[] | undefined;
+                min?: number | undefined;
+                max?: number | undefined;
+            }[] | undefined;
+            marketplaces?: MarketplaceKind[] | undefined;
+            inAccounts?: string[] | undefined;
+            notInAccounts?: string[] | undefined;
+            ordersCreatedBy?: string[] | undefined;
+            ordersNotCreatedBy?: string[] | undefined;
+        } | undefined;
+        page?: {
+            page: number;
+            pageSize: number;
+            sort?: {
+                order: SortOrder$1;
+                column: string;
+            }[] | undefined;
+            more?: boolean | undefined;
+        } | undefined;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], _tanstack_react_query.InfiniteData<ListCollectiblesReturn, unknown>>;
 };
 declare const useListCollectibles: (args: UseListCollectiblesArgs) => _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<ListCollectiblesReturn, unknown>, Error>;
 
-type UseListOffersForCollectibleArgs = ListOffersForCollectibleArgs & {
+declare const UseListOffersForCollectibleArgsSchema: z.ZodObject<z.objectUtil.extendShape<{
+    contractAddress: z.ZodString;
+    tokenId: z.ZodString;
+    filter: z.ZodOptional<z.ZodObject<{
+        createdBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        marketplace: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof MarketplaceKind>, "many">>;
+        currencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    }, {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    }>>;
+    page: z.ZodOptional<z.ZodObject<{
+        page: z.ZodNumber;
+        pageSize: z.ZodNumber;
+        more: z.ZodOptional<z.ZodBoolean>;
+        sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            order: z.ZodNativeEnum<typeof SortOrder$1>;
+        }, "strip", z.ZodTypeAny, {
+            order: SortOrder$1;
+            column: string;
+        }, {
+            order: SortOrder$1;
+            column: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    }, {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    }>>;
+}, {
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
     chainId: string;
-};
-type UseListOffersForCollectible = ReturnType<typeof fetchListOffersForCollectible>;
+    tokenId: string;
+    contractAddress: string;
+    filter?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
+    tokenId: string;
+    contractAddress: string;
+    filter?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    } | undefined;
+}>;
+type UseListOffersForCollectibleArgs = z.infer<typeof UseListOffersForCollectibleArgsSchema>;
+type UseListOffersForCollectibleReturn = Awaited<ReturnType<typeof fetchListOffersForCollectible>>;
 declare const fetchListOffersForCollectible: (config: SdkConfig, args: UseListOffersForCollectibleArgs, page: Page$1) => Promise<ListCollectibleOffersReturn>;
-declare const listOffersForCollectibleOptions: (args: UseListOffersForCollectibleArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseInfiniteQueryOptions<ListCollectibleOffersReturn, Error, _tanstack_react_query.InfiniteData<ListCollectibleOffersReturn, unknown>, ListCollectibleOffersReturn, ("offers" | "collectable" | SdkConfig | UseListOffersForCollectibleArgs)[], {
+declare const listOffersForCollectibleOptions: (args: UseListOffersForCollectibleArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseInfiniteQueryOptions<ListCollectibleOffersReturn, Error, _tanstack_react_query.InfiniteData<ListCollectibleOffersReturn, unknown>, ListCollectibleOffersReturn, ("offers" | "collectable" | SdkConfig | {
+    chainId: string;
+    tokenId: string;
+    contractAddress: string;
+    filter?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    } | undefined;
+})[], {
     page: number;
     pageSize: number;
 }>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<ListCollectibleOffersReturn, ("offers" | "collectable" | SdkConfig | UseListOffersForCollectibleArgs)[], {
+    queryFn?: _tanstack_react_query.QueryFunction<ListCollectibleOffersReturn, ("offers" | "collectable" | SdkConfig | {
+        chainId: string;
+        tokenId: string;
+        contractAddress: string;
+        filter?: {
+            currencies?: string[] | undefined;
+            marketplace?: MarketplaceKind[] | undefined;
+            createdBy?: string[] | undefined;
+        } | undefined;
+        page?: {
+            page: number;
+            pageSize: number;
+            sort?: {
+                order: SortOrder$1;
+                column: string;
+            }[] | undefined;
+            more?: boolean | undefined;
+        } | undefined;
+    })[], {
         page: number;
         pageSize: number;
     }> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("offers" | "collectable" | SdkConfig | UseListOffersForCollectibleArgs)[], _tanstack_react_query.InfiniteData<ListCollectibleOffersReturn, unknown>>;
+    queryKey: _tanstack_react_query.DataTag<("offers" | "collectable" | SdkConfig | {
+        chainId: string;
+        tokenId: string;
+        contractAddress: string;
+        filter?: {
+            currencies?: string[] | undefined;
+            marketplace?: MarketplaceKind[] | undefined;
+            createdBy?: string[] | undefined;
+        } | undefined;
+        page?: {
+            page: number;
+            pageSize: number;
+            sort?: {
+                order: SortOrder$1;
+                column: string;
+            }[] | undefined;
+            more?: boolean | undefined;
+        } | undefined;
+    })[], _tanstack_react_query.InfiniteData<ListCollectibleOffersReturn, unknown>>;
 };
 declare const useListOffersForCollectible: (args: UseListOffersForCollectibleArgs) => _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<ListCollectibleOffersReturn, unknown>, Error>;
 
-type UseLowestListingArgs = Omit<GetCollectibleLowestListingArgs, 'contractAddress'> & {
+declare const UseLowestListingSchema: z.ZodObject<z.objectUtil.extendShape<Omit<{
+    contractAddress: z.ZodString;
+    tokenId: z.ZodString;
+    filters: z.ZodOptional<z.ZodObject<{
+        createdBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        marketplace: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof MarketplaceKind>, "many">>;
+        currencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    }, {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    }>>;
+}, "contractAddress">, {
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}>, "strip", z.ZodTypeAny, {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    tokenId: string;
+    filters?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
     collectionAddress: string;
-    chainId: ChainId;
-} & QueryArg;
-type UseLowestListingReturn = ReturnType<typeof fetchLowestListing>;
+    tokenId: string;
+    filters?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseLowestListingArgs = z.infer<typeof UseLowestListingSchema>;
+type UseLowestListingReturn = Awaited<ReturnType<typeof fetchLowestListing>>;
 declare const fetchLowestListing: (args: UseLowestListingArgs, config: SdkConfig) => Promise<GetCollectibleLowestListingReturn>;
-declare const lowestListingOptions: (args: UseLowestListingArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetCollectibleLowestListingReturn, Error, GetCollectibleLowestListingReturn, ("collectable" | "details" | "lowestListings" | SdkConfig | UseLowestListingArgs)[]>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<GetCollectibleLowestListingReturn, ("collectable" | "details" | "lowestListings" | SdkConfig | UseLowestListingArgs)[], never> | undefined;
+declare const lowestListingOptions: (args: UseLowestListingArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<GetCollectibleLowestListingReturn, Error, GetCollectibleLowestListingReturn, ("collectable" | "details" | "lowestListings" | SdkConfig | {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    tokenId: string;
+    filters?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+})[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<GetCollectibleLowestListingReturn, ("collectable" | "details" | "lowestListings" | SdkConfig | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        tokenId: string;
+        filters?: {
+            currencies?: string[] | undefined;
+            marketplace?: MarketplaceKind[] | undefined;
+            createdBy?: string[] | undefined;
+        } | undefined;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], never> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("collectable" | "details" | "lowestListings" | SdkConfig | UseLowestListingArgs)[], GetCollectibleLowestListingReturn>;
+    queryKey: _tanstack_react_query.DataTag<("collectable" | "details" | "lowestListings" | SdkConfig | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        tokenId: string;
+        filters?: {
+            currencies?: string[] | undefined;
+            marketplace?: MarketplaceKind[] | undefined;
+            createdBy?: string[] | undefined;
+        } | undefined;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], GetCollectibleLowestListingReturn>;
 };
 declare const useLowestListing: (args: UseLowestListingArgs) => _tanstack_react_query.UseQueryResult<GetCollectibleLowestListingReturn, Error>;
 
@@ -180,15 +1399,58 @@ declare const marketplaceConfigOptions: (config: Pick<SdkConfig, "projectId"> |
 
 declare const useMarketplaceConfig: () => _tanstack_react_query.UseQueryResult<MarketplaceConfig, Error>;
 
-type UseRoyaletyPercentageArgs = {
-    chainId: ChainId;
+declare const UseRoyaletyPercentageSchema: z.ZodObject<{
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    collectibleId: z.ZodString;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    collectibleId: string;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
     collectionAddress: string;
     collectibleId: string;
-} & QueryArg;
-declare const royaletyPercentageOptions: (args: UseRoyaletyPercentageArgs) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<bigint, Error, bigint, ("collectable" | "royaltyPercentage" | UseRoyaletyPercentageArgs)[]>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<bigint, ("collectable" | "royaltyPercentage" | UseRoyaletyPercentageArgs)[], never> | undefined;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseRoyaletyPercentageArgs = z.infer<typeof UseRoyaletyPercentageSchema>;
+declare const royaletyPercentageOptions: (args: UseRoyaletyPercentageArgs) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<bigint, Error, bigint, ("collectable" | "royaltyPercentage" | {
+    chainId: string;
+    collectionAddress: `0x${string}`;
+    collectibleId: string;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+})[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<bigint, ("collectable" | "royaltyPercentage" | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        collectibleId: string;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], never> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("collectable" | "royaltyPercentage" | UseRoyaletyPercentageArgs)[], bigint>;
+    queryKey: _tanstack_react_query.DataTag<("collectable" | "royaltyPercentage" | {
+        chainId: string;
+        collectionAddress: `0x${string}`;
+        collectibleId: string;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], bigint>;
 };
 declare const useRoyaltyPercentage: (args: UseRoyaletyPercentageArgs) => _tanstack_react_query.UseQueryResult<bigint, Error>;
 
@@ -378,4 +1640,4 @@ declare const useTransferTokens: () => {
     transferSuccess: boolean;
 };
 
-export { type CreateReqWithDateExpiry$1 as CreateReqWithDateExpiry, type GenerateListingTransactionProps, type GenerateOfferTransactionProps, type TransferTokensParams, type UseBalanceOfCollectibleArgs, type UseCollectibleArgs, type UseCollectibleReturn, type UseCollectionArgs, type UseCollectionReturn, type UseCurrenciesArgs, type UseCurrenciesReturn, type UseFetchTokenBalancesReturn, type UseFilterReturn, type UseFiltersArgs, type UseFloorOrder, type UseGenerateListingTransactionArgs, type UseGenerateOfferTransactionArgs, type UseHighestOfferArgs, type UseHighestOfferReturn, type UseListCollectiblesArgs, type UseListCollectiblesReturn, type UseListOffersForCollectible, type UseListOffersForCollectibleArgs, type UseLowestListingArgs, type UseLowestListingReturn, type UseTokenBalancesArgs, balanceOfCollectibleOptions, collectibleOptions, collectionOptions, currenciesOptions, fetchFilters, filtersOptions, floorOrderOptions, generateListingTransaction, generateOfferTransaction, highestOfferOptions, listCollectiblesOptions, listOffersForCollectibleOptions, lowestListingOptions, marketplaceConfigOptions, royaletyPercentageOptions, tokenBalancesOptions, useBalanceOfCollectible, useCollectible, useCollection, useConfig, useCurrencies, useFilters, useFloorOrder, useGenerateListingTransaction, useGenerateOfferTransaction, useHighestOffer, useListCollectibles, useListOffersForCollectible, useLowestListing, useMarketplaceConfig, useRoyaltyPercentage, useTokenBalances, useTransferTokens };
+export { type CreateReqWithDateExpiry$1 as CreateReqWithDateExpiry, type GenerateListingTransactionProps, type GenerateOfferTransactionProps, type TransferTokensParams, type UseCollectibleArgs, type UseCollectibleReturn, type UseCollectionArgs, type UseCollectionReturn, type UseContOfCollectableReturn, type UseCountOfCollectablesArgs, type UseCurrenciesReturn, type UseFetchTokenBalancesReturn, type UseFilterReturn, type UseFiltersArgs, type UseFloorOrderArgs, type UseFloorOrderReturn, type UseGenerateListingTransactionArgs, type UseGenerateOfferTransactionArgs, type UseHighestOfferArgs, type UseHighestOfferReturn, type UseListBalancesArgs, type UseListCollectiblesArgs, type UseListCollectiblesReturn, type UseListOffersForCollectibleReturn, type UseLowestListingArgs, type UseLowestListingReturn, balanceOfCollectibleOptions, collectibleOptions, collectionOptions, countOfCollectablesOptions, currenciesOptions, fetchFilters, filtersOptions, floorOrderOptions, generateListingTransaction, generateOfferTransaction, highestOfferOptions, listBalancesOptions, listCollectiblesOptions, listOffersForCollectibleOptions, lowestListingOptions, marketplaceConfigOptions, metadataOptionsSchema, royaletyPercentageOptions, useBalanceOfCollectible, useCollectible, useCollection, useConfig, useCountOfCollectables, useCurrencies, useFilters, useFloorOrder, useGenerateListingTransaction, useGenerateOfferTransaction, useHighestOffer, useListBalances, useListCollectibles, useListOffersForCollectible, useLowestListing, useMarketplaceConfig, useRoyaltyPercentage, useTransferTokens };