@mycelium-ip/react 0.1.0-alpha.0

package/dist/hooks/ip/useCreateIp.js

@@ -0,0 +1,43 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to create a new IP (Intellectual Property) asset.
+ *
+ * @example
+ * ```tsx
+ * function CreateIpButton({ entityPubkey }: { entityPubkey: PublicKey }) {
+ *   const { mutate, isPending } = useCreateIp();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       registrantEntity: entityPubkey,
+ *       content: new TextEncoder().encode("ip-content-hash"),
+ *       treasuryTokenAccount: treasuryAccount,
+ *       payerTokenAccount: payerAccount,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Create IP
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useCreateIp() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.ipCore.ip.createIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.ips() });
+        },
+    });
+}

package/dist/hooks/ip/useTransferIp.d.ts

@@ -0,0 +1,28 @@
+import type { TransferIpParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to transfer IP ownership to another entity.
+ *
+ * @example
+ * ```tsx
+ * function TransferIpButton({ ipPubkey, currentOwner, newOwner }: Props) {
+ *   const { mutate, isPending } = useTransferIp();
+ *
+ *   const handleTransfer = () => {
+ *     mutate({
+ *       ip: ipPubkey,
+ *       currentOwnerEntity: currentOwner,
+ *       newOwnerEntity: newOwner,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleTransfer} disabled={isPending}>
+ *       Transfer IP
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useTransferIp(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, TransferIpParams, unknown>;
+//# sourceMappingURL=useTransferIp.d.ts.map

package/dist/hooks/ip/useTransferIp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTransferIp.d.ts","sourceRoot":"","sources":["../../../src/hooks/ip/useTransferIp.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,2GAa5B"}

package/dist/hooks/ip/useTransferIp.js

@@ -0,0 +1,42 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to transfer IP ownership to another entity.
+ *
+ * @example
+ * ```tsx
+ * function TransferIpButton({ ipPubkey, currentOwner, newOwner }: Props) {
+ *   const { mutate, isPending } = useTransferIp();
+ *
+ *   const handleTransfer = () => {
+ *     mutate({
+ *       ip: ipPubkey,
+ *       currentOwnerEntity: currentOwner,
+ *       newOwnerEntity: newOwner,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleTransfer} disabled={isPending}>
+ *       Transfer IP
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useTransferIp() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.ipCore.ip.transferIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.ips() });
+        },
+    });
+}

package/dist/hooks/license/useCreateLicense.d.ts

@@ -0,0 +1,28 @@
+import type { CreateLicenseParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to create a new license for an IP.
+ *
+ * @example
+ * ```tsx
+ * function CreateLicenseButton({ originIp, ownerEntity }: Props) {
+ *   const { mutate, isPending } = useCreateLicense();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       originIp,
+ *       ownerEntity,
+ *       derivativesAllowed: true,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Create License
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useCreateLicense(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateLicenseParams, unknown>;
+//# sourceMappingURL=useCreateLicense.d.ts.map

package/dist/hooks/license/useCreateLicense.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateLicense.d.ts","sourceRoot":"","sources":["../../../src/hooks/license/useCreateLicense.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,8GAa/B"}

package/dist/hooks/license/useCreateLicense.js

@@ -0,0 +1,42 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to create a new license for an IP.
+ *
+ * @example
+ * ```tsx
+ * function CreateLicenseButton({ originIp, ownerEntity }: Props) {
+ *   const { mutate, isPending } = useCreateLicense();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       originIp,
+ *       ownerEntity,
+ *       derivativesAllowed: true,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Create License
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useCreateLicense() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.license.license.createIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.licenses() });
+        },
+    });
+}

package/dist/hooks/license/useRevokeLicense.d.ts

@@ -0,0 +1,27 @@
+import type { RevokeLicenseParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to revoke a license.
+ *
+ * @example
+ * ```tsx
+ * function RevokeLicenseButton({ originIp, authorityEntity }: Props) {
+ *   const { mutate, isPending } = useRevokeLicense();
+ *
+ *   const handleRevoke = () => {
+ *     mutate({
+ *       originIp,
+ *       authorityEntity,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleRevoke} disabled={isPending}>
+ *       Revoke License
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useRevokeLicense(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, RevokeLicenseParams, unknown>;
+//# sourceMappingURL=useRevokeLicense.d.ts.map

package/dist/hooks/license/useRevokeLicense.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRevokeLicense.d.ts","sourceRoot":"","sources":["../../../src/hooks/license/useRevokeLicense.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,8GAa/B"}

package/dist/hooks/license/useRevokeLicense.js

@@ -0,0 +1,41 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to revoke a license.
+ *
+ * @example
+ * ```tsx
+ * function RevokeLicenseButton({ originIp, authorityEntity }: Props) {
+ *   const { mutate, isPending } = useRevokeLicense();
+ *
+ *   const handleRevoke = () => {
+ *     mutate({
+ *       originIp,
+ *       authorityEntity,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleRevoke} disabled={isPending}>
+ *       Revoke License
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useRevokeLicense() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.license.license.revokeIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.licenses() });
+        },
+    });
+}

package/dist/hooks/license/useUpdateLicense.d.ts

@@ -0,0 +1,28 @@
+import type { UpdateLicenseParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to update an existing license.
+ *
+ * @example
+ * ```tsx
+ * function UpdateLicenseButton({ originIp, authorityEntity }: Props) {
+ *   const { mutate, isPending } = useUpdateLicense();
+ *
+ *   const handleUpdate = () => {
+ *     mutate({
+ *       originIp,
+ *       authorityEntity,
+ *       derivativesAllowed: false,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleUpdate} disabled={isPending}>
+ *       Update License
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useUpdateLicense(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, UpdateLicenseParams, unknown>;
+//# sourceMappingURL=useUpdateLicense.d.ts.map

package/dist/hooks/license/useUpdateLicense.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdateLicense.d.ts","sourceRoot":"","sources":["../../../src/hooks/license/useUpdateLicense.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,8GAa/B"}

package/dist/hooks/license/useUpdateLicense.js

@@ -0,0 +1,42 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to update an existing license.
+ *
+ * @example
+ * ```tsx
+ * function UpdateLicenseButton({ originIp, authorityEntity }: Props) {
+ *   const { mutate, isPending } = useUpdateLicense();
+ *
+ *   const handleUpdate = () => {
+ *     mutate({
+ *       originIp,
+ *       authorityEntity,
+ *       derivativesAllowed: false,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleUpdate} disabled={isPending}>
+ *       Update License
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useUpdateLicense() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.license.license.updateIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.licenses() });
+        },
+    });
+}

package/dist/hooks/metadata/useCreateEntityMetadata.d.ts

@@ -0,0 +1,30 @@
+import type { CreateEntityMetadataParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to create metadata for an entity.
+ *
+ * @example
+ * ```tsx
+ * function AddEntityMetadata({ entityPubkey, schemaPubkey }: Props) {
+ *   const { mutate, isPending } = useCreateEntityMetadata();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       entity: entityPubkey,
+ *       schema: schemaPubkey,
+ *       revision: 1n,
+ *       data: new TextEncoder().encode(JSON.stringify(metadata)),
+ *       cid: "Qm...",
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Add Metadata
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useCreateEntityMetadata(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateEntityMetadataParams, unknown>;
+//# sourceMappingURL=useCreateEntityMetadata.d.ts.map

package/dist/hooks/metadata/useCreateEntityMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateEntityMetadata.d.ts","sourceRoot":"","sources":["../../../src/hooks/metadata/useCreateEntityMetadata.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAExE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,uBAAuB,qHAetC"}

package/dist/hooks/metadata/useCreateEntityMetadata.js

@@ -0,0 +1,45 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to create metadata for an entity.
+ *
+ * @example
+ * ```tsx
+ * function AddEntityMetadata({ entityPubkey, schemaPubkey }: Props) {
+ *   const { mutate, isPending } = useCreateEntityMetadata();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       entity: entityPubkey,
+ *       schema: schemaPubkey,
+ *       revision: 1n,
+ *       data: new TextEncoder().encode(JSON.stringify(metadata)),
+ *       cid: "Qm...",
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Add Metadata
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useCreateEntityMetadata() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.ipCore.metadata.createEntityMetadataIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.entities() });
+            queryClient.invalidateQueries({ queryKey: queryKeys.metadata() });
+        },
+    });
+}

package/dist/hooks/metadata/useCreateIpMetadata.d.ts

@@ -0,0 +1,31 @@
+import type { CreateIpMetadataParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to create metadata for an IP.
+ *
+ * @example
+ * ```tsx
+ * function AddIpMetadata({ ipPubkey, ownerEntity, schemaPubkey }: Props) {
+ *   const { mutate, isPending } = useCreateIpMetadata();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       ip: ipPubkey,
+ *       ownerEntity: ownerEntity,
+ *       schema: schemaPubkey,
+ *       revision: 1n,
+ *       data: new TextEncoder().encode(JSON.stringify(metadata)),
+ *       cid: "Qm...",
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Add IP Metadata
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useCreateIpMetadata(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateIpMetadataParams, unknown>;
+//# sourceMappingURL=useCreateIpMetadata.d.ts.map

package/dist/hooks/metadata/useCreateIpMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateIpMetadata.d.ts","sourceRoot":"","sources":["../../../src/hooks/metadata/useCreateIpMetadata.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAEpE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,iHAelC"}

package/dist/hooks/metadata/useCreateIpMetadata.js

@@ -0,0 +1,46 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to create metadata for an IP.
+ *
+ * @example
+ * ```tsx
+ * function AddIpMetadata({ ipPubkey, ownerEntity, schemaPubkey }: Props) {
+ *   const { mutate, isPending } = useCreateIpMetadata();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       ip: ipPubkey,
+ *       ownerEntity: ownerEntity,
+ *       schema: schemaPubkey,
+ *       revision: 1n,
+ *       data: new TextEncoder().encode(JSON.stringify(metadata)),
+ *       cid: "Qm...",
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Add IP Metadata
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useCreateIpMetadata() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.ipCore.metadata.createIpMetadataIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.ips() });
+            queryClient.invalidateQueries({ queryKey: queryKeys.metadata() });
+        },
+    });
+}

package/dist/hooks/metadata/useCreateMetadataSchema.d.ts

@@ -0,0 +1,29 @@
+import type { CreateMetadataSchemaParams } from "@mycelium-ip/core-sdk";
+import { type TransactionResult } from "../../utils/transaction";
+/**
+ * Hook to create a new metadata schema.
+ *
+ * @example
+ * ```tsx
+ * function CreateSchemaButton() {
+ *   const { mutate, isPending } = useCreateMetadataSchema();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       id: "my-schema",
+ *       version: "1.0.0",
+ *       data: new TextEncoder().encode(JSON.stringify(schemaDefinition)),
+ *       cid: "Qm...",
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Create Schema
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useCreateMetadataSchema(): import("@tanstack/react-query").UseMutationResult<TransactionResult, Error, CreateMetadataSchemaParams, unknown>;
+//# sourceMappingURL=useCreateMetadataSchema.d.ts.map

package/dist/hooks/metadata/useCreateMetadataSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateMetadataSchema.d.ts","sourceRoot":"","sources":["../../../src/hooks/metadata/useCreateMetadataSchema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AAExE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,uBAAuB,qHAatC"}

package/dist/hooks/metadata/useCreateMetadataSchema.js

@@ -0,0 +1,43 @@
+"use client";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { executeTransaction, } from "../../utils/transaction";
+import { useMyceliumContext } from "../internal/useMyceliumContext";
+import { queryKeys } from "../queries/queryKeys";
+/**
+ * Hook to create a new metadata schema.
+ *
+ * @example
+ * ```tsx
+ * function CreateSchemaButton() {
+ *   const { mutate, isPending } = useCreateMetadataSchema();
+ *
+ *   const handleCreate = () => {
+ *     mutate({
+ *       id: "my-schema",
+ *       version: "1.0.0",
+ *       data: new TextEncoder().encode(JSON.stringify(schemaDefinition)),
+ *       cid: "Qm...",
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={isPending}>
+ *       Create Schema
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useCreateMetadataSchema() {
+    const { client, connection, wallet, confirmation } = useMyceliumContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const instruction = await client.ipCore.metadata.createSchemaIx(params);
+            return executeTransaction(connection, wallet, instruction, confirmation);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.metadata() });
+        },
+    });
+}

package/dist/hooks/queries/queryKeys.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Query key factory for TanStack Query.
+ *
+ * Provides a structured, type-safe way to define query keys
+ * for granular cache invalidation.
+ *
+ * @example
+ * ```ts
+ * // Invalidate all mycelium queries
+ * queryClient.invalidateQueries({ queryKey: queryKeys.all });
+ *
+ * // Invalidate specific entity
+ * queryClient.invalidateQueries({ queryKey: queryKeys.entity("123") });
+ *
+ * // Invalidate all IPs
+ * queryClient.invalidateQueries({ queryKey: queryKeys.ips() });
+ * ```
+ */
+export declare const queryKeys: {
+    /** Root key for all mycelium queries */
+    all: readonly ["mycelium"];
+    /** Key for all entity queries */
+    entities: () => readonly ["mycelium", "entities"];
+    /** Key for a specific entity */
+    entity: (id: string) => readonly ["mycelium", "entities", string];
+    /** Key for all IP queries */
+    ips: () => readonly ["mycelium", "ips"];
+    /** Key for a specific IP */
+    ip: (id: string) => readonly ["mycelium", "ips", string];
+    /** Key for all license queries */
+    licenses: () => readonly ["mycelium", "licenses"];
+    /** Key for a specific license */
+    license: (id: string) => readonly ["mycelium", "licenses", string];
+    /** Key for all grant queries */
+    grants: () => readonly ["mycelium", "grants"];
+    /** Key for a specific grant */
+    grant: (id: string) => readonly ["mycelium", "grants", string];
+    /** Key for all metadata queries */
+    metadata: () => readonly ["mycelium", "metadata"];
+    /** Key for all derivative queries */
+    derivatives: () => readonly ["mycelium", "derivatives"];
+    /** Key for a specific derivative */
+    derivative: (id: string) => readonly ["mycelium", "derivatives", string];
+};
+//# sourceMappingURL=queryKeys.d.ts.map

package/dist/hooks/queries/queryKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryKeys.d.ts","sourceRoot":"","sources":["../../../src/hooks/queries/queryKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS;IACpB,wCAAwC;;IAGxC,iCAAiC;;IAGjC,gCAAgC;iBACnB,MAAM;IAEnB,6BAA6B;;IAG7B,4BAA4B;aACnB,MAAM;IAEf,kCAAkC;;IAGlC,iCAAiC;kBACnB,MAAM;IAEpB,gCAAgC;;IAGhC,+BAA+B;gBACnB,MAAM;IAElB,mCAAmC;;IAGnC,qCAAqC;;IAGrC,oCAAoC;qBACnB,MAAM;CACxB,CAAC"}