@ensforge/react 0.0.0

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

@@ -0,0 +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"}

package/dist/hooks/registration.js

@@ -0,0 +1,34 @@
+"use client";
+
+import { makeMutationHook } from "./use-mutation.js";
+import { makeQueryHook } from "./use-query.js";
+import { makeSuspenseQueryHook } from "./use-suspense-query.js";
+import { createApprovePaymentTokenMutationAtom, createApproveRenewalPaymentMutationAtom, createCommitNameMutationAtom, createCompleteRegistrationMutationAtom, createRegisterNameMutationAtom, createRegisterNamesMutationAtom, createRenewNameMutationAtom, createRenewNamesMutationAtom, getCommitmentStatusAtom, getRegistrationParametersAtom, getRegistrationPlanAtom, getRegistrationPriceAtom, getRenewalPriceAtom, isPaymentTokenSupportedAtom, makeRegistrationCommitmentAtom } from "../atoms/registration.js";
+
+//#region src/hooks/registration.ts
+const useCommitmentStatus = makeQueryHook(getCommitmentStatusAtom);
+const useCommitmentStatusSuspense = makeSuspenseQueryHook(getCommitmentStatusAtom);
+const useRegistrationParameters = makeQueryHook(getRegistrationParametersAtom);
+const useRegistrationParametersSuspense = makeSuspenseQueryHook(getRegistrationParametersAtom);
+const useRegistrationPlan = makeQueryHook(getRegistrationPlanAtom);
+const useRegistrationPlanSuspense = makeSuspenseQueryHook(getRegistrationPlanAtom);
+const useRegistrationPrice = makeQueryHook(getRegistrationPriceAtom);
+const useRegistrationPriceSuspense = makeSuspenseQueryHook(getRegistrationPriceAtom);
+const useRenewalPrice = makeQueryHook(getRenewalPriceAtom);
+const useRenewalPriceSuspense = makeSuspenseQueryHook(getRenewalPriceAtom);
+const useIsPaymentTokenSupported = makeQueryHook(isPaymentTokenSupportedAtom);
+const useIsPaymentTokenSupportedSuspense = makeSuspenseQueryHook(isPaymentTokenSupportedAtom);
+const useRegistrationCommitment = makeQueryHook(makeRegistrationCommitmentAtom);
+const useRegistrationCommitmentSuspense = makeSuspenseQueryHook(makeRegistrationCommitmentAtom);
+const useApprovePaymentToken = makeMutationHook(createApprovePaymentTokenMutationAtom);
+const useApproveRenewalPayment = makeMutationHook(createApproveRenewalPaymentMutationAtom);
+const useCommitName = makeMutationHook(createCommitNameMutationAtom);
+const useCompleteRegistration = makeMutationHook(createCompleteRegistrationMutationAtom);
+const useRegisterName = makeMutationHook(createRegisterNameMutationAtom);
+const useRegisterNames = makeMutationHook(createRegisterNamesMutationAtom);
+const useRenewName = makeMutationHook(createRenewNameMutationAtom);
+const useRenewNames = makeMutationHook(createRenewNamesMutationAtom);
+
+//#endregion
+export { useApprovePaymentToken, useApproveRenewalPayment, useCommitName, useCommitmentStatus, useCommitmentStatusSuspense, useCompleteRegistration, useIsPaymentTokenSupported, useIsPaymentTokenSupportedSuspense, useRegisterName, useRegisterNames, useRegistrationCommitment, useRegistrationCommitmentSuspense, useRegistrationParameters, useRegistrationParametersSuspense, useRegistrationPlan, useRegistrationPlanSuspense, useRegistrationPrice, useRegistrationPriceSuspense, useRenewName, useRenewNames, useRenewalPrice, useRenewalPriceSuspense };
+//# sourceMappingURL=registration.js.map

