@story-protocol/ipkit 0.4.0-beta.9

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

@@ -0,0 +1,18 @@
+import type { paths } from "@/types/schema";
+import { FetchOptions } from "openapi-fetch";
+import { HttpMethod, PathsWithMethod } from "openapi-typescript-helpers";
+import { ApiClient } from "./apiClient";
+type Paths<M extends HttpMethod> = PathsWithMethod<paths, M>;
+type Params<M extends HttpMethod, P extends Paths<M>> = M extends keyof paths[P] ? FetchOptions<paths[P][M]> : never;
+export type GetQueryParams<P extends Paths<"get">> = {
+    apiClient: ApiClient;
+    path: P;
+    apiKey: string;
+    pathParams?: Params<"get", P>["params"] extends {
+        path: any;
+    } ? Params<"get", P>["params"]["path"] : never;
+    additionalHeaders?: Record<string, string>;
+};
+export declare function getQuery<P extends Paths<"get">>({ apiClient, path, apiKey, pathParams, additionalHeaders, }: GetQueryParams<P>): Promise<import("openapi-fetch").FetchResponse<paths[P]["get"], Params<"get", P>, `${string}/${string}`>>;
+export {};
+//# sourceMappingURL=getQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getQuery.d.ts","sourceRoot":"","sources":["../../../src/lib/api/getQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAExE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC,KAAK,KAAK,CAAC,CAAC,SAAS,UAAU,IAAI,eAAe,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;AAC5D,KAAK,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,KAAK,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;AAEpH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,KAAK,CAAC,KAAK,CAAC,IAAI;IACnD,SAAS,EAAE,SAAS,CAAA;IACpB,IAAI,EAAE,CAAC,CAAA;IACP,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS;QAAE,IAAI,EAAE,GAAG,CAAA;KAAE,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,KAAK,CAAA;IAC1G,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3C,CAAA;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,CAAC,KAAK,CAAC,EAAE,EAC/C,SAAS,EACT,IAAI,EACJ,MAAM,EACN,UAAU,EACV,iBAAiB,GAClB,EAAE,cAAc,CAAC,CAAC,CAAC,4GAYnB"}

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

@@ -0,0 +1,246 @@
+import { paths } from "@/types/schema";
+import { ApiClient } from "./apiClient";
+export type SearchResponse = paths["/search"]["post"]["responses"][200]["content"]["application/json"];
+export type SearchOptions = Partial<paths["/search"]["post"]["requestBody"]["content"]["application/json"]>;
+export type GetSearchOptions = {
+    apiClient: ApiClient;
+    query: string;
+    mediaType?: "audio" | "video" | "image";
+    options?: SearchOptions;
+    apiKey: string;
+};
+export declare function getSearch({ apiClient, query, mediaType, options, apiKey }: GetSearchOptions): Promise<import("openapi-fetch").FetchResponse<{
+    parameters: {
+        query?: undefined;
+        header?: undefined;
+        path?: undefined;
+        cookie?: undefined;
+    };
+    requestBody: {
+        content: {
+            "application/json": {
+                readonly $schema?: string | undefined;
+                mediaType?: "audio" | "video" | "image" | undefined;
+                pagination?: {
+                    limit: number;
+                    offset: number;
+                } | undefined;
+                query: string;
+            };
+        };
+    };
+    responses: {
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": {
+                    readonly $schema?: string | undefined;
+                    data: {
+                        description: string;
+                        ipId: string;
+                        mediaType: string;
+                        score: number;
+                        similarity: number;
+                        title: string;
+                    }[] | null;
+                    pagination?: {
+                        hasMore: boolean;
+                        limit: number;
+                        offset: number;
+                        total?: number | undefined;
+                    } | undefined;
+                    total: number;
+                };
+            };
+        };
+        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;
+        mediaType?: "audio" | "video" | "image" | undefined;
+        pagination?: {
+            limit: number;
+            offset: number;
+        } | undefined;
+        query: string;
+    };
+} & {
+    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;
+                    mediaType?: "audio" | "video" | "image" | undefined;
+                    pagination?: {
+                        limit: number;
+                        offset: number;
+                    } | undefined;
+                    query: string;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        readonly $schema?: string | undefined;
+                        data: {
+                            description: string;
+                            ipId: string;
+                            mediaType: string;
+                            score: number;
+                            similarity: number;
+                            title: string;
+                        }[] | null;
+                        pagination?: {
+                            hasMore: boolean;
+                            limit: number;
+                            offset: number;
+                            total?: number | undefined;
+                        } | undefined;
+                        total: number;
+                    };
+                };
+            };
+            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;
+                    mediaType?: "audio" | "video" | "image" | undefined;
+                    pagination?: {
+                        limit: number;
+                        offset: number;
+                    } | undefined;
+                    query: string;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        readonly $schema?: string | undefined;
+                        data: {
+                            description: string;
+                            ipId: string;
+                            mediaType: string;
+                            score: number;
+                            similarity: number;
+                            title: string;
+                        }[] | null;
+                        pagination?: {
+                            hasMore: boolean;
+                            limit: number;
+                            offset: number;
+                            total?: number | undefined;
+                        } | undefined;
+                        total: number;
+                    };
+                };
+            };
+            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;
+    mediaType?: "audio" | "video" | "image" | undefined;
+    pagination?: {
+        limit: number;
+        offset: number;
+    } | undefined;
+    query: string;
+}, `${string}/${string}`>>;
+//# sourceMappingURL=getSearch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getSearch.d.ts","sourceRoot":"","sources":["../../../src/lib/api/getSearch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAEtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGvC,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,kBAAkB,CAAC,CAAA;AAEtG,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAA;AAE3G,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE,SAAS,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAA;IACvC,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,SAAS,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAW3F"}

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

