@ensforge/react 0.0.0 → 0.1.1

package/dist/atoms/name.d.ts

@@ -1,7 +1,7 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 //#region src/atoms/name.d.ts
-declare const getCanonicalResourceAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, bigint | null, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getExpiryAtom: EnsQueryAtomFactory<import("@ensforge/core").GetExpiryParameters, {
+declare const getCanonicalResourceAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, bigint | null, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getExpiryAtom: EnsAtomFactory<import("@ensforge/core").GetExpiryParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly expiry: bigint;
   readonly gracePeriod: bigint;
@@ -9,14 +9,14 @@ declare const getExpiryAtom: EnsQueryAtomFactory<import("@ensforge/core").GetExp
   readonly protocol: "v1" | "v2";
   readonly source: "registry" | "nameWrapper" | "baseRegistrar";
 } | null, import("@ensforge/core").GetExpiryError>;
-declare const getManagerAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}` | null, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getNameStateAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, {
+declare const getManagerAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}` | null, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getNameStateAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, {
   readonly kind: "available";
   readonly protocol: "v1" | "v2";
   readonly wrapped: false;
   readonly migrated: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
-  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly status: "available" | "active" | "grace" | "expired" | "reserved";
   readonly owner: `0x${string}` | null;
   readonly manager: `0x${string}` | null;
   readonly registrant: `0x${string}` | null;
@@ -34,7 +34,7 @@ declare const getNameStateAtom: EnsQueryAtomFactory<import("@ensforge/core").Get
   readonly wrapped: false;
   readonly migrated: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
-  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly status: "available" | "active" | "grace" | "expired" | "reserved";
   readonly owner: `0x${string}` | null;
   readonly manager: `0x${string}` | null;
   readonly registrant: `0x${string}` | null;
@@ -52,7 +52,7 @@ declare const getNameStateAtom: EnsQueryAtomFactory<import("@ensforge/core").Get
   readonly wrapped: true;
   readonly migrated: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
-  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly status: "available" | "active" | "grace" | "expired" | "reserved";
   readonly owner: `0x${string}` | null;
   readonly manager: `0x${string}` | null;
   readonly registrant: `0x${string}` | null;
@@ -70,7 +70,7 @@ declare const getNameStateAtom: EnsQueryAtomFactory<import("@ensforge/core").Get
   readonly wrapped: boolean;
   readonly migrated: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
-  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly status: "available" | "active" | "grace" | "expired" | "reserved";
   readonly owner: `0x${string}` | null;
   readonly manager: `0x${string}` | null;
   readonly registrant: `0x${string}` | null;
@@ -88,7 +88,7 @@ declare const getNameStateAtom: EnsQueryAtomFactory<import("@ensforge/core").Get
   readonly wrapped: boolean;
   readonly migrated: true;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
-  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly status: "available" | "active" | "grace" | "expired" | "reserved";
   readonly owner: `0x${string}` | null;
   readonly manager: `0x${string}` | null;
   readonly registrant: `0x${string}` | null;
@@ -106,7 +106,7 @@ declare const getNameStateAtom: EnsQueryAtomFactory<import("@ensforge/core").Get
   readonly wrapped: boolean;
   readonly migrated: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
-  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly status: "available" | "active" | "grace" | "expired" | "reserved";
   readonly owner: `0x${string}` | null;
   readonly manager: `0x${string}` | null;
   readonly registrant: `0x${string}` | null;
@@ -119,23 +119,23 @@ declare const getNameStateAtom: EnsQueryAtomFactory<import("@ensforge/core").Get
   readonly available: boolean;
   readonly renewable: boolean;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getNameStatusAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, "available" | "reserved" | "active" | "grace" | "expired", import("@ensforge/core").GetCanonicalResourceError>;
-declare const getOwnerAtom: EnsQueryAtomFactory<import("@ensforge/core").GetOwnerParameters, {
+declare const getNameStatusAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, "available" | "active" | "grace" | "expired" | "reserved", import("@ensforge/core").GetCanonicalResourceError>;
+declare const getOwnerAtom: EnsAtomFactory<import("@ensforge/core").GetOwnerParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly owner: `0x${string}` | null;
   readonly registrant: `0x${string}` | null;
   readonly protocol: "v1" | "v2";
-  readonly ownershipLevel: "registrar" | "registry" | "nameWrapper";
+  readonly ownershipLevel: "registry" | "registrar" | "nameWrapper";
 } | null, import("@ensforge/core").GetOwnerError>;
-declare const getProtocolAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, "v1" | "v2", import("@ensforge/core").GetCanonicalResourceError>;
-declare const getRegistrantAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}` | null, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getRegistryAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}`, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getTokenIdAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, bigint | null, import("@ensforge/core").GetCanonicalResourceError>;
-declare const isAvailableAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
-declare const isMigratedAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
-declare const isRenewableAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
-declare const isReservedAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
-declare const isWrappedAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getProtocolAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, "v1" | "v2", import("@ensforge/core").GetCanonicalResourceError>;
+declare const getRegistrantAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}` | null, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getRegistryAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}`, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getTokenIdAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, bigint | null, import("@ensforge/core").GetCanonicalResourceError>;
+declare const isAvailableAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
+declare const isMigratedAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
+declare const isRenewableAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
+declare const isReservedAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
+declare const isWrappedAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
 //#endregion
 export { getCanonicalResourceAtom, getExpiryAtom, getManagerAtom, getNameStateAtom, getNameStatusAtom, getOwnerAtom, getProtocolAtom, getRegistrantAtom, getRegistryAtom, getTokenIdAtom, isAvailableAtom, isMigratedAtom, isRenewableAtom, isReservedAtom, isWrappedAtom };
 //# sourceMappingURL=name.d.ts.map

package/dist/atoms/name.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"name.d.ts","names":[],"sources":["../../src/atoms/name.ts"],"mappings":";;cAEa,0BAAA,6CAAwB,wEAAA;cAIxB,eAAA,6CAAa;;;;;;;mCAAqD;cAClE,gBAAA,6CAAc,+EAAA;cACd,kBAAA,6CAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAwD;cACxE,mBAAA,6CAAiB,oHAAA;cACjB,cAAA,6CAAY;;;;;;mCAAoD;cAChE,iBAAA,6CAAe,sEAAA;cACf,mBAAA,6CAAiB,+EAAA;cACjB,iBAAA,6CAAe,wEAAA;cACf,gBAAA,6CAAc,wEAAA;cACd,iBAAA,6CAAe,kEAAA;cACf,gBAAA,6CAAc,kEAAA;cACd,iBAAA,6CAAe,kEAAA;cACf,gBAAA,6CAAc,kEAAA;cACd,eAAA,6CAAa,kEAAA"}
+{"version":3,"file":"name.d.ts","names":[],"sources":["../../src/atoms/name.ts"],"mappings":";;cAEa,0BAAA,wCAAwB,wEAAA;cAIxB,eAAA,wCAAa;;;;;;;mCAAqD;cAClE,gBAAA,wCAAc,+EAAA;cACd,kBAAA,wCAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAwD;cACxE,mBAAA,wCAAiB,oHAAA;cACjB,cAAA,wCAAY;;;;;;mCAAoD;cAChE,iBAAA,wCAAe,sEAAA;cACf,mBAAA,wCAAiB,+EAAA;cACjB,iBAAA,wCAAe,wEAAA;cACf,gBAAA,wCAAc,wEAAA;cACd,iBAAA,wCAAe,kEAAA;cACf,gBAAA,wCAAc,kEAAA;cACd,iBAAA,wCAAe,kEAAA;cACf,gBAAA,wCAAc,kEAAA;cACd,eAAA,wCAAa,kEAAA"}

package/dist/atoms/ownership.d.ts

@@ -1,7 +1,7 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 import { EnsMutationAtomFactory } from "./mutation.js";
 //#region src/atoms/ownership.d.ts
-declare const getTtlAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, import("@ensforge/core").GetTtlResult, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getTtlAtom: EnsAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, import("@ensforge/core").GetTtlResult, import("@ensforge/core").GetCanonicalResourceError>;
 declare const createReclaimNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ReclaimNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createSetManagerMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetManagerParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createSetTtlMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetTtlParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;