package/dist/hooks/registration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration.js","names":[],"sources":["../../src/hooks/registration.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getCommitmentStatusAtom,\n  getRegistrationParametersAtom,\n  getRegistrationPlanAtom,\n  getRegistrationPriceAtom,\n  getRenewalPriceAtom,\n  isPaymentTokenSupportedAtom,\n  makeRegistrationCommitmentAtom,\n  createApprovePaymentTokenMutationAtom,\n  createApproveRenewalPaymentMutationAtom,\n  createCommitNameMutationAtom,\n  createCompleteRegistrationMutationAtom,\n  createRegisterNameMutationAtom,\n  createRegisterNamesMutationAtom,\n  createRenewNameMutationAtom,\n  createRenewNamesMutationAtom,\n} from \"../atoms/registration.js\";\nimport { makeMutationHook } from \"./use-mutation.js\";\nimport { makeQueryHook } from \"./use-query.js\";\nimport { makeSuspenseQueryHook } from \"./use-suspense-query.js\";\n\nexport const useCommitmentStatus = makeQueryHook(getCommitmentStatusAtom);\nexport const useCommitmentStatusSuspense = makeSuspenseQueryHook(getCommitmentStatusAtom);\nexport const useRegistrationParameters = makeQueryHook(getRegistrationParametersAtom);\nexport const useRegistrationParametersSuspense = makeSuspenseQueryHook(\n  getRegistrationParametersAtom,\n);\nexport const useRegistrationPlan = makeQueryHook(getRegistrationPlanAtom);\nexport const useRegistrationPlanSuspense = makeSuspenseQueryHook(getRegistrationPlanAtom);\nexport const useRegistrationPrice = makeQueryHook(getRegistrationPriceAtom);\nexport const useRegistrationPriceSuspense = makeSuspenseQueryHook(getRegistrationPriceAtom);\nexport const useRenewalPrice = makeQueryHook(getRenewalPriceAtom);\nexport const useRenewalPriceSuspense = makeSuspenseQueryHook(getRenewalPriceAtom);\nexport const useIsPaymentTokenSupported = makeQueryHook(isPaymentTokenSupportedAtom);\nexport const useIsPaymentTokenSupportedSuspense = makeSuspenseQueryHook(\n  isPaymentTokenSupportedAtom,\n);\nexport const useRegistrationCommitment = makeQueryHook(makeRegistrationCommitmentAtom);\nexport const useRegistrationCommitmentSuspense = makeSuspenseQueryHook(\n  makeRegistrationCommitmentAtom,\n);\n\nexport const useApprovePaymentToken = makeMutationHook(createApprovePaymentTokenMutationAtom);\nexport const useApproveRenewalPayment = makeMutationHook(createApproveRenewalPaymentMutationAtom);\nexport const useCommitName = makeMutationHook(createCommitNameMutationAtom);\nexport const useCompleteRegistration = makeMutationHook(createCompleteRegistrationMutationAtom);\nexport const useRegisterName = makeMutationHook(createRegisterNameMutationAtom);\nexport const useRegisterNames = makeMutationHook(createRegisterNamesMutationAtom);\nexport const useRenewName = makeMutationHook(createRenewNameMutationAtom);\nexport const useRenewNames = makeMutationHook(createRenewNamesMutationAtom);\n"],"mappings":";;;;;;;;AAuBA,MAAa,sBAAsB,cAAc,uBAAuB;AACxE,MAAa,8BAA8B,sBAAsB,uBAAuB;AACxF,MAAa,4BAA4B,cAAc,6BAA6B;AACpF,MAAa,oCAAoC,sBAC/C,6BACF;AACA,MAAa,sBAAsB,cAAc,uBAAuB;AACxE,MAAa,8BAA8B,sBAAsB,uBAAuB;AACxF,MAAa,uBAAuB,cAAc,wBAAwB;AAC1E,MAAa,+BAA+B,sBAAsB,wBAAwB;AAC1F,MAAa,kBAAkB,cAAc,mBAAmB;AAChE,MAAa,0BAA0B,sBAAsB,mBAAmB;AAChF,MAAa,6BAA6B,cAAc,2BAA2B;AACnF,MAAa,qCAAqC,sBAChD,2BACF;AACA,MAAa,4BAA4B,cAAc,8BAA8B;AACrF,MAAa,oCAAoC,sBAC/C,8BACF;AAEA,MAAa,yBAAyB,iBAAiB,qCAAqC;AAC5F,MAAa,2BAA2B,iBAAiB,uCAAuC;AAChG,MAAa,gBAAgB,iBAAiB,4BAA4B;AAC1E,MAAa,0BAA0B,iBAAiB,sCAAsC;AAC9F,MAAa,kBAAkB,iBAAiB,8BAA8B;AAC9E,MAAa,mBAAmB,iBAAiB,+BAA+B;AAChF,MAAa,eAAe,iBAAiB,2BAA2B;AACxE,MAAa,gBAAgB,iBAAiB,4BAA4B"}

package/dist/hooks/resolution.d.ts

