@ensforge/react 0.1.0 → 0.1.1

package/dist/hooks/registration.d.ts

@@ -1,11 +1,11 @@
-import { UseEnsQueryParameters } from "../query/options.js";
-import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters } from "./use-suspense-query.js";
-import { EnsQueryResult } from "../query/result.js";
+import { UseEnsAtomParameters } from "../query/options.js";
+import { EnsSuspenseAtomResult, UseEnsSuspenseAtomParameters } from "./use-suspense-query.js";
+import { EnsAtomResult } from "../query/result.js";
 import { EnsMutationOptions } from "../mutation/options.js";
 import { EnsMutationResult } from "../mutation/result.js";
 import "../index.js";
 //#region src/hooks/registration.d.ts
-declare const useCommitmentStatus: <Selected = {
+declare const useCommitmentStatus: <Mapped = {
   readonly status: "not-found";
   readonly protocol: "v1" | "v2";
 } | {
@@ -28,7 +28,7 @@ declare const useCommitmentStatus: <Selected = {
   readonly submittedAt: bigint;
   readonly readyAt: bigint;
   readonly expiresAt: bigint;
-}>(input: UseEnsQueryParameters<import("@ensforge/core").GetCommitmentStatusParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").GetCommitmentStatusParameters, {
   readonly status: "not-found";
   readonly protocol: "v1" | "v2";
 } | {
@@ -51,8 +51,8 @@ declare const useCommitmentStatus: <Selected = {
   readonly submittedAt: bigint;
   readonly readyAt: bigint;
   readonly expiresAt: bigint;
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetCommitmentStatusError>;
-declare const useCommitmentStatusSuspense: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetCommitmentStatusError>;
+declare const useCommitmentStatusSuspense: <Mapped = {
   readonly status: "not-found";
   readonly protocol: "v1" | "v2";
 } | {
@@ -75,7 +75,7 @@ declare const useCommitmentStatusSuspense: <Selected = {
   readonly submittedAt: bigint;
   readonly readyAt: bigint;
   readonly expiresAt: bigint;
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetCommitmentStatusParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetCommitmentStatusParameters, {
   readonly status: "not-found";
   readonly protocol: "v1" | "v2";
 } | {
@@ -98,8 +98,8 @@ declare const useCommitmentStatusSuspense: <Selected = {
   readonly submittedAt: bigint;
   readonly readyAt: bigint;
   readonly expiresAt: bigint;
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useRegistrationParameters: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useRegistrationParameters: <Mapped = {
   readonly protocol: "v1";
   readonly registrar: `0x${string}`;
   readonly priceOracle: `0x${string}`;
@@ -122,7 +122,7 @@ declare const useRegistrationParameters: <Selected = {
     readonly kind: "erc20";
     readonly enumerable: false;
   };
-}>(input: UseEnsQueryParameters<import("@ensforge/core").BlockParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").BlockParameters, {
   readonly protocol: "v1";
   readonly registrar: `0x${string}`;
   readonly priceOracle: `0x${string}`;
@@ -145,8 +145,8 @@ declare const useRegistrationParameters: <Selected = {
     readonly kind: "erc20";
     readonly enumerable: false;
   };
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetCommitmentStatusError>;
-declare const useRegistrationParametersSuspense: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetCommitmentStatusError>;
+declare const useRegistrationParametersSuspense: <Mapped = {
   readonly protocol: "v1";
   readonly registrar: `0x${string}`;
   readonly priceOracle: `0x${string}`;
@@ -169,7 +169,7 @@ declare const useRegistrationParametersSuspense: <Selected = {
     readonly kind: "erc20";
     readonly enumerable: false;
   };
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").BlockParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").BlockParameters, {
   readonly protocol: "v1";
   readonly registrar: `0x${string}`;
   readonly priceOracle: `0x${string}`;
@@ -192,8 +192,8 @@ declare const useRegistrationParametersSuspense: <Selected = {
     readonly kind: "erc20";
     readonly enumerable: false;
   };
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useRegistrationPlan: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useRegistrationPlan: <Mapped = {
   readonly status: "unavailable";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
 } | {
@@ -294,7 +294,7 @@ declare const useRegistrationPlan: <Selected = {
     readonly readyAt: bigint;
     readonly expiresAt: bigint;
   };
-}>(input: UseEnsQueryParameters<import("@ensforge/core").GetRegistrationPlanParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").GetRegistrationPlanParameters, {
   readonly status: "unavailable";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
 } | {
@@ -395,8 +395,8 @@ declare const useRegistrationPlan: <Selected = {
     readonly readyAt: bigint;
     readonly expiresAt: bigint;
   };
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetCommitmentStatusError>;
-declare const useRegistrationPlanSuspense: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetCommitmentStatusError>;
+declare const useRegistrationPlanSuspense: <Mapped = {
   readonly status: "unavailable";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
 } | {
@@ -497,7 +497,7 @@ declare const useRegistrationPlanSuspense: <Selected = {
     readonly readyAt: bigint;
     readonly expiresAt: bigint;
   };
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetRegistrationPlanParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetRegistrationPlanParameters, {
   readonly status: "unavailable";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
 } | {
@@ -598,8 +598,8 @@ declare const useRegistrationPlanSuspense: <Selected = {
     readonly readyAt: bigint;
     readonly expiresAt: bigint;
   };
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useRegistrationPrice: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useRegistrationPrice: <Mapped = {
   readonly status: "available";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
@@ -632,7 +632,7 @@ declare const useRegistrationPrice: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly paymentToken: `0x${string}`;
-}>(input: UseEnsQueryParameters<import("@ensforge/core").GetRegistrationPriceParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").GetRegistrationPriceParameters, {
   readonly status: "available";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
@@ -665,8 +665,8 @@ declare const useRegistrationPrice: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly paymentToken: `0x${string}`;
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetCommitmentStatusError>;
-declare const useRegistrationPriceSuspense: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetCommitmentStatusError>;
+declare const useRegistrationPriceSuspense: <Mapped = {
   readonly status: "available";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
@@ -699,7 +699,7 @@ declare const useRegistrationPriceSuspense: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly paymentToken: `0x${string}`;
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetRegistrationPriceParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetRegistrationPriceParameters, {
   readonly status: "available";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
@@ -732,8 +732,8 @@ declare const useRegistrationPriceSuspense: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly paymentToken: `0x${string}`;
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useRenewalPrice: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useRenewalPrice: <Mapped = {
   readonly status: "payment-token-required";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
@@ -765,7 +765,7 @@ declare const useRenewalPrice: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly reason: "NAME_NOT_RENEWABLE";
-}>(input: UseEnsQueryParameters<import("@ensforge/core").GetRegistrationPriceParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").GetRegistrationPriceParameters, {
   readonly status: "payment-token-required";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
@@ -797,8 +797,8 @@ declare const useRenewalPrice: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly reason: "NAME_NOT_RENEWABLE";
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetCommitmentStatusError>;
-declare const useRenewalPriceSuspense: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetCommitmentStatusError>;
+declare const useRenewalPriceSuspense: <Mapped = {
   readonly status: "payment-token-required";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
@@ -830,7 +830,7 @@ declare const useRenewalPriceSuspense: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly reason: "NAME_NOT_RENEWABLE";
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetRegistrationPriceParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetRegistrationPriceParameters, {
   readonly status: "payment-token-required";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
@@ -862,8 +862,8 @@ declare const useRenewalPriceSuspense: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly reason: "NAME_NOT_RENEWABLE";
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useIsPaymentTokenSupported: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useIsPaymentTokenSupported: <Mapped = {
   readonly protocol: "v1";
   readonly supported: false;
   readonly reason: "NATIVE_PAYMENT_ONLY";
@@ -878,7 +878,7 @@ declare const useIsPaymentTokenSupported: <Selected = {
   readonly token: `0x${string}`;
   readonly symbol: string;
   readonly decimals: number;
-}>(input: UseEnsQueryParameters<import("@ensforge/core").IsPaymentTokenSupportedParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").IsPaymentTokenSupportedParameters, {
   readonly protocol: "v1";
   readonly supported: false;
   readonly reason: "NATIVE_PAYMENT_ONLY";
@@ -893,8 +893,8 @@ declare const useIsPaymentTokenSupported: <Selected = {
   readonly token: `0x${string}`;
   readonly symbol: string;
   readonly decimals: number;
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetCommitmentStatusError>;
-declare const useIsPaymentTokenSupportedSuspense: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetCommitmentStatusError>;
+declare const useIsPaymentTokenSupportedSuspense: <Mapped = {
   readonly protocol: "v1";
   readonly supported: false;
   readonly reason: "NATIVE_PAYMENT_ONLY";
@@ -909,7 +909,7 @@ declare const useIsPaymentTokenSupportedSuspense: <Selected = {
   readonly token: `0x${string}`;
   readonly symbol: string;
   readonly decimals: number;
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").IsPaymentTokenSupportedParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").IsPaymentTokenSupportedParameters, {
   readonly protocol: "v1";
   readonly supported: false;
   readonly reason: "NATIVE_PAYMENT_ONLY";
@@ -924,29 +924,29 @@ declare const useIsPaymentTokenSupportedSuspense: <Selected = {
   readonly token: `0x${string}`;
   readonly symbol: string;
   readonly decimals: number;
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useRegistrationCommitment: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useRegistrationCommitment: <Mapped = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly registrar: `0x${string}`;
   readonly commitment: `0x${string}`;
-}>(input: UseEnsQueryParameters<import("@ensforge/core").MakeRegistrationCommitmentParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").MakeRegistrationCommitmentParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly registrar: `0x${string}`;
   readonly commitment: `0x${string}`;
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetCommitmentStatusError>;
-declare const useRegistrationCommitmentSuspense: <Selected = {
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetCommitmentStatusError>;
+declare const useRegistrationCommitmentSuspense: <Mapped = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly registrar: `0x${string}`;
   readonly commitment: `0x${string}`;
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").MakeRegistrationCommitmentParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").MakeRegistrationCommitmentParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly registrar: `0x${string}`;
   readonly commitment: `0x${string}`;
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
+}, import("@ensforge/core").GetCommitmentStatusError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
 declare const useApprovePaymentToken: (options?: EnsMutationOptions<import("@ensforge/core").ApprovePaymentTokenParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").ApprovePaymentTokenParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const useApproveRenewalPayment: (options?: EnsMutationOptions<import("@ensforge/core").ApproveRenewalPaymentParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").ApproveRenewalPaymentParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const useCommitName: (options?: EnsMutationOptions<import("@ensforge/core").CommitNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").CommitNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;

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

@@ -1 +1 @@
-{"version":3,"file":"registration.d.ts","names":[],"sources":["../../src/hooks/registration.ts"],"mappings":";;;;;;;cAuBa,sBAAmB;;;;;;;;;;;;;;;;;;;;;;;UAAyC;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cAC5D,8BAA2B;;;;;;;;;;;;;;;;;;;;;;;UAAiD;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cAC5E,4BAAyB;;;;;;;;;;;;;;;;;;;;;;;UAA+C;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cACxE,oCAAiC;;;;;;;;;;;;;;;;;;;;;;;UAE7C;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cACY,sBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cAC5D,8BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cAC5E,uBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cAC9D,+BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cAC9E,kBAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cACpD,0BAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cACpE,6BAA0B;;;;;;;;;;;;;;;UAA6C;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cACvE,qCAAkC;;;;;;;;;;;;;;;UAE9C;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cACY,4BAAyB;;;;;UAAgD;;;;;GAAA,cAAA,eAAA,mCAAA;cACzE,oCAAiC;;;;;UAE7C;;;;;GAAA,cAAA,uBAAA;cAEY,yBAAsB,UAAtB,4CAAsB,wDAAA,8CAAA,gBAAA,2CAAA,wDAAA,8CAAA;cACtB,2BAAwB,UAAxB,4CAAwB,0DAAA,8CAAA,gBAAA,2CAAA,0DAAA,8CAAA;cACxB,gBAAa,UAAb,4CAAa,+CAAA,8CAAA,gBAAA,2CAAA,+CAAA,8CAAA;cACb,0BAAuB,UAAvB,4CAAuB,yDAAA,8CAAA,gBAAA,2CAAA,yDAAA,8CAAA;cACvB,kBAAe,UAAf,4CAAe,iDAAA,6CAAA,gBAAA,2CAAA,iDAAA,6CAAA;cACf,mBAAgB,UAAhB,4CAAgB,kDAAA,8CAAA,gBAAA,2CAAA,kDAAA,8CAAA;cAChB,eAAY,UAAZ,4CAAY,8CAAA,0CAAA,gBAAA,2CAAA,8CAAA,0CAAA;cACZ,gBAAa,UAAb,4CAAa,+CAAA,2CAAA,gBAAA,2CAAA,+CAAA,2CAAA"}
+{"version":3,"file":"registration.d.ts","names":[],"sources":["../../src/hooks/registration.ts"],"mappings":"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"}

package/dist/hooks/resolution.d.ts

@@ -1,11 +1,11 @@
-import { UseEnsQueryParameters } from "../query/options.js";
-import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters } from "./use-suspense-query.js";
-import { EnsQueryResult } from "../query/result.js";
+import { UseEnsAtomParameters } from "../query/options.js";
+import { EnsSuspenseAtomResult, UseEnsSuspenseAtomParameters } from "./use-suspense-query.js";
+import { EnsAtomResult } from "../query/result.js";
 import { EnsMutationOptions } from "../mutation/options.js";
 import { EnsMutationResult } from "../mutation/result.js";
 import "../index.js";
 //#region src/hooks/resolution.d.ts
-declare const useAlias: <Selected = {
+declare const useAlias: <Mapped = {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -16,7 +16,7 @@ declare const useAlias: <Selected = {
   readonly resolver: `0x${string}`;
   readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
   readonly raw: `0x${string}`;
-}>(input: UseEnsQueryParameters<import("@ensforge/core").GetAliasParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").GetAliasParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -27,8 +27,8 @@ declare const useAlias: <Selected = {
   readonly resolver: `0x${string}`;
   readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
   readonly raw: `0x${string}`;
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetAliasError>;
-declare const useAliasSuspense: <Selected = {
+}, import("@ensforge/core").GetAliasError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetAliasError>;
+declare const useAliasSuspense: <Mapped = {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -39,7 +39,7 @@ declare const useAliasSuspense: <Selected = {
   readonly resolver: `0x${string}`;
   readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
   readonly raw: `0x${string}`;
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetAliasParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetAliasParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -50,10 +50,10 @@ declare const useAliasSuspense: <Selected = {
   readonly resolver: `0x${string}`;
   readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
   readonly raw: `0x${string}`;
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useResolver: <Selected = import("@ensforge/core").GetResolverResult>(input: UseEnsQueryParameters<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetResolverError>;
-declare const useResolverSuspense: <Selected = import("@ensforge/core").GetResolverResult>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useResolverVersion: <Selected = {
+}, import("@ensforge/core").GetAliasError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useResolver: <Mapped = import("@ensforge/core").GetResolverResult>(input: UseEnsAtomParameters<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, import("@ensforge/core").GetResolverError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetResolverError>;
+declare const useResolverSuspense: <Mapped = import("@ensforge/core").GetResolverResult>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, import("@ensforge/core").GetResolverError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useResolverVersion: <Mapped = {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -63,7 +63,7 @@ declare const useResolverVersion: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}`;
   readonly version: bigint;
-}>(input: UseEnsQueryParameters<import("@ensforge/core").GetResolverVersionParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").GetResolverVersionParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -73,8 +73,8 @@ declare const useResolverVersion: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}`;
   readonly version: bigint;
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetResolverError>;
-declare const useResolverVersionSuspense: <Selected = {
+}, import("@ensforge/core").GetResolverError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetResolverError>;
+declare const useResolverVersionSuspense: <Mapped = {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -84,7 +84,7 @@ declare const useResolverVersionSuspense: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}`;
   readonly version: bigint;
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetResolverVersionParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetResolverVersionParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -94,39 +94,39 @@ declare const useResolverVersionSuspense: <Selected = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}`;
   readonly version: bigint;
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const usePredictResolverAddress: <Selected = `0x${string}`>(input: UseEnsQueryParameters<import("@ensforge/core").CreateResolverParameters, `0x${string}`, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").WriteError>;
-declare const usePredictResolverAddressSuspense: <Selected = `0x${string}`>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").CreateResolverParameters, `0x${string}`, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useResolve: <Selected = {
+}, import("@ensforge/core").GetResolverError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const usePredictResolverAddress: <Mapped = `0x${string}`>(input: UseEnsAtomParameters<import("@ensforge/core").CreateResolverParameters, `0x${string}`, import("@ensforge/core").WriteError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").WriteError>;
+declare const usePredictResolverAddressSuspense: <Mapped = `0x${string}`>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").CreateResolverParameters, `0x${string}`, import("@ensforge/core").WriteError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useResolve: <Mapped = {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-} | null>(input: UseEnsQueryParameters<import("@ensforge/core").ResolveParameters, {
+} | null>(input: UseEnsAtomParameters<import("@ensforge/core").ResolveParameters, {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-} | null, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").ResolveError>;
-declare const useResolveSuspense: <Selected = {
+} | null, import("@ensforge/core").ResolveError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").ResolveError>;
+declare const useResolveSuspense: <Mapped = {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-} | null>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").ResolveParameters, {
+} | null>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").ResolveParameters, {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-} | null, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useResolveBatch: <Selected = import("@ensforge/core").ResolveBatchResult>(input: UseEnsQueryParameters<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").ResolveError>;
-declare const useResolveBatchSuspense: <Selected = import("@ensforge/core").ResolveBatchResult>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, Selected>) => EnsSuspenseQueryResult<Selected>;
-declare const useResolveWithResolver: <Selected = {
+} | null, import("@ensforge/core").ResolveError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useResolveBatch: <Mapped = import("@ensforge/core").ResolveBatchResult>(input: UseEnsAtomParameters<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, import("@ensforge/core").ResolveError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").ResolveError>;
+declare const useResolveBatchSuspense: <Mapped = import("@ensforge/core").ResolveBatchResult>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, import("@ensforge/core").ResolveError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
+declare const useResolveWithResolver: <Mapped = {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-}>(input: UseEnsQueryParameters<import("@ensforge/core").ResolveWithResolverParameters, {
+}>(input: UseEnsAtomParameters<import("@ensforge/core").ResolveWithResolverParameters, {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").ResolveError>;
-declare const useResolveWithResolverSuspense: <Selected = {
+}, import("@ensforge/core").ResolveError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").ResolveError>;
+declare const useResolveWithResolverSuspense: <Mapped = {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").ResolveWithResolverParameters, {
+}>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").ResolveWithResolverParameters, {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
-}, Selected>) => EnsSuspenseQueryResult<Selected>;
+}, import("@ensforge/core").ResolveError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
 declare const useCreateResolver: (options?: EnsMutationOptions<import("@ensforge/core").CreateResolverParameters, import("@ensforge/core").CreateResolverResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").CreateResolverParameters, import("@ensforge/core").CreateResolverResult, import("@ensforge/core").WriteError>;
 declare const useGetOrCreateResolver: (options?: EnsMutationOptions<import("@ensforge/core").GetOrCreateResolverParameters, import("@ensforge/core").GetOrCreateResolverResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").GetOrCreateResolverParameters, import("@ensforge/core").GetOrCreateResolverResult, import("@ensforge/core").WriteError>;
 declare const useSetResolver: (options?: EnsMutationOptions<import("@ensforge/core").SetResolverParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetResolverParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;

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

@@ -1 +1 @@
-{"version":3,"file":"resolution.d.ts","names":[],"sources":["../../src/hooks/resolution.ts"],"mappings":";;;;;;;cAoBa,WAAQ;;;;;;;;;;;UAA8B;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cACtC,mBAAgB;;;;;;;;;;;UAAsC;;;;;;;;;;;GAAA,cAAA,uBAAA;cACtD,cAAW,oCAAA,mBAAA,OAAA,+CAAA,gDAAA,mBAAA,cAAA,eAAA,mCAAA;cACX,sBAAmB,oCAAA,mBAAA,OAAA,uDAAA,gDAAA,mBAAA,cAAA,uBAAA;cACnB,qBAAkB;;;;;;;;;;UAAwC;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cAC1D,6BAA0B;;;;;;;;;;UAAgD;;;;;;;;;;GAAA,cAAA,uBAAA;cAC1E,4BAAyB,0BAAA,OAAA,+CAAA,yCAAA,cAAA,eAAA,mCAAA;cACzB,oCAAiC,0BAAA,OAAA,uDAAA,yCAAA,cAAA,uBAAA;cACjC,aAAU;;;iBAA6B;;;UAAA,cAAA,eAAA,mCAAA;cACvC,qBAAkB;;;iBAAqC;;;UAAA,cAAA,uBAAA;cACvD,kBAAe,oCAAA,oBAAA,OAAA,+CAAA,iDAAA,oBAAA,cAAA,eAAA,mCAAA;cACf,0BAAuB,oCAAA,oBAAA,OAAA,uDAAA,iDAAA,oBAAA,cAAA,uBAAA;cACvB,yBAAsB;;;UAAyC;;;GAAA,cAAA,eAAA,mCAAA;cAC/D,iCAA8B;;;UAAiD;;;GAAA,cAAA,uBAAA;cAE/E,oBAAiB,UAAjB,4CAAiB,mDAAA,+CAAA,gBAAA,2CAAA,mDAAA,+CAAA;cACjB,yBAAsB,UAAtB,4CAAsB,wDAAA,oDAAA,gBAAA,2CAAA,wDAAA,oDAAA;cACtB,iBAAc,UAAd,4CAAc,gDAAA,8CAAA,gBAAA,2CAAA,gDAAA,8CAAA;cACd,2BAAwB,UAAxB,4CAAwB,0DAAA,wDAAA,gBAAA,2CAAA,0DAAA,wDAAA;cACxB,qBAAkB,UAAlB,4CAAkB,oDAAA,gDAAA,gBAAA,2CAAA,oDAAA,gDAAA"}
+{"version":3,"file":"resolution.d.ts","names":[],"sources":["../../src/hooks/resolution.ts"],"mappings":";;;;;;;cAoBa,WAAQ;;;;;;;;;;;UAA8B;;;;;;;;;;;4BAAA,eAAA,YAAA,cAAA,iCAAA;cACtC,mBAAgB;;;;;;;;;;;UAAsC;;;;;;;;;;;4BAAA,eAAA,YAAA,sBAAA;cACtD,cAAW,kCAAA,mBAAA,OAAA,8CAAA,gDAAA,4CAAA,kBAAA,YAAA,cAAA,iCAAA;cACX,sBAAmB,kCAAA,mBAAA,OAAA,sDAAA,gDAAA,4CAAA,kBAAA,YAAA,sBAAA;cACnB,qBAAkB;;;;;;;;;;UAAwC;;;;;;;;;;4BAAA,kBAAA,YAAA,cAAA,iCAAA;cAC1D,6BAA0B;;;;;;;;;;UAAgD;;;;;;;;;;4BAAA,kBAAA,YAAA,sBAAA;cAC1E,4BAAyB,wBAAA,OAAA,8CAAA,kEAAA,YAAA,YAAA,cAAA,iCAAA;cACzB,oCAAiC,wBAAA,OAAA,sDAAA,kEAAA,YAAA,YAAA,sBAAA;cACjC,aAAU;;;iBAA6B;;;mCAAA,cAAA,YAAA,cAAA,iCAAA;cACvC,qBAAkB;;;iBAAqC;;;mCAAA,cAAA,YAAA,sBAAA;cACvD,kBAAe,kCAAA,oBAAA,OAAA,8CAAA,iDAAA,6CAAA,cAAA,YAAA,cAAA,iCAAA;cACf,0BAAuB,kCAAA,oBAAA,OAAA,sDAAA,iDAAA,6CAAA,cAAA,YAAA,sBAAA;cACvB,yBAAsB;;;UAAyC;;;4BAAA,cAAA,YAAA,cAAA,iCAAA;cAC/D,iCAA8B;;;UAAiD;;;4BAAA,cAAA,YAAA,sBAAA;cAE/E,oBAAiB,UAAjB,4CAAiB,mDAAA,+CAAA,gBAAA,2CAAA,mDAAA,+CAAA;cACjB,yBAAsB,UAAtB,4CAAsB,wDAAA,oDAAA,gBAAA,2CAAA,wDAAA,oDAAA;cACtB,iBAAc,UAAd,4CAAc,gDAAA,8CAAA,gBAAA,2CAAA,gDAAA,8CAAA;cACd,2BAAwB,UAAxB,4CAAwB,0DAAA,wDAAA,gBAAA,2CAAA,0DAAA,wDAAA;cACxB,qBAAkB,UAAlB,4CAAkB,oDAAA,gDAAA,gBAAA,2CAAA,oDAAA,gDAAA"}

package/dist/hooks/reverse.d.ts

@@ -1,24 +1,24 @@
-import { UseEnsQueryParameters } from "../query/options.js";
-import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters } from "./use-suspense-query.js";
-import { EnsQueryResult } from "../query/result.js";
+import { UseEnsAtomParameters } from "../query/options.js";
+import { EnsSuspenseAtomResult, UseEnsSuspenseAtomParameters } from "./use-suspense-query.js";
+import { EnsAtomResult } from "../query/result.js";
 import { EnsMutationOptions } from "../mutation/options.js";
 import { EnsMutationResult } from "../mutation/result.js";
 import "../index.js";
 //#region src/hooks/reverse.d.ts
-declare const usePrimaryName: <Selected = {
+declare const usePrimaryName: <Mapped = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly match: true;
-} | null>(input: UseEnsQueryParameters<import("@ensforge/core").GetPrimaryNameParameters, {
+} | null>(input: UseEnsAtomParameters<import("@ensforge/core").GetPrimaryNameParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly match: true;
-} | null, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetPrimaryNameError>;
-declare const usePrimaryNameSuspense: <Selected = {
+} | null, import("@ensforge/core").GetPrimaryNameError, Mapped>) => EnsAtomResult<Mapped, import("@ensforge/core").GetPrimaryNameError>;
+declare const usePrimaryNameSuspense: <Mapped = {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly match: true;
-} | null>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetPrimaryNameParameters, {
+} | null>(input: UseEnsSuspenseAtomParameters<import("@ensforge/core").GetPrimaryNameParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly match: true;
-} | null, Selected>) => EnsSuspenseQueryResult<Selected>;
+} | null, import("@ensforge/core").GetPrimaryNameError, Mapped>) => EnsSuspenseAtomResult<Mapped>;
 declare const useClearPrimaryName: (options?: EnsMutationOptions<import("@ensforge/core").ClearPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").ClearPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const useSetContractPrimaryName: (options?: EnsMutationOptions<import("@ensforge/core").SetContractPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetContractPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const useSetPrimaryName: (options?: EnsMutationOptions<import("@ensforge/core").SetPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetPrimaryNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;

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

@@ -1 +1 @@
-{"version":3,"file":"reverse.d.ts","names":[],"sources":["../../src/hooks/reverse.ts"],"mappings":";;;;;;;cAaa,iBAAc;;;iBAAoC;;;UAAA,cAAA,eAAA,mCAAA;cAClD,yBAAsB;;;iBAA4C;;;UAAA,cAAA,uBAAA;cAElE,sBAAmB,UAAnB,4CAAmB,qDAAA,8CAAA,gBAAA,2CAAA,qDAAA,8CAAA;cACnB,4BAAyB,UAAzB,4CAAyB,2DAAA,8CAAA,gBAAA,2CAAA,2DAAA,8CAAA;cACzB,oBAAiB,UAAjB,4CAAiB,mDAAA,8CAAA,gBAAA,2CAAA,mDAAA,8CAAA;cACjB,8BAA2B,UAA3B,4CAA2B,6DAAA,8CAAA,gBAAA,2CAAA,6DAAA,8CAAA"}
+{"version":3,"file":"reverse.d.ts","names":[],"sources":["../../src/hooks/reverse.ts"],"mappings":";;;;;;;cAaa,iBAAc;;;iBAAoC;;;mCAAA,qBAAA,YAAA,cAAA,iCAAA;cAClD,yBAAsB;;;iBAA4C;;;mCAAA,qBAAA,YAAA,sBAAA;cAElE,sBAAmB,UAAnB,4CAAmB,qDAAA,8CAAA,gBAAA,2CAAA,qDAAA,8CAAA;cACnB,4BAAyB,UAAzB,4CAAyB,2DAAA,8CAAA,gBAAA,2CAAA,2DAAA,8CAAA;cACzB,oBAAiB,UAAjB,4CAAiB,mDAAA,8CAAA,gBAAA,2CAAA,mDAAA,8CAAA;cACjB,8BAA2B,UAA3B,4CAA2B,6DAAA,8CAAA,gBAAA,2CAAA,6DAAA,8CAAA"}

package/dist/hooks/use-cache.d.ts

@@ -1,11 +1,11 @@
-import { EnsforgeInvalidation } from "../cache/invalidation.js";
+import { Invalidation } from "../cache/invalidation.js";
 import { Effect } from "effect";
 //#region src/hooks/use-cache.d.ts
-interface InvalidateEnsforge {
-  (invalidation?: EnsforgeInvalidation, options?: Effect.RunOptions): Promise<void>;
-  readonly effect: (invalidation?: EnsforgeInvalidation) => Effect.Effect<void>;
+interface Invalidate {
+  (invalidation?: Invalidation, options?: Effect.RunOptions): Promise<void>;
+  readonly effect: (invalidation?: Invalidation) => Effect.Effect<void>;
 }
-declare const useInvalidateEnsforge: () => InvalidateEnsforge;
+declare const useInvalidate: () => Invalidate;
 //#endregion
-export { InvalidateEnsforge, useInvalidateEnsforge };
+export { Invalidate, useInvalidate };
 //# sourceMappingURL=use-cache.d.ts.map

package/dist/hooks/use-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-cache.d.ts","names":[],"sources":["../../src/hooks/use-cache.ts"],"mappings":";;;UAUiB;GACd,eAAe,sBAAsB,UAAU,OAAO,aAAa;WAC3D,SAAS,eAAe,yBAAyB,OAAO;;cAGtD,6BAA4B"}
+{"version":3,"file":"use-cache.d.ts","names":[],"sources":["../../src/hooks/use-cache.ts"],"mappings":";;;UAUiB;GACd,eAAe,cAAc,UAAU,OAAO,aAAa;WACnD,SAAS,eAAe,iBAAiB,OAAO;;cAG9C,qBAAoB"}

package/dist/hooks/use-cache.js

@@ -1,20 +1,20 @@
 "use client";
 
-import { invalidateEnsforgeEffect } from "../cache/invalidation.js";
+import { invalidateEffect } from "../cache/invalidation.js";
 import { useEnsforgeContext } from "../provider/context.js";
 import { Effect } from "effect";
 import { RegistryContext } from "@effect/atom-react";
 import { useContext } from "react";
 
 //#region src/hooks/use-cache.ts
-const useInvalidateEnsforge = () => {
+const useInvalidate = () => {
 	const registry = useContext(RegistryContext);
 	const { sdk } = useEnsforgeContext();
-	const effect = (invalidation = { all: true }) => invalidateEnsforgeEffect(registry, sdk, invalidation);
+	const effect = (invalidation = { all: true }) => invalidateEffect(registry, sdk, invalidation);
 	const invalidate = (invalidation, options) => Effect.runPromise(effect(invalidation), options);
 	return Object.assign(invalidate, { effect });
 };
 
 //#endregion
-export { useInvalidateEnsforge };
+export { useInvalidate };
 //# sourceMappingURL=use-cache.js.map

package/dist/hooks/use-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-cache.js","names":[],"sources":["../../src/hooks/use-cache.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext } from \"react\";\n\nimport { RegistryContext } from \"@effect/atom-react\";\nimport { Effect } from \"effect\";\n\nimport { invalidateEnsforgeEffect, type EnsforgeInvalidation } from \"../cache/invalidation.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\n\nexport interface InvalidateEnsforge {\n  (invalidation?: EnsforgeInvalidation, options?: Effect.RunOptions): Promise<void>;\n  readonly effect: (invalidation?: EnsforgeInvalidation) => Effect.Effect<void>;\n}\n\nexport const useInvalidateEnsforge = (): InvalidateEnsforge => {\n  const registry = useContext(RegistryContext);\n  const { sdk } = useEnsforgeContext();\n  const effect = (invalidation: EnsforgeInvalidation = { all: true }) =>\n    invalidateEnsforgeEffect(registry, sdk, invalidation);\n  const invalidate = (invalidation?: EnsforgeInvalidation, options?: Effect.RunOptions) =>\n    Effect.runPromise(effect(invalidation), options);\n\n  return Object.assign(invalidate, { effect });\n};\n"],"mappings":";;;;;;;;;AAeA,MAAa,8BAAkD;CAC7D,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,EAAE,QAAQ,mBAAmB;CACnC,MAAM,UAAU,eAAqC,EAAE,KAAK,KAAK,MAC/D,yBAAyB,UAAU,KAAK,YAAY;CACtD,MAAM,cAAc,cAAqC,YACvD,OAAO,WAAW,OAAO,YAAY,GAAG,OAAO;CAEjD,OAAO,OAAO,OAAO,YAAY,EAAE,OAAO,CAAC;AAC7C"}
+{"version":3,"file":"use-cache.js","names":[],"sources":["../../src/hooks/use-cache.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext } from \"react\";\n\nimport { RegistryContext } from \"@effect/atom-react\";\nimport { Effect } from \"effect\";\n\nimport { invalidateEffect, type Invalidation } from \"../cache/invalidation.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\n\nexport interface Invalidate {\n  (invalidation?: Invalidation, options?: Effect.RunOptions): Promise<void>;\n  readonly effect: (invalidation?: Invalidation) => Effect.Effect<void>;\n}\n\nexport const useInvalidate = (): Invalidate => {\n  const registry = useContext(RegistryContext);\n  const { sdk } = useEnsforgeContext();\n  const effect = (invalidation: Invalidation = { all: true }) =>\n    invalidateEffect(registry, sdk, invalidation);\n  const invalidate = (invalidation?: Invalidation, options?: Effect.RunOptions) =>\n    Effect.runPromise(effect(invalidation), options);\n\n  return Object.assign(invalidate, { effect });\n};\n"],"mappings":";;;;;;;;;AAeA,MAAa,sBAAkC;CAC7C,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,EAAE,QAAQ,mBAAmB;CACnC,MAAM,UAAU,eAA6B,EAAE,KAAK,KAAK,MACvD,iBAAiB,UAAU,KAAK,YAAY;CAC9C,MAAM,cAAc,cAA6B,YAC/C,OAAO,WAAW,OAAO,YAAY,GAAG,OAAO;CAEjD,OAAO,OAAO,OAAO,YAAY,EAAE,OAAO,CAAC;AAC7C"}