package/dist/atoms/ownership.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ownership.d.ts","names":[],"sources":["../../src/atoms/ownership.ts"],"mappings":";;;cAGa,YAAA,6CAAU,yDAAA,uCAAA;cAEV,+BAAA,gDAA6B,gDAAA,8CAAA;cAI7B,8BAAA,gDAA4B,+CAAA,8CAAA;cAI5B,0BAAA,gDAAwB,2CAAA,8CAAA;cAIxB,gCAAA,gDAA8B,iDAAA,+CAAA;cAI9B,sCAAA,gDAAoC,uDAAA,8CAAA"}
+{"version":3,"file":"ownership.d.ts","names":[],"sources":["../../src/atoms/ownership.ts"],"mappings":";;;cAGa,YAAA,wCAAU,yDAAA,uCAAA;cAEV,+BAAA,gDAA6B,gDAAA,8CAAA;cAI7B,8BAAA,gDAA4B,+CAAA,8CAAA;cAI5B,0BAAA,gDAAwB,2CAAA,8CAAA;cAIxB,gCAAA,gDAA8B,iDAAA,+CAAA;cAI9B,sCAAA,gDAAoC,uDAAA,8CAAA"}

package/dist/atoms/query.d.ts

@@ -1,18 +1,13 @@
 import { BoundEffectAction } from "../internal/action-types.js";
+import { EnsAtomOptions } from "../query/options.js";
 import { Ensforge } from "@ensforge/sdk";
 import { AsyncResult, Atom } from "effect/unstable/reactivity";
 //#region src/atoms/query.d.ts