@@ -0,0 +1,137 @@
+import { UseEnsQueryParameters } from "../query/options.js";
+import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters } from "./use-suspense-query.js";
+import { EnsQueryResult } 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 = {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly reason: "RESOLVER_NOT_FOUND" | "ALIASING_UNSUPPORTED";
+} | {
+  readonly supported: true;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}`;
+  readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
+  readonly raw: `0x${string}`;
+}>(input: UseEnsQueryParameters<import("@ensforge/core").GetAliasParameters, {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly reason: "RESOLVER_NOT_FOUND" | "ALIASING_UNSUPPORTED";
+} | {
+  readonly supported: true;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  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 = {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly reason: "RESOLVER_NOT_FOUND" | "ALIASING_UNSUPPORTED";
+} | {
+  readonly supported: true;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}`;
+  readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
+  readonly raw: `0x${string}`;
+}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetAliasParameters, {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly reason: "RESOLVER_NOT_FOUND" | "ALIASING_UNSUPPORTED";
+} | {
+  readonly supported: true;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  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 = {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly reason: "RESOLVER_NOT_FOUND" | "VERSIONING_UNSUPPORTED";
+} | {
+  readonly supported: true;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}`;
+  readonly version: bigint;
+}>(input: UseEnsQueryParameters<import("@ensforge/core").GetResolverVersionParameters, {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly reason: "RESOLVER_NOT_FOUND" | "VERSIONING_UNSUPPORTED";
+} | {
+  readonly supported: true;
+  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 = {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly reason: "RESOLVER_NOT_FOUND" | "VERSIONING_UNSUPPORTED";
+} | {
+  readonly supported: true;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}`;
+  readonly version: bigint;
+}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetResolverVersionParameters, {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly reason: "RESOLVER_NOT_FOUND" | "VERSIONING_UNSUPPORTED";
+} | {
+  readonly supported: true;
+  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 = {
+  readonly data: `0x${string}`;
+  readonly resolverAddress: `0x${string}`;
+} | null>(input: UseEnsQueryParameters<import("@ensforge/core").ResolveParameters, {
+  readonly data: `0x${string}`;
+  readonly resolverAddress: `0x${string}`;
+} | null, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").ResolveError>;
+declare const useResolveSuspense: <Selected = {
+  readonly data: `0x${string}`;
+  readonly resolverAddress: `0x${string}`;
+} | null>(input: UseEnsSuspenseQueryParameters<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 = {
+  readonly data: `0x${string}`;
+  readonly resolverAddress: `0x${string}`;
+}>(input: UseEnsQueryParameters<import("@ensforge/core").ResolveWithResolverParameters, {
+  readonly data: `0x${string}`;
+  readonly resolverAddress: `0x${string}`;
+}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").ResolveError>;
+declare const useResolveWithResolverSuspense: <Selected = {
+  readonly data: `0x${string}`;
+  readonly resolverAddress: `0x${string}`;
+}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").ResolveWithResolverParameters, {
+  readonly data: `0x${string}`;
+  readonly resolverAddress: `0x${string}`;
+}, Selected>) => EnsSuspenseQueryResult<Selected>;
+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>;
+declare const useSetResolverAndRecords: (options?: EnsMutationOptions<import("@ensforge/core").SetResolverAndRecordsParameters, import("@ensforge/core").SetResolverAndRecordsProgress, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetResolverAndRecordsParameters, import("@ensforge/core").SetResolverAndRecordsProgress, import("@ensforge/core").WriteError>;
+declare const useUpgradeResolver: (options?: EnsMutationOptions<import("@ensforge/core").UpgradeResolverParameters, import("@ensforge/core").UpgradeResolverResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").UpgradeResolverParameters, import("@ensforge/core").UpgradeResolverResult, import("@ensforge/core").WriteError>;
+//#endregion
+export { useAlias, useAliasSuspense, useCreateResolver, useGetOrCreateResolver, usePredictResolverAddress, usePredictResolverAddressSuspense, useResolve, useResolveBatch, useResolveBatchSuspense, useResolveSuspense, useResolveWithResolver, useResolveWithResolverSuspense, useResolver, useResolverSuspense, useResolverVersion, useResolverVersionSuspense, useSetResolver, useSetResolverAndRecords, useUpgradeResolver };
+//# sourceMappingURL=resolution.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/resolution.js

@@ -0,0 +1,31 @@
+"use client";
+
+import { makeMutationHook } from "./use-mutation.js";
+import { makeQueryHook } from "./use-query.js";
+import { makeSuspenseQueryHook } from "./use-suspense-query.js";
+import { createCreateResolverMutationAtom, createGetOrCreateResolverMutationAtom, createSetResolverAndRecordsMutationAtom, createSetResolverMutationAtom, createUpgradeResolverMutationAtom, getAliasAtom, getResolverAtom, getResolverVersionAtom, predictResolverAddressAtom, resolveAtom, resolveBatchAtom, resolveWithResolverAtom } from "../atoms/resolution.js";
+
+//#region src/hooks/resolution.ts
+const useAlias = makeQueryHook(getAliasAtom);
+const useAliasSuspense = makeSuspenseQueryHook(getAliasAtom);
+const useResolver = makeQueryHook(getResolverAtom);
+const useResolverSuspense = makeSuspenseQueryHook(getResolverAtom);
+const useResolverVersion = makeQueryHook(getResolverVersionAtom);
+const useResolverVersionSuspense = makeSuspenseQueryHook(getResolverVersionAtom);
+const usePredictResolverAddress = makeQueryHook(predictResolverAddressAtom);
+const usePredictResolverAddressSuspense = makeSuspenseQueryHook(predictResolverAddressAtom);
+const useResolve = makeQueryHook(resolveAtom);
+const useResolveSuspense = makeSuspenseQueryHook(resolveAtom);
+const useResolveBatch = makeQueryHook(resolveBatchAtom);
+const useResolveBatchSuspense = makeSuspenseQueryHook(resolveBatchAtom);
+const useResolveWithResolver = makeQueryHook(resolveWithResolverAtom);
+const useResolveWithResolverSuspense = makeSuspenseQueryHook(resolveWithResolverAtom);
+const useCreateResolver = makeMutationHook(createCreateResolverMutationAtom);
+const useGetOrCreateResolver = makeMutationHook(createGetOrCreateResolverMutationAtom);
+const useSetResolver = makeMutationHook(createSetResolverMutationAtom);
+const useSetResolverAndRecords = makeMutationHook(createSetResolverAndRecordsMutationAtom);
+const useUpgradeResolver = makeMutationHook(createUpgradeResolverMutationAtom);
+
+//#endregion
+export { useAlias, useAliasSuspense, useCreateResolver, useGetOrCreateResolver, usePredictResolverAddress, usePredictResolverAddressSuspense, useResolve, useResolveBatch, useResolveBatchSuspense, useResolveSuspense, useResolveWithResolver, useResolveWithResolverSuspense, useResolver, useResolverSuspense, useResolverVersion, useResolverVersionSuspense, useSetResolver, useSetResolverAndRecords, useUpgradeResolver };
+//# sourceMappingURL=resolution.js.map

package/dist/hooks/resolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolution.js","names":[],"sources":["../../src/hooks/resolution.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getAliasAtom,\n  getResolverAtom,\n  getResolverVersionAtom,\n  predictResolverAddressAtom,\n  resolveAtom,\n  resolveBatchAtom,\n  resolveWithResolverAtom,\n  createCreateResolverMutationAtom,\n  createGetOrCreateResolverMutationAtom,\n  createSetResolverMutationAtom,\n  createSetResolverAndRecordsMutationAtom,\n  createUpgradeResolverMutationAtom,\n} from \"../atoms/resolution.js\";\nimport { makeMutationHook } from \"./use-mutation.js\";\nimport { makeQueryHook } from \"./use-query.js\";\nimport { makeSuspenseQueryHook } from \"./use-suspense-query.js\";\n\nexport const useAlias = makeQueryHook(getAliasAtom);\nexport const useAliasSuspense = makeSuspenseQueryHook(getAliasAtom);\nexport const useResolver = makeQueryHook(getResolverAtom);\nexport const useResolverSuspense = makeSuspenseQueryHook(getResolverAtom);\nexport const useResolverVersion = makeQueryHook(getResolverVersionAtom);\nexport const useResolverVersionSuspense = makeSuspenseQueryHook(getResolverVersionAtom);\nexport const usePredictResolverAddress = makeQueryHook(predictResolverAddressAtom);\nexport const usePredictResolverAddressSuspense = makeSuspenseQueryHook(predictResolverAddressAtom);\nexport const useResolve = makeQueryHook(resolveAtom);\nexport const useResolveSuspense = makeSuspenseQueryHook(resolveAtom);\nexport const useResolveBatch = makeQueryHook(resolveBatchAtom);\nexport const useResolveBatchSuspense = makeSuspenseQueryHook(resolveBatchAtom);\nexport const useResolveWithResolver = makeQueryHook(resolveWithResolverAtom);\nexport const useResolveWithResolverSuspense = makeSuspenseQueryHook(resolveWithResolverAtom);\n\nexport const useCreateResolver = makeMutationHook(createCreateResolverMutationAtom);\nexport const useGetOrCreateResolver = makeMutationHook(createGetOrCreateResolverMutationAtom);\nexport const useSetResolver = makeMutationHook(createSetResolverMutationAtom);\nexport const useSetResolverAndRecords = makeMutationHook(createSetResolverAndRecordsMutationAtom);\nexport const useUpgradeResolver = makeMutationHook(createUpgradeResolverMutationAtom);\n"],"mappings":";;;;;;;;AAoBA,MAAa,WAAW,cAAc,YAAY;AAClD,MAAa,mBAAmB,sBAAsB,YAAY;AAClE,MAAa,cAAc,cAAc,eAAe;AACxD,MAAa,sBAAsB,sBAAsB,eAAe;AACxE,MAAa,qBAAqB,cAAc,sBAAsB;AACtE,MAAa,6BAA6B,sBAAsB,sBAAsB;AACtF,MAAa,4BAA4B,cAAc,0BAA0B;AACjF,MAAa,oCAAoC,sBAAsB,0BAA0B;AACjG,MAAa,aAAa,cAAc,WAAW;AACnD,MAAa,qBAAqB,sBAAsB,WAAW;AACnE,MAAa,kBAAkB,cAAc,gBAAgB;AAC7D,MAAa,0BAA0B,sBAAsB,gBAAgB;AAC7E,MAAa,yBAAyB,cAAc,uBAAuB;AAC3E,MAAa,iCAAiC,sBAAsB,uBAAuB;AAE3F,MAAa,oBAAoB,iBAAiB,gCAAgC;AAClF,MAAa,yBAAyB,iBAAiB,qCAAqC;AAC5F,MAAa,iBAAiB,iBAAiB,6BAA6B;AAC5E,MAAa,2BAA2B,iBAAiB,uCAAuC;AAChG,MAAa,qBAAqB,iBAAiB,iCAAiC"}

package/dist/hooks/reverse.d.ts

@@ -0,0 +1,28 @@
+import { UseEnsQueryParameters } from "../query/options.js";
+import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters } from "./use-suspense-query.js";
+import { EnsQueryResult } 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 = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly match: true;
+} | null>(input: UseEnsQueryParameters<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 = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly match: true;
+} | null>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetPrimaryNameParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly match: true;
+} | null, Selected>) => EnsSuspenseQueryResult<Selected>;
+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>;
+declare const useSetPrimaryNameForAddress: (options?: EnsMutationOptions<import("@ensforge/core").SetPrimaryNameForAddressParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetPrimaryNameForAddressParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+//#endregion
+export { useClearPrimaryName, usePrimaryName, usePrimaryNameSuspense, useSetContractPrimaryName, useSetPrimaryName, useSetPrimaryNameForAddress };
+//# sourceMappingURL=reverse.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/reverse.js

@@ -0,0 +1,18 @@
+"use client";
+
+import { makeMutationHook } from "./use-mutation.js";
+import { makeQueryHook } from "./use-query.js";
+import { makeSuspenseQueryHook } from "./use-suspense-query.js";
+import { createClearPrimaryNameMutationAtom, createSetContractPrimaryNameMutationAtom, createSetPrimaryNameForAddressMutationAtom, createSetPrimaryNameMutationAtom, getPrimaryNameAtom } from "../atoms/reverse.js";
+
+//#region src/hooks/reverse.ts
+const usePrimaryName = makeQueryHook(getPrimaryNameAtom);
+const usePrimaryNameSuspense = makeSuspenseQueryHook(getPrimaryNameAtom);
+const useClearPrimaryName = makeMutationHook(createClearPrimaryNameMutationAtom);
+const useSetContractPrimaryName = makeMutationHook(createSetContractPrimaryNameMutationAtom);
+const useSetPrimaryName = makeMutationHook(createSetPrimaryNameMutationAtom);
+const useSetPrimaryNameForAddress = makeMutationHook(createSetPrimaryNameForAddressMutationAtom);
+
+//#endregion
+export { useClearPrimaryName, usePrimaryName, usePrimaryNameSuspense, useSetContractPrimaryName, useSetPrimaryName, useSetPrimaryNameForAddress };
+//# sourceMappingURL=reverse.js.map

package/dist/hooks/reverse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse.js","names":[],"sources":["../../src/hooks/reverse.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getPrimaryNameAtom,\n  createClearPrimaryNameMutationAtom,\n  createSetContractPrimaryNameMutationAtom,\n  createSetPrimaryNameMutationAtom,\n  createSetPrimaryNameForAddressMutationAtom,\n} from \"../atoms/reverse.js\";\nimport { makeMutationHook } from \"./use-mutation.js\";\nimport { makeQueryHook } from \"./use-query.js\";\nimport { makeSuspenseQueryHook } from \"./use-suspense-query.js\";\n\nexport const usePrimaryName = makeQueryHook(getPrimaryNameAtom);\nexport const usePrimaryNameSuspense = makeSuspenseQueryHook(getPrimaryNameAtom);\n\nexport const useClearPrimaryName = makeMutationHook(createClearPrimaryNameMutationAtom);\nexport const useSetContractPrimaryName = makeMutationHook(createSetContractPrimaryNameMutationAtom);\nexport const useSetPrimaryName = makeMutationHook(createSetPrimaryNameMutationAtom);\nexport const useSetPrimaryNameForAddress = makeMutationHook(\n  createSetPrimaryNameForAddressMutationAtom,\n);\n"],"mappings":";;;;;;;;AAaA,MAAa,iBAAiB,cAAc,kBAAkB;AAC9D,MAAa,yBAAyB,sBAAsB,kBAAkB;AAE9E,MAAa,sBAAsB,iBAAiB,kCAAkC;AACtF,MAAa,4BAA4B,iBAAiB,wCAAwC;AAClG,MAAa,oBAAoB,iBAAiB,gCAAgC;AAClF,MAAa,8BAA8B,iBACzC,0CACF"}

