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

package/README.md

@@ -0,0 +1,183 @@
+[![Storybook](https://img.shields.io/badge/Storybook-FF4785?logo=storybook&logoColor=white)](https://ipkit.vercel.app/) [![Version](https://img.shields.io/npm/v/@story-protocol/ipkit)](https://www.npmjs.com/package/@story-protocol/ipkit)
+
+# IpKit
+
+IpKit provides a number of convenient [tanstack-query](https://tanstack.com/query/latest) hooks to quickly access Story's on-chain data, including assets, collections, transactions and more, via the [Protocol V4 API](https://docs.story.foundation/api-reference/protocol/introduction).
+
+## Installation
+
+```bash
+pnpm add @story-protocol/ipkit @tanstack/react-query
+```
+
+## API Keys
+
+To use IpKit you’ll need a Story Protocol API Key, you can request an API key by completing this [form](https://forms.gle/K6enzJw3cTK5sHYU7).
+
+There is a public API key available in the [API docs](https://docs.story.foundation/api-reference/protocol/introduction) for testing mainnet requests.
+
+## Getting Started
+
+### Providers
+
+To initialize IpKit in your project, you'll need to wrap your application in `QueryClientProvider` and `IpKitProvider`. The IpKit provider requires the `apiKey` as a prop. You can also choose to query the Aeneid testnet API by setting `isTestnet` to true.
+
+```tsx
+"use client"
+
+import { IpKitProvider } from "@story-protocol/ipkit"
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
+
+export default function Providers({ children }: { children: React.ReactNode }) {
+  const queryClient = new QueryClient()
+  return (
+    <QueryClientProvider client={queryClient}>
+      <IpKitProvider apiKey="YOUR_API_KEY">{children}</IpKitProvider>
+    </QueryClientProvider>
+  )
+}
+```
+
+### Hooks
+
+You can now use the IpKit hooks to fetch IP data. Hooks return a [tanstack-query](https://tanstack.com/query/latest) `useQuery` function, in each hook you can pass [useQuery options](https://tanstack.com/query/latest/docs/framework/react/reference/useQuery) via the `queryOptions` property.
+
+For hooks that return lists, for example `useIpAssets`, you can pass the [POST request body](https://docs.story.foundation/api-reference/protocol-v4/list-ip-assets) options via the `options` parameter.
+
+For convenience, hooks expose the most commonly required body options in their parameters:
+
+```tsx
+// simple use case
+const { data, isLoading } = useIpAssets()
+```
+
+```tsx
+// fetch a collection's assets
+const { data, isLoading } = useIpAssets({ tokenContract: "0x123" })
+```
+
+```tsx
+// fetch using options and queryOptions
+const { data, isLoading } = useIpAssets({
+  queryOptions: {
+    enabled: true,
+    refetchInterval: 1000,
+  },
+  options: {
+    pagination: {
+      limit: 10,
+      offset: 0,
+    },
+    orderBy: "descendantCount",
+    where: {
+      ownerAddress: "0x123",
+    },
+  },
+})
+```
+
+```tsx
+// fetch a single asset
+const { data, isLoading } = useIpAsset({ ipId: "0x123" })
+```
+
+See the storybook for more details for each hook. The full list of hooks are:
+
+- [useCollection](https://ipkit.vercel.app/?path=/story/hooks-usecollection--default)
+- [useCollections](https://ipkit.vercel.app/?path=/story/hooks-usecollections--default)
+- [useDispute](https://ipkit.vercel.app/?path=/story/hooks-usedispute--default)
+- [useDisputes](https://ipkit.vercel.app/?path=/story/hooks-usedisputes--default)
+- [useIpAsset](https://ipkit.vercel.app/?path=/story/hooks-useipasset--default)
+- [useIpAssetChildren](https://ipkit.vercel.app/?path=/story/hooks-useipassetchildren--default)
+- [useIpAssetEdges](https://ipkit.vercel.app/?path=/story/hooks-useipassetedges--default)
+- [useIpAssetLicenses](https://ipkit.vercel.app/?path=/story/hooks-useipassetlicenses--default)
+- [useIpAssetParents](https://ipkit.vercel.app/?path=/story/hooks-useipassetparents--default)
+- [useIpAssets](https://ipkit.vercel.app/?path=/story/hooks-useipassets--default)
+- [useIpAssetsByOwner](https://ipkit.vercel.app/?path=/story/hooks-useipassetsbyowner--default)
+- [useSearch](https://ipkit.vercel.app/?path=/story/hooks-usesearch--default)
+- [useTransaction](https://ipkit.vercel.app/?path=/story/hooks-usetransaction--default)
+- [useTransactions](https://ipkit.vercel.app/?path=/story/hooks-usetransactions--default)
+
+### useIpKit
+
+You can also use the `useIpKit` hook to access data such as `apiBaseUrl`, `apiClient` (an [openapi-fetch](https://openapi-ts.dev/openapi-fetch/) client) and `chain` which includes chain data such as `id`, `name`, `rpcUrl` and `blockExplorerUrl`. View the full list in [storybook](https://ipkit.vercel.app/?path=/docs/providers-ipkitprovider--docs).
+
+```tsx
+const { apiBaseUrl, chain } = useIpKit()
+const { id, name, rpcUrl } = chain
+```
+
+### Request functions
+
+IpKit also exposes the functions used by each hook in case you require more flexibility, SSR or want to use a different kind of Tanstack Query hook. Since they're using openapi-fetch, each function requires both `apiKey` and the `apiClient`.
+
+Create an API client with the `createApiClient` or import one for testnet or mainnet from IpKit.
+
+```tsx
+import { createApiClient } from "@story-protocol/ipkit"
+
+const client = createApiClient(`https://api.storyapis.com/api/v4/`)
+const assets = await getIpAssets({ apiKey: YOUR_API_KEY, apiClient: client })
+```
+
+```tsx
+import { stagingClient } from "@story-protocol/ipkit"
+
+const assets = await getIpAssets({
+  apiKey: YOUR_API_KEY,
+  apiClient: stagingClient,
+  ipIds: ["0x123"],
+})
+```
+
+These functions also expose some of the POST request body options as function input for convenience. The full list of exported functions are:
+
+- `getCollections`
+- `getDispute`
+- `getDisputes`
+- `getIpAssetEdges`
+- `getIpAssets`
+- `getSearch`
+- `getTransactions`
+
+### SSR
+
+If you want to use IpKit in a server component you should import from `@story-protocol/ipkit/server`, this also exports all the api functions and types, but omits hooks and providers which won't work server-side.
+
+### TypeScript
+
+IpKit uses [OpenAPI](https://www.openapis.org/) and [openapi-typescript](https://openapi-ts.dev/) to ensure up-to-date and consistent types, in-line with the API.
+
+IpKit exports all the IP data types you would expect including:
+
+`IPAsset` `IPAssetEdge` `IPTransaction` `IPSearchResult` `Collection` `CollectionMetadata` `License` `LicenseTerms` `LicensingConfig` `NFTMetadata` `InfringementStatus` `ModerationStatus` `ContractMetadata` `Dispute` `TransactionEventType`
+
+The available options for each hook are exported as `[hookName]Options`, for example `UseIpAssetsOptions`
+
+```ts
+type UseIpAssetsOptions = {
+  ipIds?: Address[]
+  tokenContract?: Address
+  includeLicenses?: boolean
+  moderated?: boolean
+  options?: IpAssetsOptions
+  queryOptions?: IpQueryOptions
+}
+```
+
+The options for each API request are exported as `[nameOfDataType]Options` for example `IpAssetsOptions`.
+
+```ts
+type IpAssetsOptions = {
+  includeLicenses?: boolean
+  moderated?: boolean
+  orderBy?: "blockNumber" | "descendantCount" | "createdAt"
+  orderDirection?: "desc" | "asc"
+  pagination?: { limit: number; offset: number }
+  where?: {
+    ipIds?: string[] | null
+    ownerAddress?: string
+    tokenContract?: string
+  }
+}
+```

package/dist/hooks/index.d.ts

@@ -9,6 +9,7 @@ export * from "./useIpAssetLicenses";
 export * from "./useIpAssetParents";
 export * from "./useIpAssets";
 export * from "./useIpAssetsByOwner";
+export * from "./useLicenseTokens";
 export * from "./useSearch";
 export * from "./useTransaction";
 export * from "./useTransactions";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA;AAC5B,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA;AACjC,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA;AACnC,cAAc,eAAe,CAAA;AAC7B,cAAc,sBAAsB,CAAA;AACpC,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,cAAc,CAAA;AAC5B,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA;AACjC,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA;AACnC,cAAc,eAAe,CAAA;AAC7B,cAAc,sBAAsB,CAAA;AACpC,cAAc,oBAAoB,CAAA;AAClC,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA"}

package/dist/hooks/stories/useLicenseTokens.stories.d.ts

@@ -0,0 +1,38 @@
+import type { StoryObj } from "@storybook/react";
+import React from "react";
+import { UseLicenseTokensOptions } from "../useLicenseTokens";
+declare const meta: {
+    title: string;
+    component: (args: UseLicenseTokensOptions) => React.JSX.Element;
+    parameters: {
+        layout: string;
+    };
+    argTypes: {
+        ownerAddress: {
+            control: "text";
+        };
+        licensorIpId: {
+            control: "text";
+        };
+    };
+    args: {
+        ownerAddress: "0x9474F1E311671b1343118317C7691804c63eCAe6";
+        licensorIpId: undefined;
+        options: {
+            orderBy: "blockNumber";
+            orderDirection: "desc";
+            pagination: {
+                offset: number;
+                limit: number;
+            };
+        };
+        queryOptions: {
+            enabled: true;
+        };
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const WithLicensorFilter: Story;
+//# sourceMappingURL=useLicenseTokens.stories.d.ts.map

package/dist/hooks/stories/useLicenseTokens.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLicenseTokens.stories.d.ts","sourceRoot":"","sources":["../../../src/hooks/stories/useLicenseTokens.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACtD,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,EAAE,uBAAuB,EAAoB,MAAM,qBAAqB,CAAA;AAiB/E,QAAA,MAAM,IAAI;;sBAda,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Cd,CAAA;AAEhC,eAAe,IAAI,CAAA;AACnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAA;AAElC,eAAO,MAAM,OAAO,EAAE,KAErB,CAAA;AAED,eAAO,MAAM,kBAAkB,EAAE,KAIhC,CAAA"}

package/dist/hooks/useLicenseTokens.d.ts

@@ -0,0 +1,12 @@
+import { IpQueryOptions } from "@/types/openapi";
+import { UseQueryResult } from "@tanstack/react-query";
+import { Address } from "viem";
+import { LicenseTokensOptions, LicenseTokensResponse } from "../lib/api/getLicenseTokens";
+export type UseLicenseTokensOptions = {
+    ownerAddress?: Address;
+    licensorIpId?: Address;
+    options?: LicenseTokensOptions;
+    queryOptions?: IpQueryOptions;
+};
+export declare function useLicenseTokens({ ownerAddress, licensorIpId, options, queryOptions, }: UseLicenseTokensOptions): UseQueryResult<LicenseTokensResponse>;
+//# sourceMappingURL=useLicenseTokens.d.ts.map

package/dist/hooks/useLicenseTokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLicenseTokens.d.ts","sourceRoot":"","sources":["../../src/hooks/useLicenseTokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,cAAc,EAAY,MAAM,uBAAuB,CAAA;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAE9B,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAoB,MAAM,6BAA6B,CAAA;AAG3G,MAAM,MAAM,uBAAuB,GAAG;IACpC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,OAAO,CAAC,EAAE,oBAAoB,CAAA;IAC9B,YAAY,CAAC,EAAE,cAAc,CAAA;CAC9B,CAAA;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,YAAY,GACb,EAAE,uBAAuB,GAAG,cAAc,CAAC,qBAAqB,CAAC,CAkBjE"}

package/dist/lib/api/getCollections.d.ts

@@ -80,7 +80,7 @@ export declare function getCollections({ collectionAddresses, apiClient, options
                         hasMore: boolean;
                         limit: number;
                         offset: number;
-                        total?: number | undefined;
+                        total: number;
                     } | undefined;
                 };
             };
@@ -201,7 +201,7 @@ export declare function getCollections({ collectionAddresses, apiClient, options
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -299,7 +299,7 @@ export declare function getCollections({ collectionAddresses, apiClient, options
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };

package/dist/lib/api/getIpAssetEdges.d.ts

@@ -62,7 +62,7 @@ export declare function getIpAssetEdges({ apiClient, ipId, parentIpId, options,
                         hasMore: boolean;
                         limit: number;
                         offset: number;
-                        total?: number | undefined;
+                        total: number;
                     } | undefined;
                 };
             };
@@ -165,7 +165,7 @@ export declare function getIpAssetEdges({ apiClient, ipId, parentIpId, options,
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -244,7 +244,7 @@ export declare function getIpAssetEdges({ apiClient, ipId, parentIpId, options,
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };

package/dist/lib/api/getIpAssets.d.ts

@@ -83,7 +83,7 @@ export declare function getIpAssets({ apiClient, ownerAddress, tokenContract, in
                                 hookData: string;
                                 isSet: boolean;
                                 licensingHook: string;
-                                mintingFee: number;
+                                mintingFee: string;
                             };
                             templateMetadataUri: string;
                             templateName: string;
@@ -191,7 +191,7 @@ export declare function getIpAssets({ apiClient, ownerAddress, tokenContract, in
                         hasMore: boolean;
                         limit: number;
                         offset: number;
-                        total?: number | undefined;
+                        total: number;
                     } | undefined;
                 };
             };
@@ -313,7 +313,7 @@ export declare function getIpAssets({ apiClient, ownerAddress, tokenContract, in
                                     hookData: string;
                                     isSet: boolean;
                                     licensingHook: string;
-                                    mintingFee: number;
+                                    mintingFee: string;
                                 };
                                 templateMetadataUri: string;
                                 templateName: string;
@@ -421,7 +421,7 @@ export declare function getIpAssets({ apiClient, ownerAddress, tokenContract, in
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };
@@ -518,7 +518,7 @@ export declare function getIpAssets({ apiClient, ownerAddress, tokenContract, in
                                     hookData: string;
                                     isSet: boolean;
                                     licensingHook: string;
-                                    mintingFee: number;
+                                    mintingFee: string;
                                 };
                                 templateMetadataUri: string;
                                 templateName: string;
@@ -626,7 +626,7 @@ export declare function getIpAssets({ apiClient, ownerAddress, tokenContract, in
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                     };
                 };

package/dist/lib/api/getLicenseTokens.d.ts

@@ -0,0 +1,273 @@
+import { paths } from "@/types/schema";
+import { Address } from "viem";
+import { ApiClient } from "./apiClient";
+export type LicenseTokensResponse = paths["/licenses/tokens"]["post"]["responses"][200]["content"]["application/json"];
+export type LicenseTokensOptions = Partial<paths["/licenses/tokens"]["post"]["requestBody"]["content"]["application/json"]>;
+export type GetLicenseTokensOptions = {
+    apiClient: ApiClient;
+    ownerAddress?: Address;
+    licensorIpId?: Address;
+    options?: LicenseTokensOptions;
+    apiKey: string;
+};
+export declare function getLicenseTokens({ apiClient, ownerAddress, licensorIpId, options, apiKey }: GetLicenseTokensOptions): Promise<import("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?: import("openapi-fetch").QuerySerializerOptions | import("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?: import("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 import("openapi-fetch").BodyType<unknown> | undefined;
+    fetch?: ((input: Request) => Promise<Response>) | undefined;
+    headers?: import("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}`>>;
+//# sourceMappingURL=getLicenseTokens.d.ts.map

package/dist/lib/api/getLicenseTokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLicenseTokens.d.ts","sourceRoot":"","sources":["../../../src/lib/api/getLicenseTokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAE9B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGvC,MAAM,MAAM,qBAAqB,GAAG,KAAK,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,kBAAkB,CAAC,CAAA;AACtH,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACxC,KAAK,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,kBAAkB,CAAC,CAChF,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,SAAS,EAAE,SAAS,CAAA;IACpB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,OAAO,CAAC,EAAE,oBAAoB,CAAA;IAC9B,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,gBAAgB,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAgBnH"}

package/dist/lib/api/getSearch.d.ts

@@ -49,7 +49,7 @@ export declare function getSearch({ apiClient, query, mediaType, options, apiKey
                         hasMore: boolean;
                         limit: number;
                         offset: number;
-                        total?: number | undefined;
+                        total: number;
                     } | undefined;
                     total: number;
                 };
@@ -135,7 +135,7 @@ export declare function getSearch({ apiClient, query, mediaType, options, apiKey
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                         total: number;
                     };
@@ -203,7 +203,7 @@ export declare function getSearch({ apiClient, query, mediaType, options, apiKey
                             hasMore: boolean;
                             limit: number;
                             offset: number;
-                            total?: number | undefined;
+                            total: number;
                         } | undefined;
                         total: number;
                     };