-interface QueryAtomOptions {
-  readonly gcTime: number;
-  readonly refetchOnWindowFocus: boolean;
-  readonly retry: false | number;
+type EnsAtom<Success, Failure> = Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>;
+interface EnsAtomFactory<Parameters, Success, Failure> {
+  (sdk: Ensforge, parameters: Parameters, options?: EnsAtomOptions<Failure>): EnsAtom<Success, Failure>;
 }
-type EnsQueryAtom<Success, Failure> = Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>;
-interface EnsQueryAtomFactory<Parameters, Success, Failure> {
-  (sdk: Ensforge, parameters: Parameters, options: QueryAtomOptions): EnsQueryAtom<Success, Failure>;
-}
-declare const defaultQueryAtomOptions: QueryAtomOptions;
-declare const makeQueryAtom: <Parameters, Success, Failure>(group: string, getAction: (sdk: Ensforge) => BoundEffectAction<Parameters, Success, Failure>) => EnsQueryAtomFactory<Parameters, Success, Failure>;
+declare const makeQueryAtom: <Parameters, Success, Failure>(group: string, getAction: (sdk: Ensforge) => BoundEffectAction<Parameters, Success, Failure>) => EnsAtomFactory<Parameters, Success, Failure>;
 //#endregion
-export { EnsQueryAtom, EnsQueryAtomFactory, QueryAtomOptions, defaultQueryAtomOptions, makeQueryAtom };
+export { EnsAtom, EnsAtomFactory, makeQueryAtom };
 //# sourceMappingURL=query.d.ts.map

package/dist/atoms/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","names":[],"sources":["../../src/atoms/query.ts"],"mappings":";;;;UAUiB;WACN;WACA;WACA;;KASC,aAAa,SAAS,WAAW,KAAK,KAAK,YAAY,YAAY,SAAS;UAEvE,oBAAoB,YAAY,SAAS;GAEtD,KAAK,UACL,YAAY,YACZ,SAAS,mBACR,aAAa,SAAS;;cAGd,yBAAyB;cAMzB,gBAAiB,YAAY,SAAS,SACjD,eACA,YAAY,KAAK,aAAa,kBAAkB,YAAY,SAAS,aACpE,oBAAoB,YAAY,SAAS"}
+{"version":3,"file":"query.d.ts","names":[],"sources":["../../src/atoms/query.ts"],"mappings":";;;;;KAoBY,QAAQ,SAAS,WAAW,KAAK,KAAK,YAAY,YAAY,SAAS;UAElE,eAAe,YAAY,SAAS;GAEjD,KAAK,UACL,YAAY,YACZ,UAAU,eAAe,WACxB,QAAQ,SAAS;;cA0BT,gBAAiB,YAAY,SAAS,SACjD,eACA,YAAY,KAAK,aAAa,kBAAkB,YAAY,SAAS,aACpE,eAAe,YAAY,SAAS"}

package/dist/atoms/query.js

@@ -1,30 +1,33 @@
 import { atomRuntime } from "../internal/runtime.js";
 import { makeReactivityKeys } from "../query/keys.js";
+import { resolveEnsAtomOptions } from "../query/options.js";
 import { Data, Effect } from "effect";
 import { Atom } from "effect/unstable/reactivity";
 
 //#region src/atoms/query.ts
 var QueryAtomInput = class extends Data.Class {};
-const defaultQueryAtomOptions = Object.freeze({
-	gcTime: 3e5,
-	refetchOnWindowFocus: false,
-	retry: false
-});
+const configureAtom = (source, options, reactivityKeys) => {
+	let atom = source.pipe(Atom.withReactivity(reactivityKeys), Atom.setIdleTTL(options.idleTTL));
+	if (options.swr !== false) atom = atom.pipe(Atom.swr({
+		...options.swr,
+		focusSignal: Atom.windowFocusSignal
+	}));
+	if (options.refreshInterval !== false) atom = atom.pipe(Atom.withRefresh(options.refreshInterval));
+	return atom;
+};
 const makeQueryAtom = (group, getAction) => {
 	const family = Atom.family((input) => {
 		const actionEffect = Effect.suspend(() => getAction(input.sdk).effect(input.parameters));
-		const effect = input.options.retry === false ? actionEffect : actionEffect.pipe(Effect.retry({ times: input.options.retry }));
-		let atom = atomRuntime.atom(effect).pipe(Atom.withReactivity(makeReactivityKeys(input.sdk, group, input.parameters)), Atom.setIdleTTL(input.options.gcTime));
-		if (input.options.refetchOnWindowFocus) atom = atom.pipe(Atom.refreshOnWindowFocus);
-		return atom;
+		const effect = input.options.retry === false ? actionEffect : actionEffect.pipe(Effect.retry(input.options.retry));
+		return configureAtom(atomRuntime.atom(effect), input.options, makeReactivityKeys(input.sdk, group, input.parameters));
 	});
 	return (sdk, parameters, options) => family(new QueryAtomInput({
-		options,
+		options: resolveEnsAtomOptions(void 0, options),
 		parameters,
 		sdk
 	}));
 };
 
 //#endregion
-export { defaultQueryAtomOptions, makeQueryAtom };
+export { configureAtom, makeQueryAtom };
 //# sourceMappingURL=query.js.map

package/dist/atoms/query.js.map

@@ -1 +1 @@
-{"version":3,"file":"query.js","names":[],"sources":["../../src/atoms/query.ts"],"sourcesContent":["import { Data, Effect } from \"effect\";\nimport { Atom } from \"effect/unstable/reactivity\";\nimport type { AsyncResult } from \"effect/unstable/reactivity\";\n\nimport type { Ensforge } from \"@ensforge/sdk\";\n\nimport type { BoundEffectAction } from \"../internal/action-types.js\";\nimport { atomRuntime } from \"../internal/runtime.js\";\nimport { makeReactivityKeys } from \"../query/keys.js\";\n\nexport interface QueryAtomOptions {\n  readonly gcTime: number;\n  readonly refetchOnWindowFocus: boolean;\n  readonly retry: false | number;\n}\n\nclass QueryAtomInput<Parameters> extends Data.Class<{\n  readonly options: QueryAtomOptions;\n  readonly parameters: Parameters;\n  readonly sdk: Ensforge;\n}> {}\n\nexport type EnsQueryAtom<Success, Failure> = Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>;\n\nexport interface EnsQueryAtomFactory<Parameters, Success, Failure> {\n  (\n    sdk: Ensforge,\n    parameters: Parameters,\n    options: QueryAtomOptions,\n  ): EnsQueryAtom<Success, Failure>;\n}\n\nexport const defaultQueryAtomOptions: QueryAtomOptions = Object.freeze({\n  gcTime: 5 * 60_000,\n  refetchOnWindowFocus: false,\n  retry: false,\n});\n\nexport const makeQueryAtom = <Parameters, Success, Failure>(\n  group: string,\n  getAction: (sdk: Ensforge) => BoundEffectAction<Parameters, Success, Failure>,\n): EnsQueryAtomFactory<Parameters, Success, Failure> => {\n  const family = Atom.family((input: QueryAtomInput<Parameters>) => {\n    const actionEffect = Effect.suspend(() => getAction(input.sdk).effect(input.parameters));\n    const effect =\n      input.options.retry === false\n        ? actionEffect\n        : actionEffect.pipe(Effect.retry({ times: input.options.retry }));\n    let atom = atomRuntime\n      .atom(effect)\n      .pipe(\n        Atom.withReactivity(makeReactivityKeys(input.sdk, group, input.parameters)),\n        Atom.setIdleTTL(input.options.gcTime),\n      );\n\n    if (input.options.refetchOnWindowFocus) {\n      atom = atom.pipe(Atom.refreshOnWindowFocus);\n    }\n\n    return atom;\n  });\n\n  return (sdk, parameters, options) =>\n    family(\n      new QueryAtomInput({\n        options,\n        parameters,\n        sdk,\n      }),\n    );\n};\n"],"mappings":";;;;;;AAgBA,IAAM,iBAAN,cAAyC,KAAK,MAI3C,CAAC;AAYJ,MAAa,0BAA4C,OAAO,OAAO;CACrE,QAAQ;CACR,sBAAsB;CACtB,OAAO;AACT,CAAC;AAED,MAAa,iBACX,OACA,cACsD;CACtD,MAAM,SAAS,KAAK,QAAQ,UAAsC;EAChE,MAAM,eAAe,OAAO,cAAc,UAAU,MAAM,GAAG,CAAC,CAAC,OAAO,MAAM,UAAU,CAAC;EACvF,MAAM,SACJ,MAAM,QAAQ,UAAU,QACpB,eACA,aAAa,KAAK,OAAO,MAAM,EAAE,OAAO,MAAM,QAAQ,MAAM,CAAC,CAAC;EACpE,IAAI,OAAO,YACR,KAAK,MAAM,CAAC,CACZ,KACC,KAAK,eAAe,mBAAmB,MAAM,KAAK,OAAO,MAAM,UAAU,CAAC,GAC1E,KAAK,WAAW,MAAM,QAAQ,MAAM,CACtC;EAEF,IAAI,MAAM,QAAQ,sBAChB,OAAO,KAAK,KAAK,KAAK,oBAAoB;EAG5C,OAAO;CACT,CAAC;CAED,QAAQ,KAAK,YAAY,YACvB,OACE,IAAI,eAAe;EACjB;EACA;EACA;CACF,CAAC,CACH;AACJ"}
+{"version":3,"file":"query.js","names":[],"sources":["../../src/atoms/query.ts"],"sourcesContent":["import { Data, Effect } from \"effect\";\nimport { Atom, type AsyncResult } from \"effect/unstable/reactivity\";\n\nimport type { Ensforge } from \"@ensforge/sdk\";\n\nimport type { BoundEffectAction } from \"../internal/action-types.js\";\nimport { atomRuntime } from \"../internal/runtime.js\";\nimport { makeReactivityKeys } from \"../query/keys.js\";\nimport {\n  resolveEnsAtomOptions,\n  type EnsAtomOptions,\n  type ResolvedEnsAtomOptions,\n} from \"../query/options.js\";\n\nclass QueryAtomInput<Parameters, Failure> extends Data.Class<{\n  readonly options: ResolvedEnsAtomOptions<Failure>;\n  readonly parameters: Parameters;\n  readonly sdk: Ensforge;\n}> {}\n\nexport type EnsAtom<Success, Failure> = Atom.Atom<AsyncResult.AsyncResult<Success, Failure>>;\n\nexport interface EnsAtomFactory<Parameters, Success, Failure> {\n  (\n    sdk: Ensforge,\n    parameters: Parameters,\n    options?: EnsAtomOptions<Failure>,\n  ): EnsAtom<Success, Failure>;\n}\n\nexport const configureAtom = <Success, Failure>(\n  source: EnsAtom<Success, Failure>,\n  options: ResolvedEnsAtomOptions<Failure>,\n  reactivityKeys: Readonly<Record<string, ReadonlyArray<unknown>>>,\n): EnsAtom<Success, Failure> => {\n  let atom = source.pipe(Atom.withReactivity(reactivityKeys), Atom.setIdleTTL(options.idleTTL));\n\n  if (options.swr !== false) {\n    atom = atom.pipe(\n      Atom.swr({\n        ...options.swr,\n        focusSignal: Atom.windowFocusSignal,\n      }),\n    );\n  }\n\n  if (options.refreshInterval !== false) {\n    atom = atom.pipe(Atom.withRefresh(options.refreshInterval));\n  }\n\n  return atom;\n};\n\nexport const makeQueryAtom = <Parameters, Success, Failure>(\n  group: string,\n  getAction: (sdk: Ensforge) => BoundEffectAction<Parameters, Success, Failure>,\n): EnsAtomFactory<Parameters, Success, Failure> => {\n  const family = Atom.family((input: QueryAtomInput<Parameters, Failure>) => {\n    const actionEffect = Effect.suspend(() => getAction(input.sdk).effect(input.parameters));\n    const effect =\n      input.options.retry === false\n        ? actionEffect\n        : actionEffect.pipe(Effect.retry(input.options.retry));\n    return configureAtom(\n      atomRuntime.atom(effect),\n      input.options,\n      makeReactivityKeys(input.sdk, group, input.parameters),\n    );\n  });\n\n  return (sdk, parameters, options) =>\n    family(\n      new QueryAtomInput({\n        options: resolveEnsAtomOptions(undefined, options),\n        parameters,\n        sdk,\n      }),\n    );\n};\n"],"mappings":";;;;;;;AAcA,IAAM,iBAAN,cAAkD,KAAK,MAIpD,CAAC;AAYJ,MAAa,iBACX,QACA,SACA,mBAC8B;CAC9B,IAAI,OAAO,OAAO,KAAK,KAAK,eAAe,cAAc,GAAG,KAAK,WAAW,QAAQ,OAAO,CAAC;CAE5F,IAAI,QAAQ,QAAQ,OAClB,OAAO,KAAK,KACV,KAAK,IAAI;EACP,GAAG,QAAQ;EACX,aAAa,KAAK;CACpB,CAAC,CACH;CAGF,IAAI,QAAQ,oBAAoB,OAC9B,OAAO,KAAK,KAAK,KAAK,YAAY,QAAQ,eAAe,CAAC;CAG5D,OAAO;AACT;AAEA,MAAa,iBACX,OACA,cACiD;CACjD,MAAM,SAAS,KAAK,QAAQ,UAA+C;EACzE,MAAM,eAAe,OAAO,cAAc,UAAU,MAAM,GAAG,CAAC,CAAC,OAAO,MAAM,UAAU,CAAC;EACvF,MAAM,SACJ,MAAM,QAAQ,UAAU,QACpB,eACA,aAAa,KAAK,OAAO,MAAM,MAAM,QAAQ,KAAK,CAAC;EACzD,OAAO,cACL,YAAY,KAAK,MAAM,GACvB,MAAM,SACN,mBAAmB,MAAM,KAAK,OAAO,MAAM,UAAU,CACvD;CACF,CAAC;CAED,QAAQ,KAAK,YAAY,YACvB,OACE,IAAI,eAAe;EACjB,SAAS,sBAAsB,QAAW,OAAO;EACjD;EACA;CACF,CAAC,CACH;AACJ"}

package/dist/atoms/records.d.ts

@@ -1,7 +1,7 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 import { EnsMutationAtomFactory } from "./mutation.js";
 //#region src/atoms/records.d.ts
-declare const getAbiAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAbiParameters, {
+declare const getAbiAtom: EnsAtomFactory<import("@ensforge/core").GetAbiParameters, {
   readonly contentType: "json" | "zlib-json" | "cbor";
   readonly value: import("viem").Abi;
   readonly raw: `0x${string}` & import("effect/Brand").Brand<"AbiRecordData">;
@@ -14,7 +14,7 @@ declare const getAbiAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAbiPar
   readonly value: null;
   readonly raw: null;
 }, import("@ensforge/core").GetAbiError>;
-declare const getAddressAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAddressParameters, {
+declare const getAddressAtom: EnsAtomFactory<import("@ensforge/core").GetAddressParameters, {
   readonly coinType: bigint & import("effect/Brand").Brand<"CoinType">;
   readonly address: string;
   readonly raw: `0x${string}` & import("effect/Brand").Brand<"AddressRecordData">;
@@ -23,7 +23,7 @@ declare const getAddressAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAd
   readonly address: null;
   readonly raw: null;
 }, import("@ensforge/core").GetAddressError>;
-declare const getAddressesAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAddressesParameters, readonly ({
+declare const getAddressesAtom: EnsAtomFactory<import("@ensforge/core").GetAddressesParameters, readonly ({
   readonly coinType: bigint & import("effect/Brand").Brand<"CoinType">;
   readonly address: string;
   readonly raw: `0x${string}` & import("effect/Brand").Brand<"AddressRecordData">;
@@ -32,7 +32,7 @@ declare const getAddressesAtom: EnsQueryAtomFactory<import("@ensforge/core").Get
   readonly address: null;
   readonly raw: null;
 })[], import("@ensforge/core").GetAddressError>;
-declare const getAvatarAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAvatarParameters, {
+declare const getAvatarAtom: EnsAtomFactory<import("@ensforge/core").GetAvatarParameters, {
   readonly status: "resolved";
   readonly record: string;
   readonly uri: string;
@@ -41,7 +41,7 @@ declare const getAvatarAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAva
   readonly record: string;
   readonly chainId: number;
 } | null, import("@ensforge/core").GetAvatarError>;
-declare const getContentHashAtom: EnsQueryAtomFactory<import("@ensforge/core").GetContentHashParameters, {
+declare const getContentHashAtom: EnsAtomFactory<import("@ensforge/core").GetContentHashParameters, {
   readonly protocol: "ipfs" | "ipns" | "swarm" | "onion" | "onion3" | "skynet" | "arweave" | "adnl";
   readonly value: string;
   readonly raw: `0x${string}` & import("effect/Brand").Brand<"ContentHash">;
@@ -50,26 +50,26 @@ declare const getContentHashAtom: EnsQueryAtomFactory<import("@ensforge/core").G
   readonly value: null;
   readonly raw: null;
 }, import("@ensforge/core").GetContentHashError>;
-declare const getDataAtom: EnsQueryAtomFactory<import("@ensforge/core").GetDataParameters, {
+declare const getDataAtom: EnsAtomFactory<import("@ensforge/core").GetDataParameters, {
   readonly key: string;
   readonly value: `0x${string}` | null;
 }, import("@ensforge/core").GetDataError>;
-declare const getInterfaceAtom: EnsQueryAtomFactory<import("@ensforge/core").GetInterfaceParameters, {
+declare const getInterfaceAtom: EnsAtomFactory<import("@ensforge/core").GetInterfaceParameters, {
   readonly interfaceId: `0x${string}` & import("effect/Brand").Brand<"InterfaceId">;
   readonly implementer: `0x${string}` | null;
 }, import("@ensforge/core").GetInterfaceError>;
-declare const getNameAtom: EnsQueryAtomFactory<import("@ensforge/core").GetNameParameters, {
+declare const getNameAtom: EnsAtomFactory<import("@ensforge/core").GetNameParameters, {
   readonly name: string | null;
 }, import("@ensforge/core").GetNameError>;
-declare const getPubkeyAtom: EnsQueryAtomFactory<import("@ensforge/core").GetPubkeyParameters, {
+declare const getPubkeyAtom: EnsAtomFactory<import("@ensforge/core").GetPubkeyParameters, {
   readonly x: `0x${string}`;
   readonly y: `0x${string}`;
 } | null, import("@ensforge/core").GetPubkeyError>;
-declare const getTextAtom: EnsQueryAtomFactory<import("@ensforge/core").GetTextParameters, {
+declare const getTextAtom: EnsAtomFactory<import("@ensforge/core").GetTextParameters, {
   readonly key: string;
   readonly value: string | null;
 }, import("@ensforge/core").GetTextError>;
-declare const getTextsAtom: EnsQueryAtomFactory<import("@ensforge/core").GetTextsParameters, readonly {
+declare const getTextsAtom: EnsAtomFactory<import("@ensforge/core").GetTextsParameters, readonly {
   readonly key: string;
   readonly value: string | null;
 }[], import("@ensforge/core").GetTextError>;

package/dist/atoms/records.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"records.d.ts","names":[],"sources":["../../src/atoms/records.ts"],"mappings":";;;cAGa,YAAA,6CAAU;;;;;;;;;;;;4BAAwD;cAClE,gBAAA,6CAAc;;;;;;;;4BAA4D;cAC1E,kBAAA,6CAAgB;;;;;;;;+BAA8D;cAC9E,eAAA,6CAAa;;;;;;;;mCAA2D;cACxE,oBAAA,6CAAkB;;;;;;;;4BAAgE;cAClF,aAAA,6CAAW;;;4BAAyD;cACpE,kBAAA,6CAAgB;;;4BAA8D;cAC9E,aAAA,6CAAW;;4BAAyD;cACpE,eAAA,6CAAa;;;mCAA2D;cACxE,aAAA,6CAAW;;;4BAAyD;cACpE,cAAA,6CAAY;;;8BAA0D;cAEtE,+BAAA,gDAA6B,gDAAA,8CAAA;cAI7B,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,0BAAA,gDAAwB,2CAAA,8CAAA;cACxB,8BAAA,gDAA4B,+CAAA,8CAAA;cAI5B,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,4BAAA,gDAA0B,6CAAA,8CAAA;cAI1B,6BAAA,gDAA2B,8CAAA,8CAAA;cAI3B,kCAAA,gDAAgC,mDAAA,8CAAA;cAIhC,2BAAA,gDAAyB,4CAAA,8CAAA;cACzB,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,2BAAA,gDAAyB,4CAAA,8CAAA;cACzB,6BAAA,gDAA2B,8CAAA,8CAAA;cAI3B,8BAAA,gDAA4B,+CAAA,2CAAA;cAI5B,2BAAA,gDAAyB,4CAAA,8CAAA;cACzB,4BAAA,gDAA0B,6CAAA,8CAAA"}
+{"version":3,"file":"records.d.ts","names":[],"sources":["../../src/atoms/records.ts"],"mappings":";;;cAGa,YAAA,wCAAU;;;;;;;;;;;;4BAAwD;cAClE,gBAAA,wCAAc;;;;;;;;4BAA4D;cAC1E,kBAAA,wCAAgB;;;;;;;;+BAA8D;cAC9E,eAAA,wCAAa;;;;;;;;mCAA2D;cACxE,oBAAA,wCAAkB;;;;;;;;4BAAgE;cAClF,aAAA,wCAAW;;;4BAAyD;cACpE,kBAAA,wCAAgB;;;4BAA8D;cAC9E,aAAA,wCAAW;;4BAAyD;cACpE,eAAA,wCAAa;;;mCAA2D;cACxE,aAAA,wCAAW;;;4BAAyD;cACpE,cAAA,wCAAY;;;8BAA0D;cAEtE,+BAAA,gDAA6B,gDAAA,8CAAA;cAI7B,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,0BAAA,gDAAwB,2CAAA,8CAAA;cACxB,8BAAA,gDAA4B,+CAAA,8CAAA;cAI5B,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,4BAAA,gDAA0B,6CAAA,8CAAA;cAI1B,6BAAA,gDAA2B,8CAAA,8CAAA;cAI3B,kCAAA,gDAAgC,mDAAA,8CAAA;cAIhC,2BAAA,gDAAyB,4CAAA,8CAAA;cACzB,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,2BAAA,gDAAyB,4CAAA,8CAAA;cACzB,6BAAA,gDAA2B,8CAAA,8CAAA;cAI3B,8BAAA,gDAA4B,+CAAA,2CAAA;cAI5B,2BAAA,gDAAyB,4CAAA,8CAAA;cACzB,4BAAA,gDAA0B,6CAAA,8CAAA"}

package/dist/atoms/registration.d.ts

@@ -1,7 +1,7 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 import { EnsMutationAtomFactory } from "./mutation.js";
 //#region src/atoms/registration.d.ts
-declare const getCommitmentStatusAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCommitmentStatusParameters, {
+declare const getCommitmentStatusAtom: EnsAtomFactory<import("@ensforge/core").GetCommitmentStatusParameters, {
   readonly status: "not-found";
   readonly protocol: "v1" | "v2";
 } | {
@@ -25,7 +25,7 @@ declare const getCommitmentStatusAtom: EnsQueryAtomFactory<import("@ensforge/cor
   readonly readyAt: bigint;
   readonly expiresAt: bigint;
 }, import("@ensforge/core").GetCommitmentStatusError>;
-declare const getRegistrationParametersAtom: EnsQueryAtomFactory<import("@ensforge/core").BlockParameters, {
+declare const getRegistrationParametersAtom: EnsAtomFactory<import("@ensforge/core").BlockParameters, {
   readonly protocol: "v1";
   readonly registrar: `0x${string}`;
   readonly priceOracle: `0x${string}`;
@@ -49,7 +49,7 @@ declare const getRegistrationParametersAtom: EnsQueryAtomFactory<import("@ensfor
     readonly enumerable: false;
   };
 }, import("@ensforge/core").GetCommitmentStatusError>;
-declare const getRegistrationPlanAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistrationPlanParameters, {
+declare const getRegistrationPlanAtom: EnsAtomFactory<import("@ensforge/core").GetRegistrationPlanParameters, {
   readonly status: "unavailable";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
 } | {
@@ -151,7 +151,7 @@ declare const getRegistrationPlanAtom: EnsQueryAtomFactory<import("@ensforge/cor
     readonly expiresAt: bigint;
   };
 }, import("@ensforge/core").GetCommitmentStatusError>;
-declare const getRegistrationPriceAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistrationPriceParameters, {
+declare const getRegistrationPriceAtom: EnsAtomFactory<import("@ensforge/core").GetRegistrationPriceParameters, {
   readonly status: "available";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
@@ -185,7 +185,7 @@ declare const getRegistrationPriceAtom: EnsQueryAtomFactory<import("@ensforge/co
   readonly protocol: "v1" | "v2";
   readonly paymentToken: `0x${string}`;
 }, import("@ensforge/core").GetCommitmentStatusError>;
-declare const getRenewalPriceAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistrationPriceParameters, {
+declare const getRenewalPriceAtom: EnsAtomFactory<import("@ensforge/core").GetRegistrationPriceParameters, {
   readonly status: "payment-token-required";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
@@ -218,7 +218,7 @@ declare const getRenewalPriceAtom: EnsQueryAtomFactory<import("@ensforge/core").
   readonly protocol: "v1" | "v2";
   readonly reason: "NAME_NOT_RENEWABLE";
 }, import("@ensforge/core").GetCommitmentStatusError>;
-declare const isPaymentTokenSupportedAtom: EnsQueryAtomFactory<import("@ensforge/core").IsPaymentTokenSupportedParameters, {
+declare const isPaymentTokenSupportedAtom: EnsAtomFactory<import("@ensforge/core").IsPaymentTokenSupportedParameters, {
   readonly protocol: "v1";
   readonly supported: false;
   readonly reason: "NATIVE_PAYMENT_ONLY";
@@ -234,7 +234,7 @@ declare const isPaymentTokenSupportedAtom: EnsQueryAtomFactory<import("@ensforge
   readonly symbol: string;
   readonly decimals: number;
 }, import("@ensforge/core").GetCommitmentStatusError>;
-declare const makeRegistrationCommitmentAtom: EnsQueryAtomFactory<import("@ensforge/core").MakeRegistrationCommitmentParameters, {
+declare const makeRegistrationCommitmentAtom: EnsAtomFactory<import("@ensforge/core").MakeRegistrationCommitmentParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly protocol: "v1" | "v2";
   readonly registrar: `0x${string}`;

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

@@ -1 +1 @@
-{"version":3,"file":"registration.d.ts","names":[],"sources":["../../src/atoms/registration.ts"],"mappings":";;;cAGa,yBAAA,6CAAuB;;;;;;;;;;;;;;;;;;;;;;;4BAGnC;cACY,+BAAA,6CAA6B;;;;;;;;;;;;;;;;;;;;;;;4BAGzC;cACY,yBAAA,6CAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGnC;cACY,0BAAA,6CAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGpC;cACY,qBAAA,6CAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAG/B;cACY,6BAAA,6CAA2B;;;;;;;;;;;;;;;4BAGvC;cACY,gCAAA,6CAA8B;;;;;4BAG1C;cAEY,uCAAA,gDAAqC,wDAAA,8CAAA;cAIrC,yCAAA,gDAAuC,0DAAA,8CAAA;cAIvC,8BAAA,gDAA4B,+CAAA,8CAAA;cAI5B,wCAAA,gDAAsC,yDAAA,8CAAA;cAItC,gCAAA,gDAA8B,iDAAA,6CAAA;cAI9B,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,6BAAA,gDAA2B,8CAAA,0CAAA;cAI3B,8BAAA,gDAA4B,+CAAA,2CAAA"}
+{"version":3,"file":"registration.d.ts","names":[],"sources":["../../src/atoms/registration.ts"],"mappings":";;;cAGa,yBAAA,wCAAuB;;;;;;;;;;;;;;;;;;;;;;;4BAGnC;cACY,+BAAA,wCAA6B;;;;;;;;;;;;;;;;;;;;;;;4BAGzC;cACY,yBAAA,wCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGnC;cACY,0BAAA,wCAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGpC;cACY,qBAAA,wCAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAG/B;cACY,6BAAA,wCAA2B;;;;;;;;;;;;;;;4BAGvC;cACY,gCAAA,wCAA8B;;;;;4BAG1C;cAEY,uCAAA,gDAAqC,wDAAA,8CAAA;cAIrC,yCAAA,gDAAuC,0DAAA,8CAAA;cAIvC,8BAAA,gDAA4B,+CAAA,8CAAA;cAI5B,wCAAA,gDAAsC,yDAAA,8CAAA;cAItC,gCAAA,gDAA8B,iDAAA,6CAAA;cAI9B,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,6BAAA,gDAA2B,8CAAA,0CAAA;cAI3B,8BAAA,gDAA4B,+CAAA,2CAAA"}

package/dist/atoms/resolution.d.ts

@@ -1,7 +1,7 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 import { EnsMutationAtomFactory } from "./mutation.js";
 //#region src/atoms/resolution.d.ts
-declare const getAliasAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAliasParameters, {
+declare const getAliasAtom: EnsAtomFactory<import("@ensforge/core").GetAliasParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -13,8 +13,8 @@ declare const getAliasAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAlia
   readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
   readonly raw: `0x${string}`;
 }, import("@ensforge/core").GetAliasError>;
-declare const getResolverAtom: EnsQueryAtomFactory<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, import("@ensforge/core").GetResolverError>;
-declare const getResolverVersionAtom: EnsQueryAtomFactory<import("@ensforge/core").GetResolverVersionParameters, {
+declare const getResolverAtom: EnsAtomFactory<import("@ensforge/core").GetResolverParameters, import("@ensforge/core").GetResolverResult, import("@ensforge/core").GetResolverError>;
+declare const getResolverVersionAtom: EnsAtomFactory<import("@ensforge/core").GetResolverVersionParameters, {
   readonly supported: false;
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -25,13 +25,13 @@ declare const getResolverVersionAtom: EnsQueryAtomFactory<import("@ensforge/core
   readonly resolver: `0x${string}`;
   readonly version: bigint;
 }, import("@ensforge/core").GetResolverError>;
-declare const predictResolverAddressAtom: EnsQueryAtomFactory<import("@ensforge/core").CreateResolverParameters, `0x${string}`, import("@ensforge/core").WriteError>;
-declare const resolveAtom: EnsQueryAtomFactory<import("@ensforge/core").ResolveParameters, {
+declare const predictResolverAddressAtom: EnsAtomFactory<import("@ensforge/core").CreateResolverParameters, `0x${string}`, import("@ensforge/core").WriteError>;
+declare const resolveAtom: EnsAtomFactory<import("@ensforge/core").ResolveParameters, {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
 } | null, import("@ensforge/core").ResolveError>;
-declare const resolveBatchAtom: EnsQueryAtomFactory<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, import("@ensforge/core").ResolveError>;
-declare const resolveWithResolverAtom: EnsQueryAtomFactory<import("@ensforge/core").ResolveWithResolverParameters, {
+declare const resolveBatchAtom: EnsAtomFactory<import("@ensforge/core").ResolveBatchParameters, import("@ensforge/core").ResolveBatchResult, import("@ensforge/core").ResolveError>;
+declare const resolveWithResolverAtom: EnsAtomFactory<import("@ensforge/core").ResolveWithResolverParameters, {
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
 }, import("@ensforge/core").ResolveError>;

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

@@ -1 +1 @@
-{"version":3,"file":"resolution.d.ts","names":[],"sources":["../../src/atoms/resolution.ts"],"mappings":";;;cAGa,cAAA,6CAAY;;;;;;;;;;;4BAAgE;cAC5E,iBAAA,6CAAe,gDAAA,4CAAA;cACf,wBAAA,6CAAsB;;;;;;;;;;4BAGlC;cACY,4BAAA,6CAA0B,kEAAA;cAI1B,aAAA,6CAAW;;;mCAA+D;cAC1E,kBAAA,6CAAgB,iDAAA,6CAAA;cAChB,yBAAA,6CAAuB;;;4BAGnC;cAEY,kCAAA,gDAAgC,mDAAA,+CAAA;cAIhC,uCAAA,gDAAqC,wDAAA,oDAAA;cAIrC,+BAAA,gDAA6B,gDAAA,8CAAA;cAI7B,yCAAA,gDAAuC,0DAAA,wDAAA;cAIvC,mCAAA,gDAAiC,oDAAA,gDAAA"}
+{"version":3,"file":"resolution.d.ts","names":[],"sources":["../../src/atoms/resolution.ts"],"mappings":";;;cAGa,cAAA,wCAAY;;;;;;;;;;;4BAAgE;cAC5E,iBAAA,wCAAe,gDAAA,4CAAA;cACf,wBAAA,wCAAsB;;;;;;;;;;4BAGlC;cACY,4BAAA,wCAA0B,kEAAA;cAI1B,aAAA,wCAAW;;;mCAA+D;cAC1E,kBAAA,wCAAgB,iDAAA,6CAAA;cAChB,yBAAA,wCAAuB;;;4BAGnC;cAEY,kCAAA,gDAAgC,mDAAA,+CAAA;cAIhC,uCAAA,gDAAqC,wDAAA,oDAAA;cAIrC,+BAAA,gDAA6B,gDAAA,8CAAA;cAI7B,yCAAA,gDAAuC,0DAAA,wDAAA;cAIvC,mCAAA,gDAAiC,oDAAA,gDAAA"}

package/dist/atoms/reverse.d.ts

@@ -1,7 +1,7 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 import { EnsMutationAtomFactory } from "./mutation.js";
 //#region src/atoms/reverse.d.ts
-declare const getPrimaryNameAtom: EnsQueryAtomFactory<import("@ensforge/core").GetPrimaryNameParameters, {
+declare const getPrimaryNameAtom: EnsAtomFactory<import("@ensforge/core").GetPrimaryNameParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly match: true;
 } | null, import("@ensforge/core").GetPrimaryNameError>;

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

@@ -1 +1 @@
-{"version":3,"file":"reverse.d.ts","names":[],"sources":["../../src/atoms/reverse.ts"],"mappings":";;;cAGa,oBAAA,6CAAkB;;;mCAAgE;cAElF,oCAAA,gDAAkC,qDAAA,8CAAA;cAIlC,0CAAA,gDAAwC,2DAAA,8CAAA;cAIxC,kCAAA,gDAAgC,mDAAA,8CAAA;cAIhC,4CAAA,gDAA0C,6DAAA,8CAAA"}
+{"version":3,"file":"reverse.d.ts","names":[],"sources":["../../src/atoms/reverse.ts"],"mappings":";;;cAGa,oBAAA,wCAAkB;;;mCAAgE;cAElF,oCAAA,gDAAkC,qDAAA,8CAAA;cAIlC,0CAAA,gDAAwC,2DAAA,8CAAA;cAIxC,kCAAA,gDAAgC,mDAAA,8CAAA;cAIhC,4CAAA,gDAA0C,6DAAA,8CAAA"}

package/dist/atoms/stream.d.ts

@@ -1,11 +1,11 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 import { Ensforge } from "@ensforge/sdk";
 import { Cause, Stream } from "effect";
 //#region src/atoms/stream.d.ts
 interface BoundStreamAction<Parameters, Success, Failure> {
   readonly stream: (parameters: Parameters) => Stream.Stream<Success, Failure>;
 }
-declare const makeStreamAtom: <Parameters, Success, Failure>(group: string, getAction: (sdk: Ensforge) => BoundStreamAction<Parameters, Success, Failure>) => EnsQueryAtomFactory<Parameters, Success, Failure | Cause.NoSuchElementError>;
+declare const makeStreamAtom: <Parameters, Success, Failure>(group: string, getAction: (sdk: Ensforge) => BoundStreamAction<Parameters, Success, Failure>) => EnsAtomFactory<Parameters, Success, Failure | Cause.NoSuchElementError>;
 //#endregion
 export { makeStreamAtom };
 //# sourceMappingURL=stream.d.ts.map

package/dist/atoms/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","names":[],"sources":["../../src/atoms/stream.ts"],"mappings":";;;;UASU,kBAAkB,YAAY,SAAS;WACtC,SAAS,YAAY,eAAe,OAAO,OAAO,SAAS;;cASzD,iBAAkB,YAAY,SAAS,SAClD,eACA,YAAY,KAAK,aAAa,kBAAkB,YAAY,SAAS,aACpE,oBAAoB,YAAY,SAAS,UAAU,MAAM"}
+{"version":3,"file":"stream.d.ts","names":[],"sources":["../../src/atoms/stream.ts"],"mappings":";;;;UAUU,kBAAkB,YAAY,SAAS;WACtC,SAAS,YAAY,eAAe,OAAO,OAAO,SAAS;;cASzD,iBAAkB,YAAY,SAAS,SAClD,eACA,YAAY,KAAK,aAAa,kBAAkB,YAAY,SAAS,aACpE,eAAe,YAAY,SAAS,UAAU,MAAM"}

package/dist/atoms/stream.js

@@ -1,6 +1,8 @@
 import { atomRuntime } from "../internal/runtime.js";
 import { makeReactivityKeys } from "../query/keys.js";
-import { Data, Schedule, Stream } from "effect";
+import { resolveEnsAtomOptions } from "../query/options.js";
+import { configureAtom } from "./query.js";
+import { Data, Stream } from "effect";
 import { Atom } from "effect/unstable/reactivity";
 
 //#region src/atoms/stream.ts
@@ -8,11 +10,11 @@ var StreamAtomInput = class extends Data.Class {};
 const makeStreamAtom = (group, getAction) => {
 	const family = Atom.family((input) => {
 		const actionStream = Stream.suspend(() => getAction(input.sdk).stream(input.parameters));
-		const stream = input.options.retry === false ? actionStream : actionStream.pipe(Stream.retry(Schedule.recurs(input.options.retry)));
-		return atomRuntime.atom(stream).pipe(Atom.withReactivity(makeReactivityKeys(input.sdk, group, input.parameters)), Atom.setIdleTTL(input.options.gcTime));
+		const stream = input.options.retry === false ? actionStream : actionStream.pipe(Stream.retry(input.options.retry));
+		return configureAtom(atomRuntime.atom(stream), input.options, makeReactivityKeys(input.sdk, group, input.parameters));
 	});
 	return (sdk, parameters, options) => family(new StreamAtomInput({
-		options,
+		options: resolveEnsAtomOptions(void 0, options),
 		parameters,
 		sdk
 	}));

package/dist/atoms/stream.js.map

@@ -1 +1 @@
-{"version":3,"file":"stream.js","names":[],"sources":["../../src/atoms/stream.ts"],"sourcesContent":["import { Data, Schedule, Stream, type Cause } from \"effect\";\nimport { Atom } from \"effect/unstable/reactivity\";\n\nimport type { Ensforge } from \"@ensforge/sdk\";\n\nimport { atomRuntime } from \"../internal/runtime.js\";\nimport { makeReactivityKeys } from \"../query/keys.js\";\nimport type { EnsQueryAtom, EnsQueryAtomFactory, QueryAtomOptions } from \"./query.js\";\n\ninterface BoundStreamAction<Parameters, Success, Failure> {\n  readonly stream: (parameters: Parameters) => Stream.Stream<Success, Failure>;\n}\n\nclass StreamAtomInput<Parameters> extends Data.Class<{\n  readonly options: QueryAtomOptions;\n  readonly parameters: Parameters;\n  readonly sdk: Ensforge;\n}> {}\n\nexport const makeStreamAtom = <Parameters, Success, Failure>(\n  group: string,\n  getAction: (sdk: Ensforge) => BoundStreamAction<Parameters, Success, Failure>,\n): EnsQueryAtomFactory<Parameters, Success, Failure | Cause.NoSuchElementError> => {\n  const family = Atom.family((input: StreamAtomInput<Parameters>) => {\n    const actionStream = Stream.suspend(() => getAction(input.sdk).stream(input.parameters));\n    const stream =\n      input.options.retry === false\n        ? actionStream\n        : actionStream.pipe(Stream.retry(Schedule.recurs(input.options.retry)));\n    return atomRuntime\n      .atom(stream)\n      .pipe(\n        Atom.withReactivity(makeReactivityKeys(input.sdk, group, input.parameters)),\n        Atom.setIdleTTL(input.options.gcTime),\n      );\n  });\n\n  return (sdk, parameters, options): EnsQueryAtom<Success, Failure | Cause.NoSuchElementError> =>\n    family(new StreamAtomInput({ options, parameters, sdk }));\n};\n"],"mappings":";;;;;;AAaA,IAAM,kBAAN,cAA0C,KAAK,MAI5C,CAAC;AAEJ,MAAa,kBACX,OACA,cACiF;CACjF,MAAM,SAAS,KAAK,QAAQ,UAAuC;EACjE,MAAM,eAAe,OAAO,cAAc,UAAU,MAAM,GAAG,CAAC,CAAC,OAAO,MAAM,UAAU,CAAC;EACvF,MAAM,SACJ,MAAM,QAAQ,UAAU,QACpB,eACA,aAAa,KAAK,OAAO,MAAM,SAAS,OAAO,MAAM,QAAQ,KAAK,CAAC,CAAC;EAC1E,OAAO,YACJ,KAAK,MAAM,CAAC,CACZ,KACC,KAAK,eAAe,mBAAmB,MAAM,KAAK,OAAO,MAAM,UAAU,CAAC,GAC1E,KAAK,WAAW,MAAM,QAAQ,MAAM,CACtC;CACJ,CAAC;CAED,QAAQ,KAAK,YAAY,YACvB,OAAO,IAAI,gBAAgB;EAAE;EAAS;EAAY;CAAI,CAAC,CAAC;AAC5D"}
+{"version":3,"file":"stream.js","names":[],"sources":["../../src/atoms/stream.ts"],"sourcesContent":["import { Data, Stream, type Cause } from \"effect\";\nimport { Atom } from \"effect/unstable/reactivity\";\n\nimport type { Ensforge } from \"@ensforge/sdk\";\n\nimport { atomRuntime } from \"../internal/runtime.js\";\nimport { makeReactivityKeys } from \"../query/keys.js\";\nimport { resolveEnsAtomOptions, type ResolvedEnsAtomOptions } from \"../query/options.js\";\nimport { configureAtom, type EnsAtom, type EnsAtomFactory } from \"./query.js\";\n\ninterface BoundStreamAction<Parameters, Success, Failure> {\n  readonly stream: (parameters: Parameters) => Stream.Stream<Success, Failure>;\n}\n\nclass StreamAtomInput<Parameters, Failure> extends Data.Class<{\n  readonly options: ResolvedEnsAtomOptions<Failure>;\n  readonly parameters: Parameters;\n  readonly sdk: Ensforge;\n}> {}\n\nexport const makeStreamAtom = <Parameters, Success, Failure>(\n  group: string,\n  getAction: (sdk: Ensforge) => BoundStreamAction<Parameters, Success, Failure>,\n): EnsAtomFactory<Parameters, Success, Failure | Cause.NoSuchElementError> => {\n  const family = Atom.family(\n    (input: StreamAtomInput<Parameters, Failure | Cause.NoSuchElementError>) => {\n      const actionStream = Stream.suspend(() => getAction(input.sdk).stream(input.parameters));\n      const stream =\n        input.options.retry === false\n          ? actionStream\n          : actionStream.pipe(Stream.retry(input.options.retry));\n      return configureAtom(\n        atomRuntime.atom(stream),\n        input.options,\n        makeReactivityKeys(input.sdk, group, input.parameters),\n      );\n    },\n  );\n\n  return (sdk, parameters, options): EnsAtom<Success, Failure | Cause.NoSuchElementError> =>\n    family(\n      new StreamAtomInput({\n        options: resolveEnsAtomOptions(undefined, options),\n        parameters,\n        sdk,\n      }),\n    );\n};\n"],"mappings":";;;;;;;;AAcA,IAAM,kBAAN,cAAmD,KAAK,MAIrD,CAAC;AAEJ,MAAa,kBACX,OACA,cAC4E;CAC5E,MAAM,SAAS,KAAK,QACjB,UAA2E;EAC1E,MAAM,eAAe,OAAO,cAAc,UAAU,MAAM,GAAG,CAAC,CAAC,OAAO,MAAM,UAAU,CAAC;EACvF,MAAM,SACJ,MAAM,QAAQ,UAAU,QACpB,eACA,aAAa,KAAK,OAAO,MAAM,MAAM,QAAQ,KAAK,CAAC;EACzD,OAAO,cACL,YAAY,KAAK,MAAM,GACvB,MAAM,SACN,mBAAmB,MAAM,KAAK,OAAO,MAAM,UAAU,CACvD;CACF,CACF;CAEA,QAAQ,KAAK,YAAY,YACvB,OACE,IAAI,gBAAgB;EAClB,SAAS,sBAAsB,QAAW,OAAO;EACjD;EACA;CACF,CAAC,CACH;AACJ"}

package/dist/atoms/wrapping.d.ts

@@ -1,8 +1,8 @@
-import { EnsQueryAtomFactory } from "./query.js";
+import { EnsAtomFactory } from "./query.js";
 import { EnsMutationAtomFactory } from "./mutation.js";
 //#region src/atoms/wrapping.d.ts
-declare const getFusesAtom: EnsQueryAtomFactory<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetFusesResult, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getWrapperExpiryAtom: EnsQueryAtomFactory<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetWrapperExpiryResult, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getFusesAtom: EnsAtomFactory<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetFusesResult, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getWrapperExpiryAtom: EnsAtomFactory<import("@ensforge/core").WrapperReadParameters, import("@ensforge/core").GetWrapperExpiryResult, import("@ensforge/core").GetCanonicalResourceError>;
 declare const createExtendSubnameExpiryMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ExtendSubnameExpiryParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createSetChildFusesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetChildFusesParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createSetFusesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetFusesParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;

package/dist/atoms/wrapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrapping.d.ts","names":[],"sources":["../../src/atoms/wrapping.ts"],"mappings":";;;cAGa,cAAA,6CAAY,gDAAA,yCAAA;cACZ,sBAAA,6CAAoB,gDAAA,iDAAA;cAKpB,uCAAA,gDAAqC,wDAAA,8CAAA;cAIrC,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,4BAAA,gDAA0B,6CAAA,8CAAA;cAI1B,8BAAA,gDAA4B,+CAAA,8CAAA;cAI5B,4BAAA,gDAA0B,6CAAA,yCAAA"}
+{"version":3,"file":"wrapping.d.ts","names":[],"sources":["../../src/atoms/wrapping.ts"],"mappings":";;;cAGa,cAAA,wCAAY,gDAAA,yCAAA;cACZ,sBAAA,wCAAoB,gDAAA,iDAAA;cAKpB,uCAAA,gDAAqC,wDAAA,8CAAA;cAIrC,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,4BAAA,gDAA0B,6CAAA,8CAAA;cAI1B,8BAAA,gDAA4B,+CAAA,8CAAA;cAI5B,4BAAA,gDAA0B,6CAAA,yCAAA"}

package/dist/atoms.d.ts

@@ -1,4 +1,5 @@
-import { EnsQueryAtom, EnsQueryAtomFactory, QueryAtomOptions, defaultQueryAtomOptions, makeQueryAtom } from "./atoms/query.js";
+import { EnsAtomOptions, ResolvedEnsAtomOptions, defaultEnsAtomOptions } from "./query/options.js";
+import { EnsAtom, EnsAtomFactory, makeQueryAtom } from "./atoms/query.js";
 import { EnsMutationAtom, EnsMutationAtomFactory, makeMutationAtom } from "./atoms/mutation.js";
 import { createExecuteWritePlanMutationAtom, createResumeCallsMutationAtom, createSendCallsMutationAtom, estimateCallsAtom, getCallsStatusAtom, getWalletCapabilitiesAtom, prepareCallsAtom, simulateCallsAtom } from "./atoms/batch.js";
 import { getNameCapabilitiesAtom, getOperatorApprovalAtom, getRecordPermissionsAtom, getRegistryCapabilitiesAtom, getRegistryRolesAtom, getRequiredAuthorizationAtom, getResolverCapabilitiesAtom, getResolverDelegateApprovalAtom, getResolverRolesAtom, getTokenApprovalAtom, getWrapperPermissionsAtom, getWriteTargetAtom, hasRegistryRolesAtom, hasResolverRolesAtom } from "./atoms/capabilities.js";
@@ -16,4 +17,4 @@ import { createCreateSubnameMutationAtom, createDeleteSubnameMutationAtom, creat
 import { createExtendSubnameExpiryMutationAtom, createSetChildFusesMutationAtom, createSetFusesMutationAtom, createUnwrapNameMutationAtom, createWrapNameMutationAtom, getFusesAtom, getWrapperExpiryAtom } from "./atoms/wrapping.js";
 import { ReadBatchAtomParameters, getRecordsAtom, readBatchAtom, readBatchSettledAtom } from "./atoms/generic.js";
 import { makeStreamAtom } from "./atoms/stream.js";
-export { type EnsMutationAtom, type EnsMutationAtomFactory, type EnsQueryAtom, type EnsQueryAtomFactory, type QueryAtomOptions, type ReadBatchAtomParameters, createApproveMigrationMutationAtom, createApproveNameMutationAtom, createApprovePaymentTokenMutationAtom, createApproveRenewalPaymentMutationAtom, createClaimDnsNameMutationAtom, createClearAvatarMutationAtom, createClearNameApprovalMutationAtom, createClearPrimaryNameMutationAtom, createClearRecordsMutationAtom, createCommitNameMutationAtom, createCompleteRegistrationMutationAtom, createCreateResolverMutationAtom, createCreateSubnameMutationAtom, createDeleteSubnameMutationAtom, createExecuteWritePlanMutationAtom, createExtendSubnameExpiryMutationAtom, createGetOrCreateResolverMutationAtom, createGrantRegistryRolesMutationAtom, createGrantResolverRolesMutationAtom, createGrantResolverRootRolesMutationAtom, createImportDnsNameMutationAtom, createMigrateNameMutationAtom, createMigrateNamesMutationAtom, createReclaimNameMutationAtom, createRegisterNameMutationAtom, createRegisterNamesMutationAtom, createRenewNameMutationAtom, createRenewNamesMutationAtom, createResumeCallsMutationAtom, createRevokeRegistryRolesMutationAtom, createRevokeResolverRolesMutationAtom, createRevokeResolverRootRolesMutationAtom, createSendCallsMutationAtom, createSetAbiMutationAtom, createSetAddressMutationAtom, createSetAddressesMutationAtom, createSetAliasMutationAtom, createSetAvatarMutationAtom, createSetChildFusesMutationAtom, createSetContentHashMutationAtom, createSetContractPrimaryNameMutationAtom, createSetDataMutationAtom, createSetDnsRecordsMutationAtom, createSetFusesMutationAtom, createSetInterfaceMutationAtom, createSetManagerMutationAtom, createSetNameMutationAtom, createSetOperatorApprovalMutationAtom, createSetPrimaryNameForAddressMutationAtom, createSetPrimaryNameMutationAtom, createSetPubkeyMutationAtom, createSetRecordPermissionsMutationAtom, createSetRecordsMutationAtom, createSetResolverAndRecordsMutationAtom, createSetResolverDelegateApprovalMutationAtom, createSetResolverMutationAtom, createSetSubnameExpiryMutationAtom, createSetSubnameManagerMutationAtom, createSetSubnameRecordMutationAtom, createSetSubnameResolverMutationAtom, createSetTextMutationAtom, createSetTextsMutationAtom, createSetTtlMutationAtom, createSetZoneHashMutationAtom, createTransferNameMutationAtom, createTransferRegistrantMutationAtom, createTransferSubnameMutationAtom, createUnwrapNameMutationAtom, createUpgradeResolverMutationAtom, createWrapNameMutationAtom, defaultQueryAtomOptions, estimateCallsAtom, getAbiAtom, getAddressAtom, getAddressesAtom, getAliasAtom, getAvatarAtom, getCallsStatusAtom, getCanonicalResourceAtom, getCommitmentStatusAtom, getContentHashAtom, getDataAtom, getDnsClaimStatusAtom, getDnsImportPlanAtom, getDnsRecordAtom, getDnsRecordsAtom, getEnsEventsAtom, getExpiryAtom, getFusesAtom, getInterfaceAtom, getManagerAtom, getMigrationEligibilityAtom, getMigrationPlanAtom, getMigrationStatusAtom, getMigrationTargetAtom, getNameAtom, getNameCapabilitiesAtom, getNameHistoryAtom, getNameStateAtom, getNameStatusAtom, getOperatorApprovalAtom, getOwnerAtom, getPrimaryNameAtom, getProtocolAtom, getPubkeyAtom, getRecordPermissionsAtom, getRecordsAtom, getRegistrantAtom, getRegistrationParametersAtom, getRegistrationPlanAtom, getRegistrationPriceAtom, getRegistryAtom, getRegistryCapabilitiesAtom, getRegistryRolesAtom, getRenewalPriceAtom, getRequiredAuthorizationAtom, getResolverAtom, getResolverCapabilitiesAtom, getResolverDelegateApprovalAtom, getResolverRolesAtom, getResolverVersionAtom, getTextAtom, getTextsAtom, getTokenApprovalAtom, getTokenIdAtom, getTtlAtom, getWalletCapabilitiesAtom, getWrapperExpiryAtom, getWrapperPermissionsAtom, getWriteTargetAtom, getZoneHashAtom, hasDnsRecordsAtom, hasRegistryRolesAtom, hasResolverRolesAtom, isAvailableAtom, isMigratedAtom, isPaymentTokenSupportedAtom, isRenewableAtom, isReservedAtom, isWrappedAtom, makeMutationAtom, makeQueryAtom, makeRegistrationCommitmentAtom, makeStreamAtom, predictResolverAddressAtom, prepareCallsAtom, readBatchAtom, readBatchSettledAtom, resolveAtom, resolveBatchAtom, resolveWithResolverAtom, simulateCallsAtom, watchEnsEventsAtom };
+export { type EnsAtom, type EnsAtomFactory, type EnsAtomOptions, type EnsMutationAtom, type EnsMutationAtomFactory, type ReadBatchAtomParameters, type ResolvedEnsAtomOptions, createApproveMigrationMutationAtom, createApproveNameMutationAtom, createApprovePaymentTokenMutationAtom, createApproveRenewalPaymentMutationAtom, createClaimDnsNameMutationAtom, createClearAvatarMutationAtom, createClearNameApprovalMutationAtom, createClearPrimaryNameMutationAtom, createClearRecordsMutationAtom, createCommitNameMutationAtom, createCompleteRegistrationMutationAtom, createCreateResolverMutationAtom, createCreateSubnameMutationAtom, createDeleteSubnameMutationAtom, createExecuteWritePlanMutationAtom, createExtendSubnameExpiryMutationAtom, createGetOrCreateResolverMutationAtom, createGrantRegistryRolesMutationAtom, createGrantResolverRolesMutationAtom, createGrantResolverRootRolesMutationAtom, createImportDnsNameMutationAtom, createMigrateNameMutationAtom, createMigrateNamesMutationAtom, createReclaimNameMutationAtom, createRegisterNameMutationAtom, createRegisterNamesMutationAtom, createRenewNameMutationAtom, createRenewNamesMutationAtom, createResumeCallsMutationAtom, createRevokeRegistryRolesMutationAtom, createRevokeResolverRolesMutationAtom, createRevokeResolverRootRolesMutationAtom, createSendCallsMutationAtom, createSetAbiMutationAtom, createSetAddressMutationAtom, createSetAddressesMutationAtom, createSetAliasMutationAtom, createSetAvatarMutationAtom, createSetChildFusesMutationAtom, createSetContentHashMutationAtom, createSetContractPrimaryNameMutationAtom, createSetDataMutationAtom, createSetDnsRecordsMutationAtom, createSetFusesMutationAtom, createSetInterfaceMutationAtom, createSetManagerMutationAtom, createSetNameMutationAtom, createSetOperatorApprovalMutationAtom, createSetPrimaryNameForAddressMutationAtom, createSetPrimaryNameMutationAtom, createSetPubkeyMutationAtom, createSetRecordPermissionsMutationAtom, createSetRecordsMutationAtom, createSetResolverAndRecordsMutationAtom, createSetResolverDelegateApprovalMutationAtom, createSetResolverMutationAtom, createSetSubnameExpiryMutationAtom, createSetSubnameManagerMutationAtom, createSetSubnameRecordMutationAtom, createSetSubnameResolverMutationAtom, createSetTextMutationAtom, createSetTextsMutationAtom, createSetTtlMutationAtom, createSetZoneHashMutationAtom, createTransferNameMutationAtom, createTransferRegistrantMutationAtom, createTransferSubnameMutationAtom, createUnwrapNameMutationAtom, createUpgradeResolverMutationAtom, createWrapNameMutationAtom, defaultEnsAtomOptions, estimateCallsAtom, getAbiAtom, getAddressAtom, getAddressesAtom, getAliasAtom, getAvatarAtom, getCallsStatusAtom, getCanonicalResourceAtom, getCommitmentStatusAtom, getContentHashAtom, getDataAtom, getDnsClaimStatusAtom, getDnsImportPlanAtom, getDnsRecordAtom, getDnsRecordsAtom, getEnsEventsAtom, getExpiryAtom, getFusesAtom, getInterfaceAtom, getManagerAtom, getMigrationEligibilityAtom, getMigrationPlanAtom, getMigrationStatusAtom, getMigrationTargetAtom, getNameAtom, getNameCapabilitiesAtom, getNameHistoryAtom, getNameStateAtom, getNameStatusAtom, getOperatorApprovalAtom, getOwnerAtom, getPrimaryNameAtom, getProtocolAtom, getPubkeyAtom, getRecordPermissionsAtom, getRecordsAtom, getRegistrantAtom, getRegistrationParametersAtom, getRegistrationPlanAtom, getRegistrationPriceAtom, getRegistryAtom, getRegistryCapabilitiesAtom, getRegistryRolesAtom, getRenewalPriceAtom, getRequiredAuthorizationAtom, getResolverAtom, getResolverCapabilitiesAtom, getResolverDelegateApprovalAtom, getResolverRolesAtom, getResolverVersionAtom, getTextAtom, getTextsAtom, getTokenApprovalAtom, getTokenIdAtom, getTtlAtom, getWalletCapabilitiesAtom, getWrapperExpiryAtom, getWrapperPermissionsAtom, getWriteTargetAtom, getZoneHashAtom, hasDnsRecordsAtom, hasRegistryRolesAtom, hasResolverRolesAtom, isAvailableAtom, isMigratedAtom, isPaymentTokenSupportedAtom, isRenewableAtom, isReservedAtom, isWrappedAtom, makeMutationAtom, makeQueryAtom, makeRegistrationCommitmentAtom, makeStreamAtom, predictResolverAddressAtom, prepareCallsAtom, readBatchAtom, readBatchSettledAtom, resolveAtom, resolveBatchAtom, resolveWithResolverAtom, simulateCallsAtom, watchEnsEventsAtom };