@story-protocol/ipkit 0.4.0-beta.9 → 0.4.0

package/dist/types.d.ts

@@ -2,7 +2,6 @@ import * as openapi_fetch from 'openapi-fetch';
 import { Client } from 'openapi-fetch';
 import { Address } from 'viem';
 import React from 'react';
-import { ClassValue } from 'clsx';
 import { UseQueryResult } from '@tanstack/react-query';
 
 interface paths {
@@ -119,6 +118,26 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/licenses/tokens": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Get License Tokens
+         * @description Retrieve license tokens with optional filtering. If no filters are provided, returns all license tokens. Supports filtering by owner wallet address and/or licensor IP ID. Results are paginated and can be ordered by 'blockNumber' (default: descending).
+         */
+        post: operations["getLicenseTokensV4"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/search": {
         parameters: {
             query?: never;
@@ -629,6 +648,71 @@ interface components {
             transferable: boolean;
             uri: string;
         };
+        LicenseToken: {
+            blockNumber: string;
+            blockTime: string;
+            burntAt: string;
+            id: string;
+            licenseTemplate: string;
+            licenseTermsId: string;
+            licensorIpId: string;
+            owner: string;
+            transferable: string;
+        };
+        LicenseTokenPaginationOptionsHuma: {
+            /**
+             * Format: int64
+             * @description Number of items to return
+             * @default 100
+             */
+            limit: number;
+            /**
+             * Format: int64
+             * @description Number of items to skip
+             * @default 0
+             */
+            offset: number;
+        };
+        LicenseTokensRequestBodyHuma: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /**
+             * @description Field to order results by (only 'blockNumber' is supported)
+             * @default blockNumber
+             * @enum {string}
+             */
+            orderBy: "blockNumber";
+            /**
+             * @description Order direction for results ('asc' for ascending, 'desc' for descending)
+             * @default desc
+             * @enum {string}
+             */
+            orderDirection: "asc" | "desc";
+            /** @description Pagination configuration (optional, defaults: limit=100, offset=0) */
+            pagination?: components["schemas"]["LicenseTokenPaginationOptionsHuma"];
+            /** @description Optional filter options for license tokens */
+            where?: components["schemas"]["LicenseTokensWhereOptionsHuma"];
+        };
+        LicenseTokensResponseHumaBody: {
+            /**
+             * Format: uri
+             * @description A URL to the JSON Schema for this object.
+             */
+            readonly $schema?: string;
+            /** @description List of license tokens matching the filter criteria */
+            data: components["schemas"]["LicenseToken"][] | null;
+            /** @description Pagination metadata including total count and hasMore flag */
+            pagination?: components["schemas"]["PaginationMetadataHuma"];
+        };
+        LicenseTokensWhereOptionsHuma: {
+            /** @description Optional licensor IP ID to filter license tokens */
+            licensorIpId?: string;
+            /** @description Optional owner wallet address to filter license tokens */
+            ownerAddress?: string;
+        };
         LicensingConfig: {
             /** Format: int64 */
             commercialRevShare: number;
@@ -639,8 +723,7 @@ interface components {
             hookData: string;
             isSet: boolean;
             licensingHook: string;
-            /** Format: int64 */
-            mintingFee: number;
+            mintingFee: string;
         };
         ListDisputesResponseHumaBody: {
             /**
@@ -723,7 +806,7 @@ interface components {
              * Format: int64
              * @description Total count of items
              */
-            total?: number;
+            total: number;
         };
         PaginationOptionsHuma: {
             /**
@@ -1000,6 +1083,39 @@ interface operations {
             };
         };
     };
+    getLicenseTokensV4: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["LicenseTokensRequestBodyHuma"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LicenseTokensResponseHumaBody"];
+                };
+            };
+            /** @description Error */
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": components["schemas"]["ErrorModel"];
+                };
+            };
+        };
+    };
     searchV4: {
         parameters: {
             query?: never;
@@ -1105,26 +1221,19 @@ declare enum IPKIT_SUPPORTED_CHAIN {
 }
 declare const WRAPPED_IP: ERC20Token;
 
-type Mode = "light" | "dark" | undefined;
-type Theme = "default" | "story" | string;
 interface IpKitProviderOptions {
     apiKey: string;
     appId?: string;
     children: React.ReactNode;
     isTestnet?: boolean;
-    mode?: Mode;
-    theme?: Theme;
 }
-declare const IpKitProvider: ({ apiKey, appId, children, isTestnet, mode, theme, }: IpKitProviderOptions) => React.JSX.Element;
+declare const IpKitProvider: ({ apiKey, appId, children, isTestnet, }: IpKitProviderOptions) => React.JSX.Element;
 declare const useIpKit: () => {
     apiBaseUrl: string;
     apiClient: ApiClient;
     apiKey: string;
     appId: string | undefined;
     chain: ChainConfig;
-    mode: Mode;
-    theme: Theme;
-    themeClass: string;
 };
 
 type QueryKey = ReadonlyArray<unknown>;
@@ -1146,14 +1255,15 @@ type IPSearchResult = components["schemas"]["IPSearchResult"];
 type Collection = components["schemas"]["EnrichedCollection"];
 type CollectionMetadata = components["schemas"]["ContractMetadataByAddressResponse"];
 type License = components["schemas"]["License"];
-type LicenseTerms$1 = components["schemas"]["LicenseTerms"];
+type LicenseTerms = components["schemas"]["LicenseTerms"];
+type LicenseToken = components["schemas"]["LicenseToken"];
 type LicensingConfig = components["schemas"]["LicensingConfig"];
 type NFTMetadata = components["schemas"]["NFTMetadata"];
 type InfringementStatus = components["schemas"]["InfringementStatus"];
 type ModerationStatus = components["schemas"]["ModerationStatus"];
 type ContractMetadata = components["schemas"]["ContractMetadata"];
 type Dispute = components["schemas"]["Dispute"];
-type PILTerms = LicenseTerms$1;
+type PILTerms = LicenseTerms;
 type TransactionEventType = "IPRegistered" | "LicenseTermsAttached" | "DerivativeRegistered" | "DisputeRaised" | "DisputeResolved" | "DisputeCancelled" | "DisputeJudgementSet" | "RoyaltyPaid";
 
 declare enum PIL_FLAVOR {
@@ -1212,18 +1322,6 @@ interface IPMetadata {
     [key: string]: any;
 }
 
-declare function cn(...inputs: ClassValue[]): string;
-declare function shortenAddress(address: string, length?: number): string;
-declare function camelize(str: string): string;
-declare function getPilFlavorByLicenseTerms(pilTerms: PILTerms): PilFlavor;
-declare function getImageUrlFromIpfsUrl(ipfsUrl: string): Promise<string>;
-declare function convertIpfsUriToUrl(ipfsUri: string): string;
-declare function getMetadataFromIpfs(ipfsUrl: string): Promise<any>;
-declare function fetchLicenseOffChainData(uri: string): Promise<any>;
-
-type LicenseTerms = Partial<PILTerms>;
-declare function convertLicenseTermObject(licenseTerms: Trait[]): LicenseTerms;
-
 type CollectionsResponse = paths["/collections"]["post"]["responses"][200]["content"]["application/json"];
 type CollectionsOptions = Partial<paths["/collections"]["post"]["requestBody"]["content"]["application/json"]>;
 type GetCollectionsOptions = {
@@ -1303,7 +1401,7 @@ declare function getCollections({ collectionAddresses, apiClient, options, apiKe
                         hasMore: boolean;
                         limit: number;
                         offset: number;
-                        total?: number | undefined;
+                        total: number;
                     } | undefined;
                 };
             };
@@ -1424,7 +1522,7 @@ declare function getCollections({ collectionAddresses, apiClient, options, apiKe
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -1522,7 +1620,7 @@ declare function getCollections({ collectionAddresses, apiClient, options, apiKe
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -2077,7 +2175,7 @@ declare function getIpAssetEdges({ apiClient, ipId, parentIpId, options, apiKey
                         hasMore: boolean;
                         limit: number;
                         offset: number;
-                        total?: number | undefined;
+                        total: number;
                     } | undefined;
                 };
             };
@@ -2180,7 +2278,7 @@ declare function getIpAssetEdges({ apiClient, ipId, parentIpId, options, apiKey
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -2259,7 +2357,7 @@ declare function getIpAssetEdges({ apiClient, ipId, parentIpId, options, apiKey
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -2387,7 +2485,7 @@ declare function getIpAssets({ apiClient, ownerAddress, tokenContract, includeLi
                                 hookData: string;
                                 isSet: boolean;
                                 licensingHook: string;
-                                mintingFee: number;
+                                mintingFee: string;
                             };
                             templateMetadataUri: string;
                             templateName: string;
@@ -2495,7 +2593,7 @@ declare function getIpAssets({ apiClient, ownerAddress, tokenContract, includeLi
                         hasMore: boolean;
                         limit: number;
                         offset: number;
-                        total?: number | undefined;
+                        total: number;
                     } | undefined;
                 };
             };
@@ -2617,7 +2715,7 @@ declare function getIpAssets({ apiClient, ownerAddress, tokenContract, includeLi
                                     hookData: string;
                                     isSet: boolean;
                                     licensingHook: string;
-                                    mintingFee: number;
+                                    mintingFee: string;
                                 };
                                 templateMetadataUri: string;
                                 templateName: string;
@@ -2725,7 +2823,7 @@ declare function getIpAssets({ apiClient, ownerAddress, tokenContract, includeLi
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -2822,7 +2920,7 @@ declare function getIpAssets({ apiClient, ownerAddress, tokenContract, includeLi
                                     hookData: string;
                                     isSet: boolean;
                                     licensingHook: string;
-                                    mintingFee: number;
+                                    mintingFee: string;
                                 };
                                 templateMetadataUri: string;
                                 templateName: string;
@@ -2930,7 +3028,7 @@ declare function getIpAssets({ apiClient, ownerAddress, tokenContract, includeLi
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -2977,6 +3075,276 @@ declare function getIpAssets({ apiClient, ownerAddress, tokenContract, includeLi
     } | undefined;
 }, `${string}/${string}`>>;
 
+type LicenseTokensResponse = paths["/licenses/tokens"]["post"]["responses"][200]["content"]["application/json"];
+type LicenseTokensOptions = Partial<paths["/licenses/tokens"]["post"]["requestBody"]["content"]["application/json"]>;
+type GetLicenseTokensOptions = {
+    apiClient: ApiClient;
+    ownerAddress?: Address;
+    licensorIpId?: Address;
+    options?: LicenseTokensOptions;
+    apiKey: string;
+};
+declare function getLicenseTokens({ apiClient, ownerAddress, licensorIpId, options, apiKey }: GetLicenseTokensOptions): Promise<openapi_fetch.FetchResponse<{
+    parameters: {
+        query?: undefined;
+        header?: undefined;
+        path?: undefined;
+        cookie?: undefined;
+    };
+    requestBody: {
+        content: {
+            "application/json": {
+                readonly $schema?: string | undefined;
+                orderBy: "blockNumber";
+                orderDirection: "asc" | "desc";
+                pagination?: {
+                    limit: number;
+                    offset: number;
+                } | undefined;
+                where?: {
+                    licensorIpId?: string | undefined;
+                    ownerAddress?: string | undefined;
+                } | undefined;
+            };
+        };
+    };
+    responses: {
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": {
+                    readonly $schema?: string | undefined;
+                    data: {
+                        blockNumber: string;
+                        blockTime: string;
+                        burntAt: string;
+                        id: string;
+                        licenseTemplate: string;
+                        licenseTermsId: string;
+                        licensorIpId: string;
+                        owner: string;
+                        transferable: string;
+                    }[] | null;
+                    pagination?: {
+                        hasMore: boolean;
+                        limit: number;
+                        offset: number;
+                        total: number;
+                    } | undefined;
+                };
+            };
+        };
+        default: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": {
+                    readonly $schema?: string | undefined;
+                    detail?: string | undefined;
+                    errors?: {
+                        location?: string | undefined;
+                        message?: string | undefined;
+                        value?: unknown;
+                    }[] | null | undefined;
+                    instance?: string | undefined;
+                    status?: number | undefined;
+                    title?: string | undefined;
+                    type: string;
+                };
+            };
+        };
+    };
+}, {
+    params?: {
+        query?: undefined;
+        header?: undefined;
+        path?: undefined;
+        cookie?: undefined;
+    } | undefined;
+} & {
+    body: {
+        readonly $schema?: string | undefined;
+        orderBy: "blockNumber";
+        orderDirection: "asc" | "desc";
+        pagination?: {
+            limit: number;
+            offset: number;
+        } | undefined;
+        where?: {
+            licensorIpId?: string | undefined;
+            ownerAddress?: string | undefined;
+        } | undefined;
+    };
+} & {
+    baseUrl?: string | undefined;
+    querySerializer?: openapi_fetch.QuerySerializerOptions | openapi_fetch.QuerySerializer<{
+        parameters: {
+            query?: undefined;
+            header?: undefined;
+            path?: undefined;
+            cookie?: undefined;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    readonly $schema?: string | undefined;
+                    orderBy: "blockNumber";
+                    orderDirection: "asc" | "desc";
+                    pagination?: {
+                        limit: number;
+                        offset: number;
+                    } | undefined;
+                    where?: {
+                        licensorIpId?: string | undefined;
+                        ownerAddress?: string | undefined;
+                    } | undefined;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        readonly $schema?: string | undefined;
+                        data: {
+                            blockNumber: string;
+                            blockTime: string;
+                            burntAt: string;
+                            id: string;
+                            licenseTemplate: string;
+                            licenseTermsId: string;
+                            licensorIpId: string;
+                            owner: string;
+                            transferable: string;
+                        }[] | null;
+                        pagination?: {
+                            hasMore: boolean;
+                            limit: number;
+                            offset: number;
+                            total: number;
+                        } | undefined;
+                    };
+                };
+            };
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": {
+                        readonly $schema?: string | undefined;
+                        detail?: string | undefined;
+                        errors?: {
+                            location?: string | undefined;
+                            message?: string | undefined;
+                            value?: unknown;
+                        }[] | null | undefined;
+                        instance?: string | undefined;
+                        status?: number | undefined;
+                        title?: string | undefined;
+                        type: string;
+                    };
+                };
+            };
+        };
+    }> | undefined;
+    bodySerializer?: openapi_fetch.BodySerializer<{
+        parameters: {
+            query?: undefined;
+            header?: undefined;
+            path?: undefined;
+            cookie?: undefined;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    readonly $schema?: string | undefined;
+                    orderBy: "blockNumber";
+                    orderDirection: "asc" | "desc";
+                    pagination?: {
+                        limit: number;
+                        offset: number;
+                    } | undefined;
+                    where?: {
+                        licensorIpId?: string | undefined;
+                        ownerAddress?: string | undefined;
+                    } | undefined;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        readonly $schema?: string | undefined;
+                        data: {
+                            blockNumber: string;
+                            blockTime: string;
+                            burntAt: string;
+                            id: string;
+                            licenseTemplate: string;
+                            licenseTermsId: string;
+                            licensorIpId: string;
+                            owner: string;
+                            transferable: string;
+                        }[] | null;
+                        pagination?: {
+                            hasMore: boolean;
+                            limit: number;
+                            offset: number;
+                            total: number;
+                        } | undefined;
+                    };
+                };
+            };
+            default: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/problem+json": {
+                        readonly $schema?: string | undefined;
+                        detail?: string | undefined;
+                        errors?: {
+                            location?: string | undefined;
+                            message?: string | undefined;
+                            value?: unknown;
+                        }[] | null | undefined;
+                        instance?: string | undefined;
+                        status?: number | undefined;
+                        title?: string | undefined;
+                        type: string;
+                    };
+                };
+            };
+        };
+    }> | undefined;
+    parseAs?: keyof openapi_fetch.BodyType<unknown> | undefined;
+    fetch?: ((input: Request) => Promise<Response>) | undefined;
+    headers?: openapi_fetch.HeadersOptions | undefined;
+} & Omit<RequestInit, "headers" | "body"> & {
+    readonly $schema?: string | undefined;
+    orderBy: "blockNumber";
+    orderDirection: "asc" | "desc";
+    pagination?: {
+        limit: number;
+        offset: number;
+    } | undefined;
+    where?: {
+        licensorIpId?: string | undefined;
+        ownerAddress?: string | undefined;
+    } | undefined;
+}, `${string}/${string}`>>;
+
 type SearchResponse = paths["/search"]["post"]["responses"][200]["content"]["application/json"];
 type SearchOptions = Partial<paths["/search"]["post"]["requestBody"]["content"]["application/json"]>;
 type GetSearchOptions = {
@@ -3026,7 +3394,7 @@ declare function getSearch({ apiClient, query, mediaType, options, apiKey }: Get
                         hasMore: boolean;
                         limit: number;
                         offset: number;
-                        total?: number | undefined;
+                        total: number;
                     } | undefined;
                     total: number;
                 };