package/dist/hooks/subnames.d.ts

@@ -0,0 +1,14 @@
+import { EnsMutationOptions } from "../mutation/options.js";
+import { EnsMutationResult } from "../mutation/result.js";
+import "../index.js";
+//#region src/hooks/subnames.d.ts
+declare const useCreateSubname: (options?: EnsMutationOptions<import("@ensforge/core").CreateSubnameParameters, import("@ensforge/core").CreateSubnameResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").CreateSubnameParameters, import("@ensforge/core").CreateSubnameResult, import("@ensforge/core").WriteError>;
+declare const useDeleteSubname: (options?: EnsMutationOptions<import("@ensforge/core").DeleteSubnameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").DeleteSubnameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const useSetSubnameExpiry: (options?: EnsMutationOptions<import("@ensforge/core").SetSubnameExpiryParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetSubnameExpiryParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const useSetSubnameManager: (options?: EnsMutationOptions<import("@ensforge/core").SetSubnameManagerParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetSubnameManagerParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const useSetSubnameRecord: (options?: EnsMutationOptions<import("@ensforge/core").SetSubnameRecordParameters, import("@ensforge/core").SetSubnameRecordResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetSubnameRecordParameters, import("@ensforge/core").SetSubnameRecordResult, import("@ensforge/core").WriteError>;
+declare const useSetSubnameResolver: (options?: EnsMutationOptions<import("@ensforge/core").SetSubnameResolverParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetSubnameResolverParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const useTransferSubname: (options?: EnsMutationOptions<import("@ensforge/core").TransferSubnameParameters, import("@ensforge/core").TransferNameProgress, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").TransferSubnameParameters, import("@ensforge/core").TransferNameProgress, import("@ensforge/core").WriteError>;
+//#endregion
+export { useCreateSubname, useDeleteSubname, useSetSubnameExpiry, useSetSubnameManager, useSetSubnameRecord, useSetSubnameResolver, useTransferSubname };
+//# sourceMappingURL=subnames.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subnames.d.ts","names":[],"sources":["../../src/hooks/subnames.ts"],"mappings":";;;;cAaa,mBAAgB,UAAhB,4CAAgB,kDAAA,8CAAA,gBAAA,2CAAA,kDAAA,8CAAA;cAChB,mBAAgB,UAAhB,4CAAgB,kDAAA,8CAAA,gBAAA,2CAAA,kDAAA,8CAAA;cAChB,sBAAmB,UAAnB,4CAAmB,qDAAA,8CAAA,gBAAA,2CAAA,qDAAA,8CAAA;cACnB,uBAAoB,UAApB,4CAAoB,sDAAA,8CAAA,gBAAA,2CAAA,sDAAA,8CAAA;cACpB,sBAAmB,UAAnB,4CAAmB,qDAAA,iDAAA,gBAAA,2CAAA,qDAAA,iDAAA;cACnB,wBAAqB,UAArB,4CAAqB,uDAAA,8CAAA,gBAAA,2CAAA,uDAAA,8CAAA;cACrB,qBAAkB,UAAlB,4CAAkB,oDAAA,+CAAA,gBAAA,2CAAA,oDAAA,+CAAA"}

package/dist/hooks/subnames.js

@@ -0,0 +1,17 @@
+"use client";
+
+import { makeMutationHook } from "./use-mutation.js";
+import { createCreateSubnameMutationAtom, createDeleteSubnameMutationAtom, createSetSubnameExpiryMutationAtom, createSetSubnameManagerMutationAtom, createSetSubnameRecordMutationAtom, createSetSubnameResolverMutationAtom, createTransferSubnameMutationAtom } from "../atoms/subnames.js";
+
+//#region src/hooks/subnames.ts
+const useCreateSubname = makeMutationHook(createCreateSubnameMutationAtom);
+const useDeleteSubname = makeMutationHook(createDeleteSubnameMutationAtom);
+const useSetSubnameExpiry = makeMutationHook(createSetSubnameExpiryMutationAtom);
+const useSetSubnameManager = makeMutationHook(createSetSubnameManagerMutationAtom);
+const useSetSubnameRecord = makeMutationHook(createSetSubnameRecordMutationAtom);
+const useSetSubnameResolver = makeMutationHook(createSetSubnameResolverMutationAtom);
+const useTransferSubname = makeMutationHook(createTransferSubnameMutationAtom);
+
+//#endregion
+export { useCreateSubname, useDeleteSubname, useSetSubnameExpiry, useSetSubnameManager, useSetSubnameRecord, useSetSubnameResolver, useTransferSubname };
+//# sourceMappingURL=subnames.js.map

package/dist/hooks/subnames.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subnames.js","names":[],"sources":["../../src/hooks/subnames.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  createCreateSubnameMutationAtom,\n  createDeleteSubnameMutationAtom,\n  createSetSubnameExpiryMutationAtom,\n  createSetSubnameManagerMutationAtom,\n  createSetSubnameRecordMutationAtom,\n  createSetSubnameResolverMutationAtom,\n  createTransferSubnameMutationAtom,\n} from \"../atoms/subnames.js\";\nimport { makeMutationHook } from \"./use-mutation.js\";\n\nexport const useCreateSubname = makeMutationHook(createCreateSubnameMutationAtom);\nexport const useDeleteSubname = makeMutationHook(createDeleteSubnameMutationAtom);\nexport const useSetSubnameExpiry = makeMutationHook(createSetSubnameExpiryMutationAtom);\nexport const useSetSubnameManager = makeMutationHook(createSetSubnameManagerMutationAtom);\nexport const useSetSubnameRecord = makeMutationHook(createSetSubnameRecordMutationAtom);\nexport const useSetSubnameResolver = makeMutationHook(createSetSubnameResolverMutationAtom);\nexport const useTransferSubname = makeMutationHook(createTransferSubnameMutationAtom);\n"],"mappings":";;;;;;AAaA,MAAa,mBAAmB,iBAAiB,+BAA+B;AAChF,MAAa,mBAAmB,iBAAiB,+BAA+B;AAChF,MAAa,sBAAsB,iBAAiB,kCAAkC;AACtF,MAAa,uBAAuB,iBAAiB,mCAAmC;AACxF,MAAa,sBAAsB,iBAAiB,kCAAkC;AACtF,MAAa,wBAAwB,iBAAiB,oCAAoC;AAC1F,MAAa,qBAAqB,iBAAiB,iCAAiC"}

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

@@ -0,0 +1,11 @@
+import { EnsforgeInvalidation } 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>;
+}
+declare const useInvalidateEnsforge: () => InvalidateEnsforge;
+//#endregion
+export { InvalidateEnsforge, useInvalidateEnsforge };
+//# sourceMappingURL=use-cache.d.ts.map

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