@@ -0,0 +1,292 @@
+import { paths } from "@/types/schema";
+import { Address } from "viem";
+import { ApiClient } from "./apiClient";
+export type TransactionsResponse = paths["/transactions"]["post"]["responses"][200]["content"]["application/json"];
+export type TransactionsOptions = Partial<paths["/transactions"]["post"]["requestBody"]["content"]["application/json"]>;
+export type GetTransactionsOptions = {
+    apiClient: ApiClient;
+    txHashes?: Address[];
+    ipIds?: Address[];
+    initiators?: Address[];
+    eventTypes?: string[];
+    options?: TransactionsOptions;
+    apiKey: string;
+};
+export declare function getTransactions({ apiClient, txHashes, ipIds, initiators, eventTypes, options, apiKey, }: GetTransactionsOptions): Promise<import("openapi-fetch").FetchResponse<{
+    parameters: {
+        query?: undefined;
+        header?: undefined;
+        path?: undefined;
+        cookie?: undefined;
+    };
+    requestBody: {
+        content: {
+            "application/json": {
+                readonly $schema?: string | undefined;
+                orderBy: "blockNumber" | "createdAt" | "eventType" | "txHash" | "ipId" | "initiator";
+                orderDirection: "asc" | "desc";
+                pagination?: {
+                    limit: number;
+                    offset: number;
+                } | undefined;
+                where?: {
+                    blockGte?: number | undefined;
+                    blockLte?: number | undefined;
+                    eventTypes?: string[] | null | undefined;
+                    initiators?: string[] | null | undefined;
+                    ipIds?: string[] | null | undefined;
+                    txHashes?: string[] | null | undefined;
+                } | undefined;
+            };
+        };
+    };
+    responses: {
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": {
+                    readonly $schema?: string | undefined;
+                    data: {
+                        blockNumber: number;
+                        createdAt: string;
+                        eventType: string;
+                        id: number;
+                        initiator: string;
+                        ipId: string;
+                        logIndex: number;
+                        txHash: string;
+                    }[] | null;
+                    pagination?: {
+                        hasMore: boolean;
+                        limit: number;
+                        offset: number;
+                        total?: number | undefined;
+                    } | 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" | "createdAt" | "eventType" | "txHash" | "ipId" | "initiator";
+        orderDirection: "asc" | "desc";
+        pagination?: {
+            limit: number;
+            offset: number;
+        } | undefined;
+        where?: {
+            blockGte?: number | undefined;
+            blockLte?: number | undefined;
+            eventTypes?: string[] | null | undefined;
+            initiators?: string[] | null | undefined;
+            ipIds?: string[] | null | undefined;
+            txHashes?: string[] | null | 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" | "createdAt" | "eventType" | "txHash" | "ipId" | "initiator";
+                    orderDirection: "asc" | "desc";
+                    pagination?: {
+                        limit: number;
+                        offset: number;
+                    } | undefined;
+                    where?: {
+                        blockGte?: number | undefined;
+                        blockLte?: number | undefined;
+                        eventTypes?: string[] | null | undefined;
+                        initiators?: string[] | null | undefined;
+                        ipIds?: string[] | null | undefined;
+                        txHashes?: string[] | null | undefined;
+                    } | undefined;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        readonly $schema?: string | undefined;
+                        data: {
+                            blockNumber: number;
+                            createdAt: string;
+                            eventType: string;
+                            id: number;
+                            initiator: string;
+                            ipId: string;
+                            logIndex: number;
+                            txHash: string;
+                        }[] | null;
+                        pagination?: {
+                            hasMore: boolean;
+                            limit: number;
+                            offset: number;
+                            total?: number | undefined;
+                        } | 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" | "createdAt" | "eventType" | "txHash" | "ipId" | "initiator";
+                    orderDirection: "asc" | "desc";
+                    pagination?: {
+                        limit: number;
+                        offset: number;
+                    } | undefined;
+                    where?: {
+                        blockGte?: number | undefined;
+                        blockLte?: number | undefined;
+                        eventTypes?: string[] | null | undefined;
+                        initiators?: string[] | null | undefined;
+                        ipIds?: string[] | null | undefined;
+                        txHashes?: string[] | null | undefined;
+                    } | undefined;
+                };
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        readonly $schema?: string | undefined;
+                        data: {
+                            blockNumber: number;
+                            createdAt: string;
+                            eventType: string;
+                            id: number;
+                            initiator: string;
+                            ipId: string;
+                            logIndex: number;
+                            txHash: string;
+                        }[] | null;
+                        pagination?: {
+                            hasMore: boolean;
+                            limit: number;
+                            offset: number;
+                            total?: number | undefined;
+                        } | 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" | "createdAt" | "eventType" | "txHash" | "ipId" | "initiator";
+    orderDirection: "asc" | "desc";
+    pagination?: {
+        limit: number;
+        offset: number;
+    } | undefined;
+    where?: {
+        blockGte?: number | undefined;
+        blockLte?: number | undefined;
+        eventTypes?: string[] | null | undefined;
+        initiators?: string[] | null | undefined;
+        ipIds?: string[] | null | undefined;
+        txHashes?: string[] | null | undefined;
+    } | undefined;
+}, `${string}/${string}`>>;
+//# sourceMappingURL=getTransactions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getTransactions.d.ts","sourceRoot":"","sources":["../../../src/lib/api/getTransactions.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,oBAAoB,GAAG,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,kBAAkB,CAAC,CAAA;AAElH,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAA;AAEvH,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,SAAS,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;IACpB,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;IACjB,UAAU,CAAC,EAAE,OAAO,EAAE,CAAA;IACtB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB,OAAO,CAAC,EAAE,mBAAmB,CAAA;IAC7B,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,eAAe,CAAC,EAC9B,SAAS,EACT,QAAQ,EACR,KAAK,EACL,UAAU,EACV,UAAU,EACV,OAAO,EACP,MAAM,GACP,EAAE,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAkBxB"}

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

@@ -0,0 +1,9 @@
+export * from "./apiClient";
+export * from "./getCollections";
+export * from "./getDispute";
+export * from "./getDisputes";
+export * from "./getIpAssetEdges";
+export * from "./getIpAssets";
+export * from "./getSearch";
+export * from "./getTransactions";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,mBAAmB,CAAA"}

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

@@ -0,0 +1,16 @@
+import type { paths } from "@/types/schema";
+import { FetchOptions } from "openapi-fetch";
+import { HttpMethod, PathsWithMethod } from "openapi-typescript-helpers";
+import { ApiClient } from "./apiClient";
+type Paths<M extends HttpMethod> = PathsWithMethod<paths, M>;
+type Params<M extends HttpMethod, P extends Paths<M>> = M extends keyof paths[P] ? FetchOptions<paths[P][M]> : never;
+export type ListQueryParams<P extends Paths<"post">> = {
+    apiClient: ApiClient;
+    path: P;
+    apiKey: string;
+    body?: Params<"post", P>["body"];
+    additionalHeaders?: Record<string, string>;
+};
+export declare function listQuery<P extends Paths<"post">>({ apiClient, path, apiKey, body, additionalHeaders, }: ListQueryParams<P>): Promise<import("openapi-fetch").FetchResponse<paths[P]["post"], Params<"post", P> & Params<"post", P>["body"], `${string}/${string}`>>;
+export {};
+//# sourceMappingURL=listQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"listQuery.d.ts","sourceRoot":"","sources":["../../../src/lib/api/listQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAExE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC,KAAK,KAAK,CAAC,CAAC,SAAS,UAAU,IAAI,eAAe,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;AAC5D,KAAK,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,KAAK,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;AAEpH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,IAAI;IACrD,SAAS,EAAE,SAAS,CAAA;IACpB,IAAI,EAAE,CAAC,CAAA;IACP,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAA;IAChC,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3C,CAAA;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,EAAE,EACjD,SAAS,EACT,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,iBAAiB,GAClB,EAAE,eAAe,CAAC,CAAC,CAAC,0IAepB"}

package/dist/lib/functions/convertLicenseTermObject.d.ts

@@ -0,0 +1,6 @@
+import { Trait } from "@/types/assets";
+import { PILTerms } from "@/types/openapi";
+type LicenseTerms = Partial<PILTerms>;
+export declare function convertLicenseTermObject(licenseTerms: Trait[]): LicenseTerms;
+export {};
+//# sourceMappingURL=convertLicenseTermObject.d.ts.map

package/dist/lib/functions/convertLicenseTermObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertLicenseTermObject.d.ts","sourceRoot":"","sources":["../../../src/lib/functions/convertLicenseTermObject.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAI1C,KAAK,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;AAErC,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,KAAK,EAAE,GAAG,YAAY,CAM5E"}

package/dist/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./utils";
+export * from "./functions/convertLicenseTermObject";
+export * from "./api";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,sCAAsC,CAAA;AACpD,cAAc,OAAO,CAAA"}

package/dist/lib/utils.d.ts

@@ -0,0 +1,12 @@
+import { PilFlavor } from "@/types/assets";
+import { PILTerms } from "@/types/openapi";
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+export declare function shortenAddress(address: string, length?: number): string;
+export declare function camelize(str: string): string;
+export declare function getPilFlavorByLicenseTerms(pilTerms: PILTerms): PilFlavor;
+export declare function getImageUrlFromIpfsUrl(ipfsUrl: string): Promise<string>;
+export declare function convertIpfsUriToUrl(ipfsUri: string): string;
+export declare function getMetadataFromIpfs(ipfsUrl: string): Promise<any>;
+export declare function fetchLicenseOffChainData(uri: string): Promise<any>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,SAAS,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAC1C,OAAO,EAAE,KAAK,UAAU,EAAQ,MAAM,MAAM,CAAA;AAQ5C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,MAAM,CAYlE;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,UAKnC;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAiBxE;AAED,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,MAAM,mBAI3D;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAO3D;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,MAAM,gBAGxD;AAED,wBAAsB,wBAAwB,CAAC,GAAG,EAAE,MAAM,gBAazD"}

package/dist/providers/IpKitProvider/IpKitProvider.d.ts

@@ -0,0 +1,25 @@
+import { ApiClient } from "@/lib/api/apiClient";
+import { ChainConfig } from "@/types/chains";
+import React from "react";
+export type Mode = "light" | "dark" | undefined;
+export type Theme = "default" | "story" | string;
+export interface IpKitProviderOptions {
+    apiKey: string;
+    appId?: string;
+    children: React.ReactNode;
+    isTestnet?: boolean;
+    mode?: Mode;
+    theme?: Theme;
+}
+export declare const IpKitProvider: ({ apiKey, appId, children, isTestnet, mode, theme, }: IpKitProviderOptions) => React.JSX.Element;
+export declare const useIpKit: () => {
+    apiBaseUrl: string;
+    apiClient: ApiClient;
+    apiKey: string;
+    appId: string | undefined;
+    chain: ChainConfig;
+    mode: Mode;
+    theme: Theme;
+    themeClass: string;
+};
+//# sourceMappingURL=IpKitProvider.d.ts.map