@@ -3112,7 +3480,7 @@ declare function getSearch({ apiClient, query, mediaType, options, apiKey }: Get
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                         total: number;
                     };
@@ -3180,7 +3548,7 @@ declare function getSearch({ apiClient, query, mediaType, options, apiKey }: Get
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                         total: number;
                     };
@@ -3282,7 +3650,7 @@ declare function getTransactions({ apiClient, txHashes, ipIds, initiators, event
                         hasMore: boolean;
                         limit: number;
                         offset: number;
-                        total?: number | undefined;
+                        total: number;
                     } | undefined;
                 };
             };
@@ -3385,7 +3753,7 @@ declare function getTransactions({ apiClient, txHashes, ipIds, initiators, event
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -3462,7 +3830,7 @@ declare function getTransactions({ apiClient, txHashes, ipIds, initiators, event
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -3596,6 +3964,14 @@ type UseIpAssetsByOwnerOptions = {
 };
 declare function useIpAssetsByOwner({ ownerAddress, includeLicenses, moderated, options, queryOptions, }?: UseIpAssetsByOwnerOptions): UseQueryResult<IpAssetsResponse>;
 
+type UseLicenseTokensOptions = {
+    ownerAddress?: Address;
+    licensorIpId?: Address;
+    options?: LicenseTokensOptions;
+    queryOptions?: IpQueryOptions;
+};
+declare function useLicenseTokens({ ownerAddress, licensorIpId, options, queryOptions, }: UseLicenseTokensOptions): UseQueryResult<LicenseTokensResponse>;
+
 type UseSearchOptions = {
     query: string;
     mediaType?: "audio" | "video" | "image";
@@ -3619,4 +3995,4 @@ type UseTransactionsOptions = {
 };
 declare function useTransactions({ txHashes, ipIds, initiators, eventTypes, options, queryOptions, }?: UseTransactionsOptions): UseQueryResult<TransactionsResponse>;
 
-export { API_URL, type ApiClient, CHAINID_TO_CHAINNAME, CHAINS, type ChainConfig, type Collection, type CollectionMetadata, type CollectionsOptions, type CollectionsResponse, type ContractMetadata, type Creator, type Dispute, type DisputeResponse, type DisputesOptions, type DisputesResponse, type ERC20Token, type GetCollectionsOptions, type GetDisputeOptions, type GetDisputesOptions, type GetIpAssetEdgesOptions, type GetIpAssetsOptions, type GetSearchOptions, type GetTransactionsOptions, type IPAsset, type IPAssetEdge, IPKIT_SUPPORTED_CHAIN, type IPMetadata, type IPSearchResult, type IPTransaction, type InfringementStatus, type IpAssetEdgesOptions, type IpAssetEdgesResponse, type IpAssetsOptions, type IpAssetsResponse, IpKitProvider, type IpKitProviderOptions, type IpQueryOptions, type License, type LicenseOffChainData, type LicenseTerms$1 as LicenseTerms, type LicenseTermsWithOffChainData, type LicenseWithOffChainData, type LicensingConfig, type Mode, type ModerationStatus, type NFTMetadata, type PILTerms, type PILTermsWithOffChainData, PIL_FLAVOR, type PilFlavor, STORY_AENEID, STORY_MAINNET, type SearchOptions, type SearchResponse, type SocialMedia, type SupportedChainConfig, type Theme, type Trait, type TransactionEventType, type TransactionsOptions, type TransactionsResponse, type UseCollectionOptions, type UseCollectionsOptions, type UseDisputeOptions, type UseDisputesOptions, type UseIpAssetChildrenOptions, type UseIpAssetEdgesOptions, type UseIpAssetLicensesOptions, type UseIpAssetOptions, type UseIpAssetParentsOptions, type UseIpAssetsByOwnerOptions, type UseIpAssetsOptions, type UseSearchOptions, type UseTransactionOptions, type UseTransactionsOptions, WRAPPED_IP, camelize, cn, type components, convertIpfsUriToUrl, convertLicenseTermObject, createApiClient, fetchLicenseOffChainData, getCollections, getDispute, getDisputes, getImageUrlFromIpfsUrl, getIpAssetEdges, getIpAssets, getMetadataFromIpfs, getPilFlavorByLicenseTerms, getSearch, getTransactions, type operations, type paths, prodClient, shortenAddress, stagingClient, useCollection, useCollections, useDispute, useDisputes, useIpAsset, useIpAssetChildren, useIpAssetEdges, useIpAssetLicenses, useIpAssetParents, useIpAssets, useIpAssetsByOwner, useIpKit, useSearch, useTransaction, useTransactions };
+export { API_URL, type ApiClient, CHAINID_TO_CHAINNAME, CHAINS, type ChainConfig, type Collection, type CollectionMetadata, type CollectionsOptions, type CollectionsResponse, type ContractMetadata, type Creator, type Dispute, type DisputeResponse, type DisputesOptions, type DisputesResponse, type ERC20Token, type GetCollectionsOptions, type GetDisputeOptions, type GetDisputesOptions, type GetIpAssetEdgesOptions, type GetIpAssetsOptions, type GetLicenseTokensOptions, type GetSearchOptions, type GetTransactionsOptions, type IPAsset, type IPAssetEdge, IPKIT_SUPPORTED_CHAIN, type IPMetadata, type IPSearchResult, type IPTransaction, type InfringementStatus, type IpAssetEdgesOptions, type IpAssetEdgesResponse, type IpAssetsOptions, type IpAssetsResponse, IpKitProvider, type IpKitProviderOptions, type IpQueryOptions, type License, type LicenseOffChainData, type LicenseTerms, type LicenseTermsWithOffChainData, type LicenseToken, type LicenseTokensOptions, type LicenseTokensResponse, type LicenseWithOffChainData, type LicensingConfig, type ModerationStatus, type NFTMetadata, type PILTerms, type PILTermsWithOffChainData, PIL_FLAVOR, type PilFlavor, STORY_AENEID, STORY_MAINNET, type SearchOptions, type SearchResponse, type SocialMedia, type SupportedChainConfig, type Trait, type TransactionEventType, type TransactionsOptions, type TransactionsResponse, type UseCollectionOptions, type UseCollectionsOptions, type UseDisputeOptions, type UseDisputesOptions, type UseIpAssetChildrenOptions, type UseIpAssetEdgesOptions, type UseIpAssetLicensesOptions, type UseIpAssetOptions, type UseIpAssetParentsOptions, type UseIpAssetsByOwnerOptions, type UseIpAssetsOptions, type UseLicenseTokensOptions, type UseSearchOptions, type UseTransactionOptions, type UseTransactionsOptions, WRAPPED_IP, type components, createApiClient, getCollections, getDispute, getDisputes, getIpAssetEdges, getIpAssets, getLicenseTokens, getSearch, getTransactions, type operations, type paths, prodClient, stagingClient, useCollection, useCollections, useDispute, useDisputes, useIpAsset, useIpAssetChildren, useIpAssetEdges, useIpAssetLicenses, useIpAssetParents, useIpAssets, useIpAssetsByOwner, useIpKit, useLicenseTokens, useSearch, useTransaction, useTransactions };