@@ -0,0 +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"}

package/dist/hooks/use-cache.js

@@ -0,0 +1,20 @@
+"use client";
+
+import { invalidateEnsforgeEffect } 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 registry = useContext(RegistryContext);
+	const { sdk } = useEnsforgeContext();
+	const effect = (invalidation = { all: true }) => invalidateEnsforgeEffect(registry, sdk, invalidation);
+	const invalidate = (invalidation, options) => Effect.runPromise(effect(invalidation), options);
+	return Object.assign(invalidate, { effect });
+};
+
+//#endregion
+export { useInvalidateEnsforge };
+//# sourceMappingURL=use-cache.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,8 @@
+import { EnsMutationAtomFactory } from "../atoms/mutation.js";
+import { EnsMutationOptions } from "../mutation/options.js";
+import { EnsMutationResult } from "../mutation/result.js";
+//#region src/hooks/use-mutation.d.ts
+declare const makeMutationHook: <Parameters, Success, Failure>(factory: EnsMutationAtomFactory<Parameters, Success, Failure>) => (options?: EnsMutationOptions<Parameters, Success, Failure>) => EnsMutationResult<Parameters, Success, Failure>;
+//#endregion
+export { makeMutationHook };
+//# sourceMappingURL=use-mutation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-mutation.d.ts","names":[],"sources":["../../src/hooks/use-mutation.ts"],"mappings":";;;;cAca,mBACV,YAAY,SAAS,SAAS,SAAS,uBAAuB,YAAY,SAAS,cAElF,UAAS,mBAAmB,YAAY,SAAS,aAChD,kBAAkB,YAAY,SAAS"}

package/dist/hooks/use-mutation.js

@@ -0,0 +1,79 @@
+"use client";
+
+import { useEnsforgeContext } from "../provider/context.js";
+import { errorFromCause } from "../query/result.js";
+import { Cause, Effect, Exit, Option } from "effect";
+import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
+import { RegistryContext, useAtomValue } from "@effect/atom-react";
+import { useContext, useRef, useState } from "react";
+
+//#region src/hooks/use-mutation.ts
+const makeMutationHook = (factory) => (options = {}) => {
+	const { sdk } = useEnsforgeContext();
+	const registry = useContext(RegistryContext);
+	const atomRef = useRef(void 0);
+	const [parameters, setParameters] = useState(void 0);
+	if (atomRef.current === void 0) atomRef.current = factory(sdk);
+	const atom = atomRef.current;
+	const result = useAtomValue(atom);
+	const mutateEffect = (nextParameters) => {
+		const effect = Effect.sync(() => {
+			setParameters(nextParameters);
+			registry.set(atom, nextParameters);
+		}).pipe(Effect.andThen(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true })));
+		return options.retry === void 0 || options.retry === false ? effect : effect.pipe(Effect.retry({ times: options.retry }));
+	};
+	const runCallbacks = (exit, nextParameters, local) => {
+		if (Exit.isSuccess(exit)) {
+			options.onSuccess?.(exit.value, nextParameters);
+			local?.onSuccess?.(exit.value, nextParameters);
+			options.onSettled?.(exit.value, null, nextParameters);
+			local?.onSettled?.(exit.value, null, nextParameters);
+			return;
+		}
+		const error = errorFromCause(exit.cause);
+		options.onError?.(error, nextParameters);
+		local?.onError?.(error, nextParameters);
+		options.onSettled?.(void 0, error, nextParameters);
+		local?.onSettled?.(void 0, error, nextParameters);
+	};
+	const mutate = (nextParameters, callbacks) => {
+		Effect.runPromiseExit(mutateEffect(nextParameters)).then((exit) => runCallbacks(exit, nextParameters, callbacks));
+	};
+	const mutateAsync = async (nextParameters) => {
+		const exit = await Effect.runPromiseExit(mutateEffect(nextParameters));
+		runCallbacks(exit, nextParameters, void 0);
+		if (Exit.isSuccess(exit)) return exit.value;
+		throw Cause.squash(exit.cause);
+	};
+	const cause = Option.getOrNull(AsyncResult.cause(result));
+	const data = Option.getOrUndefined(AsyncResult.value(result));
+	const isIdle = AsyncResult.isInitial(result) && !result.waiting;
+	const isPending = result.waiting;
+	const isError = AsyncResult.isFailure(result);
+	const isSuccess = AsyncResult.isSuccess(result) && !result.waiting;
+	return {
+		cause,
+		data,
+		error: cause === null ? null : errorFromCause(cause),
+		interrupt: () => registry.set(atom, Atom.Interrupt),
+		isError,
+		isIdle,
+		isPending,
+		isSuccess,
+		mutate,
+		mutateAsync,
+		mutateEffect,
+		parameters,
+		reset: () => {
+			setParameters(void 0);
+			registry.set(atom, Atom.Reset);
+		},
+		result,
+		status: isPending ? "pending" : isError ? "error" : isSuccess ? "success" : "idle"
+	};
+};
+
+//#endregion
+export { makeMutationHook };
+//# sourceMappingURL=use-mutation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-mutation.js","names":[],"sources":["../../src/hooks/use-mutation.ts"],"sourcesContent":["\"use client\";\n\nimport { useContext, useRef, useState } from \"react\";\n\nimport { RegistryContext, useAtomValue } from \"@effect/atom-react\";\nimport { Cause, Effect, Exit, Option } from \"effect\";\nimport { AsyncResult, Atom, AtomRegistry } from \"effect/unstable/reactivity\";\n\nimport type { EnsMutationAtomFactory } from \"../atoms/mutation.js\";\nimport type { EnsMutationCallbacks, EnsMutationOptions } from \"../mutation/options.js\";\nimport type { EnsMutationResult } from \"../mutation/result.js\";\nimport { useEnsforgeContext } from \"../provider/context.js\";\nimport { errorFromCause } from \"../query/result.js\";\n\nexport const makeMutationHook =\n  <Parameters, Success, Failure>(factory: EnsMutationAtomFactory<Parameters, Success, Failure>) =>\n  (\n    options: EnsMutationOptions<Parameters, Success, Failure> = {},\n  ): EnsMutationResult<Parameters, Success, Failure> => {\n    const { sdk } = useEnsforgeContext();\n    const registry = useContext(RegistryContext);\n    const atomRef = useRef<ReturnType<typeof factory> | undefined>(undefined);\n    const [parameters, setParameters] = useState<Parameters | undefined>(undefined);\n    if (atomRef.current === undefined) atomRef.current = factory(sdk);\n    const atom = atomRef.current;\n    const result = useAtomValue(atom);\n\n    const mutateEffect = (nextParameters: Parameters): Effect.Effect<Success, Failure> => {\n      const effect = Effect.sync(() => {\n        setParameters(nextParameters);\n        registry.set(atom, nextParameters);\n      }).pipe(\n        Effect.andThen(\n          AtomRegistry.getResult(registry, atom, {\n            suspendOnWaiting: true,\n          }),\n        ),\n      );\n      return options.retry === undefined || options.retry === false\n        ? effect\n        : effect.pipe(Effect.retry({ times: options.retry }));\n    };\n\n    const runCallbacks = (\n      exit: Exit.Exit<Success, Failure>,\n      nextParameters: Parameters,\n      local: EnsMutationCallbacks<Parameters, Success, Failure> | undefined,\n    ) => {\n      if (Exit.isSuccess(exit)) {\n        options.onSuccess?.(exit.value, nextParameters);\n        local?.onSuccess?.(exit.value, nextParameters);\n        options.onSettled?.(exit.value, null, nextParameters);\n        local?.onSettled?.(exit.value, null, nextParameters);\n        return;\n      }\n\n      const error = errorFromCause(exit.cause);\n      options.onError?.(error, nextParameters);\n      local?.onError?.(error, nextParameters);\n      options.onSettled?.(undefined, error, nextParameters);\n      local?.onSettled?.(undefined, error, nextParameters);\n    };\n\n    const mutate = (\n      nextParameters: Parameters,\n      callbacks?: EnsMutationCallbacks<Parameters, Success, Failure>,\n    ) => {\n      void Effect.runPromiseExit(mutateEffect(nextParameters)).then((exit) =>\n        runCallbacks(exit, nextParameters, callbacks),\n      );\n    };\n\n    const mutateAsync = async (nextParameters: Parameters): Promise<Success> => {\n      const exit = await Effect.runPromiseExit(mutateEffect(nextParameters));\n      runCallbacks(exit, nextParameters, undefined);\n      if (Exit.isSuccess(exit)) return exit.value;\n      throw Cause.squash(exit.cause);\n    };\n\n    const cause = Option.getOrNull(AsyncResult.cause(result));\n    const data = Option.getOrUndefined(AsyncResult.value(result));\n    const isIdle = AsyncResult.isInitial(result) && !result.waiting;\n    const isPending = result.waiting;\n    const isError = AsyncResult.isFailure(result);\n    const isSuccess = AsyncResult.isSuccess(result) && !result.waiting;\n\n    return {\n      cause,\n      data,\n      error: cause === null ? null : errorFromCause(cause),\n      interrupt: () => registry.set(atom, Atom.Interrupt),\n      isError,\n      isIdle,\n      isPending,\n      isSuccess,\n      mutate,\n      mutateAsync,\n      mutateEffect,\n      parameters,\n      reset: () => {\n        setParameters(undefined);\n        registry.set(atom, Atom.Reset);\n      },\n      result,\n      status: isPending ? \"pending\" : isError ? \"error\" : isSuccess ? \"success\" : \"idle\",\n    };\n  };\n"],"mappings":";;;;;;;;;;AAcA,MAAa,oBACoB,aAE7B,UAA4D,CAAC,MACT;CACpD,MAAM,EAAE,QAAQ,mBAAmB;CACnC,MAAM,WAAW,WAAW,eAAe;CAC3C,MAAM,UAAU,OAA+C,MAAS;CACxE,MAAM,CAAC,YAAY,iBAAiB,SAAiC,MAAS;CAC9E,IAAI,QAAQ,YAAY,QAAW,QAAQ,UAAU,QAAQ,GAAG;CAChE,MAAM,OAAO,QAAQ;CACrB,MAAM,SAAS,aAAa,IAAI;CAEhC,MAAM,gBAAgB,mBAAgE;EACpF,MAAM,SAAS,OAAO,WAAW;GAC/B,cAAc,cAAc;GAC5B,SAAS,IAAI,MAAM,cAAc;EACnC,CAAC,CAAC,CAAC,KACD,OAAO,QACL,aAAa,UAAU,UAAU,MAAM,EACrC,kBAAkB,KACpB,CAAC,CACH,CACF;EACA,OAAO,QAAQ,UAAU,UAAa,QAAQ,UAAU,QACpD,SACA,OAAO,KAAK,OAAO,MAAM,EAAE,OAAO,QAAQ,MAAM,CAAC,CAAC;CACxD;CAEA,MAAM,gBACJ,MACA,gBACA,UACG;EACH,IAAI,KAAK,UAAU,IAAI,GAAG;GACxB,QAAQ,YAAY,KAAK,OAAO,cAAc;GAC9C,OAAO,YAAY,KAAK,OAAO,cAAc;GAC7C,QAAQ,YAAY,KAAK,OAAO,MAAM,cAAc;GACpD,OAAO,YAAY,KAAK,OAAO,MAAM,cAAc;GACnD;EACF;EAEA,MAAM,QAAQ,eAAe,KAAK,KAAK;EACvC,QAAQ,UAAU,OAAO,cAAc;EACvC,OAAO,UAAU,OAAO,cAAc;EACtC,QAAQ,YAAY,QAAW,OAAO,cAAc;EACpD,OAAO,YAAY,QAAW,OAAO,cAAc;CACrD;CAEA,MAAM,UACJ,gBACA,cACG;EACH,AAAK,OAAO,eAAe,aAAa,cAAc,CAAC,CAAC,CAAC,MAAM,SAC7D,aAAa,MAAM,gBAAgB,SAAS,CAC9C;CACF;CAEA,MAAM,cAAc,OAAO,mBAAiD;EAC1E,MAAM,OAAO,MAAM,OAAO,eAAe,aAAa,cAAc,CAAC;EACrE,aAAa,MAAM,gBAAgB,MAAS;EAC5C,IAAI,KAAK,UAAU,IAAI,GAAG,OAAO,KAAK;EACtC,MAAM,MAAM,OAAO,KAAK,KAAK;CAC/B;CAEA,MAAM,QAAQ,OAAO,UAAU,YAAY,MAAM,MAAM,CAAC;CACxD,MAAM,OAAO,OAAO,eAAe,YAAY,MAAM,MAAM,CAAC;CAC5D,MAAM,SAAS,YAAY,UAAU,MAAM,KAAK,CAAC,OAAO;CACxD,MAAM,YAAY,OAAO;CACzB,MAAM,UAAU,YAAY,UAAU,MAAM;CAC5C,MAAM,YAAY,YAAY,UAAU,MAAM,KAAK,CAAC,OAAO;CAE3D,OAAO;EACL;EACA;EACA,OAAO,UAAU,OAAO,OAAO,eAAe,KAAK;EACnD,iBAAiB,SAAS,IAAI,MAAM,KAAK,SAAS;EAClD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,aAAa;GACX,cAAc,MAAS;GACvB,SAAS,IAAI,MAAM,KAAK,KAAK;EAC/B;EACA;EACA,QAAQ,YAAY,YAAY,UAAU,UAAU,YAAY,YAAY;CAC9E;AACF"}

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

@@ -0,0 +1,10 @@
+import { EnsQueryAtomFactory } from "../atoms/query.js";
+import { UseEnsQueryParameters } from "../query/options.js";
+import { EnsQueryResult } from "../query/result.js";
+import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
+//#region src/hooks/use-query.d.ts
+declare const makeQueryHook: <Parameters extends object, Success, Failure>(factory: EnsQueryAtomFactory<Parameters, Success, Failure>) => <Selected = Success>(input: UseEnsQueryParameters<Parameters, Success, Selected>) => EnsQueryResult<Selected, Failure>;
+declare const prefetchQueryAtom: <Success, Failure>(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>, signal?: AbortSignal) => Promise<Success>;
+//#endregion
+export { makeQueryHook, prefetchQueryAtom };
+//# sourceMappingURL=use-query.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-query.d.ts","names":[],"sources":["../../src/hooks/use-query.ts"],"mappings":";;;;;cAiGa,gBACV,2BAA2B,SAAS,SACnC,SAAS,oBAAoB,YAAY,SAAS,cAEnD,WAAW,SACV,OAAO,sBAAsB,YAAY,SAAS,cACjD,eAAe,UAAU;cAGjB,oBAAqB,SAAS,SACzC,UAAU,aAAa,cACvB,MAAM,KAAK,KAAK,YAAY,YAAY,SAAS,WACjD,SAAS,gBACR,QAAQ"}

package/dist/hooks/use-query.js

@@ -0,0 +1,81 @@
+"use client";
+
+import { useEnsforgeContext } from "../provider/context.js";
+import { errorFromCause, resultUpdatedAt } from "../query/result.js";
+import { resolveEnsQueryOptions } from "../query/options.js";
+import { Effect, Option } from "effect";
+import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
+import { RegistryContext, useAtomValue } from "@effect/atom-react";
+import { useContext, useEffect, useRef } from "react";
+
+//#region src/hooks/use-query.ts
+const disabledAtom = Atom.make(AsyncResult.initial());
+const splitQueryParameters = (input) => {
+	const { query, ...parameters } = input;
+	return [parameters, query];
+};
+const useQueryAtom = (factory, input) => {
+	const { defaults, sdk } = useEnsforgeContext();
+	const registry = useContext(RegistryContext);
+	const [parameters, query] = splitQueryParameters(input);
+	const options = resolveEnsQueryOptions(defaults.queries, query);
+	const enabled = query?.enabled ?? true;
+	const atom = factory(sdk, parameters, options);
+	const rawResult = useAtomValue(enabled ? atom : disabledAtom);
+	const result = query?.select === void 0 ? rawResult : AsyncResult.map(rawResult, query.select);
+	const staleCheckedAtom = useRef(void 0);
+	useEffect(() => {
+		if (staleCheckedAtom.current === atom) return;
+		staleCheckedAtom.current = atom;
+		if (!enabled || !AsyncResult.isSuccess(rawResult)) return;
+		if (Date.now() - rawResult.timestamp >= options.staleTime) registry.refresh(atom);
+	}, [
+		atom,
+		enabled,
+		options.staleTime,
+		rawResult,
+		registry
+	]);
+	useEffect(() => {
+		if (!enabled || options.refetchInterval === false) return;
+		const interval = globalThis.setInterval(() => registry.refresh(atom), options.refetchInterval);
+		return () => globalThis.clearInterval(interval);
+	}, [
+		atom,
+		enabled,
+		options.refetchInterval,
+		registry
+	]);
+	const refetchEffect = () => {
+		const effect = Effect.sync(() => registry.refresh(atom)).pipe(Effect.andThen(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true })));
+		return query?.select === void 0 ? effect : effect.pipe(Effect.map(query.select));
+	};
+	const cause = Option.getOrNull(AsyncResult.cause(result));
+	const data = Option.getOrUndefined(AsyncResult.value(result));
+	const isPending = AsyncResult.isInitial(result);
+	const isError = AsyncResult.isFailure(result);
+	const isSuccess = AsyncResult.isSuccess(result);
+	return {
+		cause,
+		data,
+		error: cause === null ? null : errorFromCause(cause),
+		fetchStatus: result.waiting ? "fetching" : "idle",
+		isError,
+		isFetching: result.waiting,
+		isLoading: isPending && result.waiting,
+		isPending,
+		isRefetching: !isPending && result.waiting,
+		isSuccess,
+		refetch: () => Effect.runPromise(refetchEffect()),
+		refetchEffect,
+		result,
+		status: isPending ? "pending" : isError ? "error" : "success",
+		updatedAt: resultUpdatedAt(result)
+	};
+};
+const makeQueryHook = (factory) => (input) => useQueryAtom(factory, input);
+const prefetchQueryAtom = (registry, atom, signal) => Effect.runPromise(AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }), { signal });
+
+//#endregion
+export { makeQueryHook, prefetchQueryAtom, useQueryAtom };
+//# sourceMappingURL=use-query.js.map