@ensforge/react 0.1.1 → 0.2.0

package/README.md

@@ -14,7 +14,7 @@ Reactive React hooks for building ENS applications.
 ## Installation
 
 ```sh
-pnpm add @ensforge/react react effect@rc viem
+pnpm add @ensforge/react react effect@rc viem wagmi
 ```
 
 ## Overview
@@ -74,6 +74,13 @@ const updateUrl = () =>
   });
 ```
 
+Hook inputs are inferred automatically. When an action parameter type is needed explicitly, import
+it from the matching SDK group.
+
+```ts
+import type { SetTextParameters } from "@ensforge/sdk/records";
+```
+
 An existing SDK instance can also be shared through the provider:
 
 ```tsx

package/dist/atoms/capabilities.d.ts

@@ -24,7 +24,7 @@ declare const getNameCapabilitiesAtom: EnsAtomFactory<import("@ensforge/core").G
     readonly inherited: boolean;
     readonly extended: boolean;
     readonly permissioned: boolean;
-    readonly authorization: "role" | "unknown" | "none" | "owner-delegate";
+    readonly authorization: "none" | "unknown" | "role" | "owner-delegate";
     readonly profiles: {
       readonly address: boolean;
       readonly text: boolean;
@@ -117,7 +117,7 @@ declare const getOperatorApprovalAtom: EnsAtomFactory<import("@ensforge/core").G
   readonly owner: `0x${string}`;
   readonly operator: `0x${string}`;
   readonly targets: readonly {
-    readonly kind: "registry" | "resolver" | "registrar" | "wrapper";
+    readonly kind: "resolver" | "registrar" | "registry" | "wrapper";
     readonly address: `0x${string}`;
     readonly supported: boolean;
     readonly approved: boolean;
@@ -210,7 +210,7 @@ declare const getRegistryCapabilitiesAtom: EnsAtomFactory<import("@ensforge/core
   readonly transfer: boolean;
   readonly setExpiry: boolean;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getRegistryRolesAtom: EnsAtomFactory<import("@ensforge/core").GetRegistryRolesParameters, {
+declare const getRegistryRolesAtom: EnsAtomFactory<import("@ensforge/core").AccountCapabilityParameters, {
   readonly supported: false;
   readonly protocol: "v1" | "v2";
   readonly reason: "RESOLVER_NOT_FOUND" | "ROLE_BASED_PERMISSIONS_UNSUPPORTED";
@@ -269,11 +269,11 @@ declare const getRequiredAuthorizationAtom: EnsAtomFactory<import("@ensforge/cor
   readonly target: {
     readonly available: false;
     readonly protocol: "v1" | "v2";
-    readonly reason: "NAME_NOT_REGISTERED" | "RESOLVER_NOT_FOUND" | "OPERATION_UNSUPPORTED";
+    readonly reason: "RESOLVER_NOT_FOUND" | "NAME_NOT_REGISTERED" | "OPERATION_UNSUPPORTED";
   } | {
     readonly available: true;
     readonly protocol: "v1" | "v2";
-    readonly kind: "registry" | "resolver" | "registrar" | "name-wrapper" | "wrapper-registry";
+    readonly kind: "resolver" | "registrar" | "registry" | "name-wrapper" | "wrapper-registry";
     readonly address: `0x${string}`;
     readonly operation: {
       readonly type: "address";
@@ -354,7 +354,7 @@ declare const getRequiredAuthorizationAtom: EnsAtomFactory<import("@ensforge/cor
     readonly status: "unknown";
     readonly reason: "CUSTOM_RESOLVER";
   };
-  readonly blockers: readonly ("NAME_NOT_REGISTERED" | "RESOLVER_NOT_FOUND" | "OPERATION_UNSUPPORTED" | "WRAPPER_FUSE" | "TRANSFER_ROLE")[];
+  readonly blockers: readonly ("RESOLVER_NOT_FOUND" | "NAME_NOT_REGISTERED" | "OPERATION_UNSUPPORTED" | "WRAPPER_FUSE" | "TRANSFER_ROLE")[];
 }, import("@ensforge/core").GetCanonicalResourceError>;
 declare const getResolverCapabilitiesAtom: EnsAtomFactory<import("@ensforge/core").GetRegistryCapabilitiesParameters, {
   readonly address: `0x${string}` | null;
@@ -362,7 +362,7 @@ declare const getResolverCapabilitiesAtom: EnsAtomFactory<import("@ensforge/core
   readonly inherited: boolean;
   readonly extended: boolean;
   readonly permissioned: boolean;
-  readonly authorization: "role" | "unknown" | "none" | "owner-delegate";
+  readonly authorization: "none" | "unknown" | "role" | "owner-delegate";
   readonly profiles: {
     readonly address: boolean;
     readonly text: boolean;
@@ -412,7 +412,7 @@ declare const getTokenApprovalAtom: EnsAtomFactory<import("@ensforge/core").GetR
   readonly tokenId: bigint;
   readonly approved: `0x${string}` | null;
 }, import("@ensforge/core").GetCanonicalResourceError>;
-declare const getWrapperPermissionsAtom: EnsAtomFactory<import("@ensforge/core").GetRegistryRolesParameters, {
+declare const getWrapperPermissionsAtom: EnsAtomFactory<import("@ensforge/core").AccountCapabilityParameters, {
   readonly supported: false;
   readonly protocol: "v1" | "v2";
   readonly reason: "NAME_NOT_WRAPPED";
@@ -447,11 +447,11 @@ declare const getWrapperPermissionsAtom: EnsAtomFactory<import("@ensforge/core")
 declare const getWriteTargetAtom: EnsAtomFactory<import("@ensforge/core").GetWriteTargetParameters, {
   readonly available: false;
   readonly protocol: "v1" | "v2";
-  readonly reason: "NAME_NOT_REGISTERED" | "RESOLVER_NOT_FOUND" | "OPERATION_UNSUPPORTED";
+  readonly reason: "RESOLVER_NOT_FOUND" | "NAME_NOT_REGISTERED" | "OPERATION_UNSUPPORTED";
 } | {
   readonly available: true;
   readonly protocol: "v1" | "v2";
-  readonly kind: "registry" | "resolver" | "registrar" | "name-wrapper" | "wrapper-registry";
+  readonly kind: "resolver" | "registrar" | "registry" | "name-wrapper" | "wrapper-registry";
   readonly address: `0x${string}`;
   readonly operation: {
     readonly type: "address";

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

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","names":[],"sources":["../../src/atoms/capabilities.ts"],"mappings":";;cAEa,yBAAA,wCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGnC;cACY,yBAAA,wCAAuB;;;;;;;;;4BAGnC;cACY,0BAAA,wCAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGpC;cACY,6BAAA,wCAA2B;;;;;;;;;;;;;;4BAGvC;cACY,sBAAA,wCAAoB;;;;;;;;;;;4BAGhC;cACY,8BAAA,wCAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGxC;cACY,6BAAA,wCAA2B;;;;;;;;;;;;;;;;;;;4BAGvC;cACY,iCAAA,wCAA+B;;;;;;;;;;;4BAG3C;cACY,sBAAA,wCAAoB;;;;;;;;;;;4BAGhC;cACY,sBAAA,wCAAoB;;;;;;;;;;;4BAGhC;cACY,2BAAA,wCAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGrC;cACY,oBAAA,wCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAG9B;cACY,sBAAA,wCAAoB;;;;;;;;;;;;4BAGhC;cACY,sBAAA,wCAAoB;;;;;;;;;;;;4BAGhC"}
+{"version":3,"file":"capabilities.d.ts","names":[],"sources":["../../src/atoms/capabilities.ts"],"mappings":";;cAEa,yBAAA,wCAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAwDof;;;eAA6F,sDAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BArDrnB;cACY,yBAAA,wCAAuB;;;;;;;;;4BAGnC;cACY,0BAAA,wCAAwB;;;;;;;;;;;;;;;;;eA0BnC;;;eAE2C,sDAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAzB7C;cACY,6BAAA,wCAA2B;;;;;;;;;;;;;;4BAGvC;cACY,sBAAA,wCAAoB;;;;;;;;;;;4BAGhC;cACY,8BAAA,wCAA4B;;;;;;;;;;;;;;aAU1B;;;aAE2B,sDAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAwBwiB;;;eAA6F,sDAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAjChrB;cACY,6BAAA,wCAA2B;;;;;;;;;;;;;;;;;;;4BAGvC;cACY,iCAAA,wCAA+B;;;;;;;;;;;4BAG3C;cACY,sBAAA,wCAAoB;;;;;;;;;;;4BAGhC;cACY,sBAAA,wCAAoB;;;;;;;;;;;4BAGhC;cACY,2BAAA,wCAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGrC;cACY,oBAAA,wCAAkB;;;;;;;;;;;;;;;;;;;;;aAVZ;;;aAGb,sDAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAUN;cACY,sBAAA,wCAAoB;;;;;;;;;;;;4BAGhC;cACY,sBAAA,wCAAoB;;;;;;;;;;;;4BAGhC"}

package/dist/atoms/dns.d.ts

@@ -15,7 +15,7 @@ declare const getDnsClaimStatusAtom: EnsAtomFactory<import("@ensforge/core").Get
   readonly status: "proof-required";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly previousInception: bigint;
-}, import("@ensforge/core").GetDnsClaimStatusError>;
+}, import("@ensforge/core").DnsReadError>;
 declare const getDnsImportPlanAtom: EnsAtomFactory<import("@ensforge/core").GetDnsImportPlanParameters, {
   readonly status: "unsupported";
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
@@ -36,14 +36,14 @@ declare const getDnsImportPlanAtom: EnsAtomFactory<import("@ensforge/core").GetD
     readonly name: `0x${string}` & import("effect/Brand").Brand<"DnsEncodedName">;
     readonly previousInception: bigint;
   };
-}, import("@ensforge/core").GetDnsClaimStatusError>;
+}, import("@ensforge/core").DnsReadError>;
 declare const getDnsRecordAtom: EnsAtomFactory<import("@ensforge/core").GetDnsRecordParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resource: number;
   readonly resolver: `0x${string}` | null;
   readonly value: `0x${string}` | null;
-}, import("@ensforge/core").GetDnsClaimStatusError>;
+}, import("@ensforge/core").DnsReadError>;
 declare const getDnsRecordsAtom: EnsAtomFactory<import("@ensforge/core").GetDnsRecordsParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
@@ -54,20 +54,22 @@ declare const getDnsRecordsAtom: EnsAtomFactory<import("@ensforge/core").GetDnsR
     readonly resolver: `0x${string}` | null;
     readonly value: `0x${string}` | null;
   }[];
-}, import("@ensforge/core").GetDnsClaimStatusError>;
+}, import("@ensforge/core").DnsReadError>;
 declare const getZoneHashAtom: EnsAtomFactory<import("@ensforge/core").GetZoneHashParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
   readonly value: `0x${string}` | null;
-}, import("@ensforge/core").GetDnsClaimStatusError>;
+}, import("@ensforge/core").DnsReadError>;
 declare const hasDnsRecordsAtom: EnsAtomFactory<import("@ensforge/core").HasDnsRecordsParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly resolver: `0x${string}` | null;
   readonly exists: boolean;
-}, import("@ensforge/core").GetDnsClaimStatusError>;
+}, import("@ensforge/core").DnsReadError>;
 declare const createClaimDnsNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ClaimDnsNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
-declare const createImportDnsNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ImportDnsNameParameters, import("@ensforge/core").ImportDnsNameResult, import("@ensforge/core").WriteError>;
+declare const createImportDnsNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ClaimDnsNameParameters & import("@ensforge/core").DnsWriteWalletParameters & {
+  readonly resume?: import("@ensforge/core").ImportDnsNameResult;
+}, import("@ensforge/core").ImportDnsNameResult, import("@ensforge/core").WriteError>;
 declare const createSetDnsRecordsMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetDnsRecordsParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createSetZoneHashMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetZoneHashParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"dns.d.ts","names":[],"sources":["../../src/atoms/dns.ts"],"mappings":";;;cAGa,uBAAA,wCAAqB;;;;;;;;;;;;;;4BAA2D;cAChF,sBAAA,wCAAoB;;;;;;;;;;;;;;;;;;;;4BAA0D;cAC9E,kBAAA,wCAAgB;;;;;;4BAAsD;cACtE,mBAAA,wCAAiB;;;;;;;;;;4BAAuD;cACxE,iBAAA,wCAAe;;;;4BAAqD;cACpE,mBAAA,wCAAiB;;;;;4BAAuD;cAExE,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,+BAAA,gDAA6B,gDAAA,8CAAA"}
+{"version":3,"file":"dns.d.ts","names":[],"sources":["../../src/atoms/dns.ts"],"mappings":";;;cAGa,uBAAA,wCAAqB;;;;;;;;;;;;;;4BAA2D;cAChF,sBAAA,wCAAoB;;;;;;;;;;;;;;;;;;;;4BAA0D;cAC9E,kBAAA,wCAAgB;;;;;;4BAAsD;cACtE,mBAAA,wCAAiB;;;;;;;;;;4BAAuD;cACxE,iBAAA,wCAAe;;;;4BAAqD;cACpE,mBAAA,wCAAiB;;;;;4BAAuD;cAExE,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,iCAAA,gDAA+B,kDAAA;;4BAG3C,8CAAA;cACY,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,+BAAA,gDAA6B,gDAAA,8CAAA"}

package/dist/atoms/events.d.ts

@@ -1,86 +1,86 @@
 import { EnsAtomFactory } from "./query.js";
 //#region src/atoms/events.d.ts
 declare const getEnsEventsAtom: EnsAtomFactory<import("@ensforge/core").GetEnsEventsParameters, readonly {
-  readonly protocol: "v1" | "v2";
+  readonly blockNumber: bigint | null;
+  readonly transactionHash: `0x${string}` | null;
+  readonly transactionIndex: number | null;
+  readonly logIndex: number | null;
   readonly raw: {
     readonly topics: readonly `0x${string}`[];
     readonly data: `0x${string}`;
     readonly args: unknown;
   };
-  readonly blockNumber: bigint | null;
-  readonly kind: "migration" | "resolver" | "manager" | "commitment" | "records" | "ownership" | "registration" | "renewal" | "subname" | "other";
-  readonly transactionHash: `0x${string}` | null;
-  readonly contract: `0x${string}`;
-  readonly transactionIndex: number | null;
-  readonly logIndex: number | null;
-  readonly contractKind: "registry" | "resolver" | "registrar" | "name-wrapper" | "migration-controller";
+  readonly kind: "commitment" | "registration" | "renewal" | "ownership" | "manager" | "resolver" | "records" | "subname" | "migration" | "other";
+  readonly protocol: "v1" | "v2";
+  readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
   readonly eventName: string;
+  readonly contract: `0x${string}`;
   readonly removed: boolean;
-  readonly to?: `0x${string}` | undefined;
+  readonly commitment?: `0x${string}` | undefined;
+  readonly resolver?: `0x${string}` | undefined;
   readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
-  readonly tokenId?: bigint | undefined;
-  readonly owner?: `0x${string}` | undefined;
-  readonly from?: `0x${string}` | undefined;
   readonly label?: string | undefined;
-  readonly resolver?: `0x${string}` | undefined;
   readonly node?: `0x${string}` | undefined;
-  readonly commitment?: `0x${string}` | undefined;
-}[], import("@ensforge/core").GetEnsEventsError>;
+  readonly owner?: `0x${string}` | undefined;
+  readonly from?: `0x${string}` | undefined;
+  readonly to?: `0x${string}` | undefined;
+  readonly tokenId?: bigint | undefined;
+}[], import("@ensforge/core").EnsEventError>;
 declare const getNameHistoryAtom: EnsAtomFactory<import("@ensforge/core").GetNameHistoryParameters, {
   readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
   readonly events: readonly {
-    readonly protocol: "v1" | "v2";
+    readonly blockNumber: bigint | null;
+    readonly transactionHash: `0x${string}` | null;
+    readonly transactionIndex: number | null;
+    readonly logIndex: number | null;
     readonly raw: {
       readonly topics: readonly `0x${string}`[];
       readonly data: `0x${string}`;
       readonly args: unknown;
     };
-    readonly blockNumber: bigint | null;
-    readonly kind: "migration" | "resolver" | "manager" | "commitment" | "records" | "ownership" | "registration" | "renewal" | "subname" | "other";
-    readonly transactionHash: `0x${string}` | null;
-    readonly contract: `0x${string}`;
-    readonly transactionIndex: number | null;
-    readonly logIndex: number | null;
-    readonly contractKind: "registry" | "resolver" | "registrar" | "name-wrapper" | "migration-controller";
+    readonly kind: "commitment" | "registration" | "renewal" | "ownership" | "manager" | "resolver" | "records" | "subname" | "migration" | "other";
+    readonly protocol: "v1" | "v2";
+    readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
     readonly eventName: string;
+    readonly contract: `0x${string}`;
     readonly removed: boolean;
-    readonly to?: `0x${string}` | undefined;
+    readonly commitment?: `0x${string}` | undefined;
+    readonly resolver?: `0x${string}` | undefined;
     readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
-    readonly tokenId?: bigint | undefined;
-    readonly owner?: `0x${string}` | undefined;
-    readonly from?: `0x${string}` | undefined;
     readonly label?: string | undefined;
-    readonly resolver?: `0x${string}` | undefined;
     readonly node?: `0x${string}` | undefined;
-    readonly commitment?: `0x${string}` | undefined;
+    readonly owner?: `0x${string}` | undefined;
+    readonly from?: `0x${string}` | undefined;
+    readonly to?: `0x${string}` | undefined;
+    readonly tokenId?: bigint | undefined;
   }[];
-}, import("@ensforge/core").GetEnsEventsError>;
+}, import("@ensforge/core").EnsEventError>;
 declare const watchEnsEventsAtom: EnsAtomFactory<import("@ensforge/core").WatchEnsEventsParameters, {
+  readonly kind: "resolver" | "commitment" | "registration" | "renewal" | "ownership" | "manager" | "records" | "subname" | "migration" | "other";
   readonly protocol: "v1" | "v2";
-  readonly raw: {
-    readonly topics: readonly `0x${string}`[];
-    readonly data: `0x${string}`;
-    readonly args: unknown;
-  };
+  readonly contractKind: "registry" | "name-wrapper" | "registrar" | "resolver" | "migration-controller";
+  readonly eventName: string;
+  readonly contract: `0x${string}`;
   readonly blockNumber: bigint | null;
-  readonly kind: "migration" | "resolver" | "manager" | "commitment" | "records" | "ownership" | "registration" | "renewal" | "subname" | "other";
   readonly transactionHash: `0x${string}` | null;
-  readonly contract: `0x${string}`;
   readonly transactionIndex: number | null;
   readonly logIndex: number | null;
-  readonly contractKind: "registry" | "resolver" | "registrar" | "name-wrapper" | "migration-controller";
-  readonly eventName: string;
   readonly removed: boolean;
-  readonly to?: `0x${string}` | undefined;
+  readonly raw: {
+    readonly topics: readonly `0x${string}`[];
+    readonly data: `0x${string}`;
+    readonly args: unknown;
+  };
+  readonly resolver?: `0x${string}` | undefined;
   readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
-  readonly tokenId?: bigint | undefined;
-  readonly owner?: `0x${string}` | undefined;
-  readonly from?: `0x${string}` | undefined;
+  readonly commitment?: `0x${string}` | undefined;
   readonly label?: string | undefined;
-  readonly resolver?: `0x${string}` | undefined;
   readonly node?: `0x${string}` | undefined;
-  readonly commitment?: `0x${string}` | undefined;
-}, import("effect/Cause").NoSuchElementError | import("@ensforge/core").GetEnsEventsError>;
+  readonly owner?: `0x${string}` | undefined;
+  readonly from?: `0x${string}` | undefined;
+  readonly to?: `0x${string}` | undefined;
+  readonly tokenId?: bigint | undefined;
+}, import("@ensforge/core").EnsEventError | import("effect/Cause").NoSuchElementError>;
 //#endregion
 export { getEnsEventsAtom, getNameHistoryAtom, watchEnsEventsAtom };
 //# sourceMappingURL=events.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","names":[],"sources":["../../src/atoms/events.ts"],"mappings":";;cAGa,kBAAA,wCAAgB;;;;;;;;;;;;;;;;;;;;;;;;;8BAA4D;cAC5E,oBAAA,wCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAA8D;cAChF,oBAAA,wCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;0BAA+D,8CAAA"}
+{"version":3,"file":"events.d.ts","names":[],"sources":["../../src/atoms/events.ts"],"mappings":";;cAGa,kBAAA,wCAAgB;;;;;;;;;;;;;;;;;;;;;;;;;8BAA4D;cAC5E,oBAAA,wCAAkB;;;;;;;;;;;;;;;;;;aAEwtB;aAAmD;aAA+C,wCAAC;aAA2F;aAAwC;aAAgD;aAA+C;aAA6C;aAAkD;;4BAF9jC;cAChF,oBAAA,wCAAkB;;;;;;;;;;;;;;;;;;;;;;;;;4BAA+D,uCAAA"}

package/dist/atoms/generic.d.ts

@@ -1,6 +1,8 @@
 import { EnsAtomOptions } from "../query/options.js";
 import { EnsAtom } from "./query.js";
-import { EnsReadRequest, Ensforge, GetRecordsError, GetRecordsParameters, GetRecordsResult, GetRecordsSelection, ReadBatchError, ReadBatchOptions, ReadBatchResult, ReadBatchSettledResult, RpcError } from "@ensforge/sdk";
+import { EnsReadRequest, Ensforge, RpcError } from "@ensforge/sdk";
+import { ReadBatchError, ReadBatchOptions, ReadBatchResult, ReadBatchSettledResult } from "@ensforge/sdk/batch";
+import { GetRecordsError, GetRecordsParameters, GetRecordsResult, GetRecordsSelection } from "@ensforge/sdk/records";
 //#region src/atoms/generic.d.ts
 type ReadRequests = Readonly<Record<string, EnsReadRequest<unknown, unknown>>>;
 interface ReadBatchAtomParameters<Requests extends ReadRequests> {

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

@@ -1 +1 @@
-{"version":3,"file":"generic.d.ts","names":[],"sources":["../../src/atoms/generic.ts"],"mappings":";;;;KAiBK,eAAe,SAAS,eAAe;UAE3B,wBAAwB,iBAAiB;WAC/C,UAAU;WACV,UAAU;;cAQR,uBAAwB,kBAAkB,qBACrD,KAAK,UACL,YAAY,qBAAqB,YACjC,UAAU,eAAe,qBACxB,QAAQ,iBAAiB,YAAY;cAc3B,sBAAuB,iBAAiB,cACnD,KAAK,UACL,YAAY,wBAAwB,WACpC,UAAU,eAAe,eAAe,eACvC,QAAQ,gBAAgB,WAAW,eAAe;cAcxC,6BAA8B,iBAAiB,cAC1D,KAAK,UACL,YAAY,wBAAwB,WACpC,UAAU,eAAe,cACxB,QAAQ,uBAAuB,WAAW"}
+{"version":3,"file":"generic.d.ts","names":[],"sources":["../../src/atoms/generic.ts"],"mappings":";;;;;;KAkBK,eAAe,SAAS,eAAe;UAE3B,wBAAwB,iBAAiB;WAC/C,UAAU;WACV,UAAU;;cAQR,uBAAwB,kBAAkB,qBACrD,KAAK,UACL,YAAY,qBAAqB,YACjC,UAAU,eAAe,qBACxB,QAAQ,iBAAiB,YAAY;cAc3B,sBAAuB,iBAAiB,cACnD,KAAK,UACL,YAAY,wBAAwB,WACpC,UAAU,eAAe,eAAe,eACvC,QAAQ,gBAAgB,WAAW,eAAe;cAcxC,6BAA8B,iBAAiB,cAC1D,KAAK,UACL,YAAY,wBAAwB,WACpC,UAAU,eAAe,cACxB,QAAQ,uBAAuB,WAAW"}

package/dist/atoms/generic.js.map

@@ -1 +1 @@
-{"version":3,"file":"generic.js","names":[],"sources":["../../src/atoms/generic.ts"],"sourcesContent":["import type {\n  EnsReadRequest,\n  GetRecordsError,\n  GetRecordsParameters,\n  GetRecordsResult,\n  GetRecordsSelection,\n  ReadBatchError,\n  ReadBatchOptions,\n  ReadBatchResult,\n  ReadBatchSettledResult,\n  RpcError,\n} from \"@ensforge/sdk\";\nimport type { Ensforge } from \"@ensforge/sdk\";\n\nimport type { EnsAtomOptions } from \"../query/options.js\";\nimport { makeQueryAtom, type EnsAtom } from \"./query.js\";\n\ntype ReadRequests = Readonly<Record<string, EnsReadRequest<unknown, unknown>>>;\n\nexport interface ReadBatchAtomParameters<Requests extends ReadRequests> {\n  readonly options?: ReadBatchOptions;\n  readonly requests: Requests;\n}\n\nconst getRecordsAtomBase = makeQueryAtom<GetRecordsParameters, GetRecordsResult, GetRecordsError>(\n  \"records\",\n  (sdk) => sdk.records.getRecords,\n);\n\nexport const getRecordsAtom = <const Selection extends GetRecordsSelection>(\n  sdk: Ensforge,\n  parameters: GetRecordsParameters<Selection>,\n  options?: EnsAtomOptions<GetRecordsError>,\n): EnsAtom<GetRecordsResult<Selection>, GetRecordsError> =>\n  getRecordsAtomBase(sdk, parameters, options) as EnsAtom<\n    GetRecordsResult<Selection>,\n    GetRecordsError\n  >;\n\nconst readBatchAtomBase = makeQueryAtom<\n  ReadBatchAtomParameters<ReadRequests>,\n  ReadBatchResult<ReadRequests>,\n  ReadBatchError<ReadRequests>\n>(\"batch\", (sdk) => ({\n  effect: ({ options, requests }) => sdk.batch.readBatch.effect(requests, options),\n}));\n\nexport const readBatchAtom = <const Requests extends ReadRequests>(\n  sdk: Ensforge,\n  parameters: ReadBatchAtomParameters<Requests>,\n  options?: EnsAtomOptions<ReadBatchError<Requests>>,\n): EnsAtom<ReadBatchResult<Requests>, ReadBatchError<Requests>> =>\n  readBatchAtomBase(sdk, parameters, options as EnsAtomOptions<unknown>) as EnsAtom<\n    ReadBatchResult<Requests>,\n    ReadBatchError<Requests>\n  >;\n\nconst readBatchSettledAtomBase = makeQueryAtom<\n  ReadBatchAtomParameters<ReadRequests>,\n  ReadBatchSettledResult<ReadRequests>,\n  RpcError\n>(\"batch\", (sdk) => ({\n  effect: ({ options, requests }) => sdk.batch.readBatchSettled.effect(requests, options),\n}));\n\nexport const readBatchSettledAtom = <const Requests extends ReadRequests>(\n  sdk: Ensforge,\n  parameters: ReadBatchAtomParameters<Requests>,\n  options?: EnsAtomOptions<RpcError>,\n): EnsAtom<ReadBatchSettledResult<Requests>, RpcError> =>\n  readBatchSettledAtomBase(sdk, parameters, options) as EnsAtom<\n    ReadBatchSettledResult<Requests>,\n    RpcError\n  >;\n"],"mappings":";;;AAwBA,MAAM,qBAAqB,cACzB,YACC,QAAQ,IAAI,QAAQ,UACvB;AAEA,MAAa,kBACX,KACA,YACA,YAEA,mBAAmB,KAAK,YAAY,OAAO;AAK7C,MAAM,oBAAoB,cAIxB,UAAU,SAAS,EACnB,SAAS,EAAE,SAAS,eAAe,IAAI,MAAM,UAAU,OAAO,UAAU,OAAO,EACjF,EAAE;AAEF,MAAa,iBACX,KACA,YACA,YAEA,kBAAkB,KAAK,YAAY,OAAkC;AAKvE,MAAM,2BAA2B,cAI/B,UAAU,SAAS,EACnB,SAAS,EAAE,SAAS,eAAe,IAAI,MAAM,iBAAiB,OAAO,UAAU,OAAO,EACxF,EAAE;AAEF,MAAa,wBACX,KACA,YACA,YAEA,yBAAyB,KAAK,YAAY,OAAO"}
+{"version":3,"file":"generic.js","names":[],"sources":["../../src/atoms/generic.ts"],"sourcesContent":["import type { EnsReadRequest, RpcError } from \"@ensforge/sdk\";\nimport type { Ensforge } from \"@ensforge/sdk\";\nimport type {\n  ReadBatchError,\n  ReadBatchOptions,\n  ReadBatchResult,\n  ReadBatchSettledResult,\n} from \"@ensforge/sdk/batch\";\nimport type {\n  GetRecordsError,\n  GetRecordsParameters,\n  GetRecordsResult,\n  GetRecordsSelection,\n} from \"@ensforge/sdk/records\";\n\nimport type { EnsAtomOptions } from \"../query/options.js\";\nimport { makeQueryAtom, type EnsAtom } from \"./query.js\";\n\ntype ReadRequests = Readonly<Record<string, EnsReadRequest<unknown, unknown>>>;\n\nexport interface ReadBatchAtomParameters<Requests extends ReadRequests> {\n  readonly options?: ReadBatchOptions;\n  readonly requests: Requests;\n}\n\nconst getRecordsAtomBase = makeQueryAtom<GetRecordsParameters, GetRecordsResult, GetRecordsError>(\n  \"records\",\n  (sdk) => sdk.records.getRecords,\n);\n\nexport const getRecordsAtom = <const Selection extends GetRecordsSelection>(\n  sdk: Ensforge,\n  parameters: GetRecordsParameters<Selection>,\n  options?: EnsAtomOptions<GetRecordsError>,\n): EnsAtom<GetRecordsResult<Selection>, GetRecordsError> =>\n  getRecordsAtomBase(sdk, parameters, options) as EnsAtom<\n    GetRecordsResult<Selection>,\n    GetRecordsError\n  >;\n\nconst readBatchAtomBase = makeQueryAtom<\n  ReadBatchAtomParameters<ReadRequests>,\n  ReadBatchResult<ReadRequests>,\n  ReadBatchError<ReadRequests>\n>(\"batch\", (sdk) => ({\n  effect: ({ options, requests }) => sdk.batch.readBatch.effect(requests, options),\n}));\n\nexport const readBatchAtom = <const Requests extends ReadRequests>(\n  sdk: Ensforge,\n  parameters: ReadBatchAtomParameters<Requests>,\n  options?: EnsAtomOptions<ReadBatchError<Requests>>,\n): EnsAtom<ReadBatchResult<Requests>, ReadBatchError<Requests>> =>\n  readBatchAtomBase(sdk, parameters, options as EnsAtomOptions<unknown>) as EnsAtom<\n    ReadBatchResult<Requests>,\n    ReadBatchError<Requests>\n  >;\n\nconst readBatchSettledAtomBase = makeQueryAtom<\n  ReadBatchAtomParameters<ReadRequests>,\n  ReadBatchSettledResult<ReadRequests>,\n  RpcError\n>(\"batch\", (sdk) => ({\n  effect: ({ options, requests }) => sdk.batch.readBatchSettled.effect(requests, options),\n}));\n\nexport const readBatchSettledAtom = <const Requests extends ReadRequests>(\n  sdk: Ensforge,\n  parameters: ReadBatchAtomParameters<Requests>,\n  options?: EnsAtomOptions<RpcError>,\n): EnsAtom<ReadBatchSettledResult<Requests>, RpcError> =>\n  readBatchSettledAtomBase(sdk, parameters, options) as EnsAtom<\n    ReadBatchSettledResult<Requests>,\n    RpcError\n  >;\n"],"mappings":";;;AAyBA,MAAM,qBAAqB,cACzB,YACC,QAAQ,IAAI,QAAQ,UACvB;AAEA,MAAa,kBACX,KACA,YACA,YAEA,mBAAmB,KAAK,YAAY,OAAO;AAK7C,MAAM,oBAAoB,cAIxB,UAAU,SAAS,EACnB,SAAS,EAAE,SAAS,eAAe,IAAI,MAAM,UAAU,OAAO,UAAU,OAAO,EACjF,EAAE;AAEF,MAAa,iBACX,KACA,YACA,YAEA,kBAAkB,KAAK,YAAY,OAAkC;AAKvE,MAAM,2BAA2B,cAI/B,UAAU,SAAS,EACnB,SAAS,EAAE,SAAS,eAAe,IAAI,MAAM,iBAAiB,OAAO,UAAU,OAAO,EACxF,EAAE;AAEF,MAAa,wBACX,KACA,YACA,YAEA,yBAAyB,KAAK,YAAY,OAAO"}

package/dist/atoms/migration.d.ts

@@ -164,7 +164,7 @@ declare const getMigrationTargetAtom: EnsAtomFactory<import("@ensforge/core").Ge
   readonly receiver: `0x${string}`;
 }, import("@ensforge/core").GetCanonicalResourceError>;
 declare const createApproveMigrationMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ApproveMigrationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
-declare const createMigrateNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").MigrateNameParameters, import("@ensforge/core").MigrateNameResult, import("@ensforge/core").WriteError>;
+declare const createMigrateNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").MigrateNameCallParameters & import("@ensforge/core").MigrateNameParameters, import("@ensforge/core").CallExecutionResult | import("@ensforge/core").MigrateNameResult, import("@ensforge/core").WriteError>;
 declare const createMigrateNamesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").MigrateNamesParameters, import("@ensforge/core").MigrationBatchProgress, import("@ensforge/core").WriteError>;
 //#endregion
 export { createApproveMigrationMutationAtom, createMigrateNameMutationAtom, createMigrateNamesMutationAtom, getMigrationEligibilityAtom, getMigrationPlanAtom, getMigrationStatusAtom, getMigrationTargetAtom };

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

@@ -1 +1 @@
-{"version":3,"file":"migration.d.ts","names":[],"sources":["../../src/atoms/migration.ts"],"mappings":";;;cAGa,6BAAA,wCAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGvC;cACY,sBAAA,wCAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGhC;cACY,wBAAA,wCAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGlC;cACY,wBAAA,wCAAsB;;;;;;;;;;;;4BAGlC;cAEY,oCAAA,gDAAkC,qDAAA,8CAAA;cAIlC,+BAAA,gDAA6B,gDAAA,4CAAA;cAI7B,gCAAA,gDAA8B,iDAAA,iDAAA"}
+{"version":3,"file":"migration.d.ts","names":[],"sources":["../../src/atoms/migration.ts"],"mappings":";;;cAGa,6BAAA,wCAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGvC;cACY,sBAAA,wCAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGhC;cACY,wBAAA,wCAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGlC;cACY,wBAAA,wCAAsB;;;;;;;;;;;;4BAGlC;cAEY,oCAAA,gDAAkC,qDAAA,8CAAA;cAIlC,+BAAA,gDAA6B,qDAAA,gDAAA,+CAAA,4CAAA;cAI7B,gCAAA,gDAA8B,iDAAA,iDAAA"}

package/dist/atoms/name.d.ts

@@ -125,7 +125,7 @@ declare const getOwnerAtom: EnsAtomFactory<import("@ensforge/core").GetOwnerPara
   readonly owner: `0x${string}` | null;
   readonly registrant: `0x${string}` | null;
   readonly protocol: "v1" | "v2";
-  readonly ownershipLevel: "registry" | "registrar" | "nameWrapper";
+  readonly ownershipLevel: "registrar" | "registry" | "nameWrapper";
 } | null, import("@ensforge/core").GetOwnerError>;
 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>;

package/dist/atoms/records.d.ts

@@ -85,7 +85,7 @@ declare const createSetDataMutationAtom: EnsMutationAtomFactory<import("@ensforg
 declare const createSetInterfaceMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetInterfaceParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createSetNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createSetPubkeyMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetPubkeyParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
-declare const createSetRecordsMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetRecordsParameters, import("@ensforge/core").SetRecordsResult, import("@ensforge/core").WriteError>;
+declare const createSetRecordsMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetRecordsParameters, import("@ensforge/core").CallExecutionResult | import("@ensforge/core").SetRecordsResult, import("@ensforge/core").WriteError>;
 declare const createSetTextMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetTextParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createSetTextsMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetTextsParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 //#endregion

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

@@ -1 +1 @@
-{"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"}
+{"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,+CAAA,2CAAA;cAI5B,2BAAA,gDAAyB,4CAAA,8CAAA;cACzB,4BAAA,gDAA0B,6CAAA,8CAAA"}

package/dist/atoms/registration.d.ts

@@ -243,10 +243,40 @@ declare const makeRegistrationCommitmentAtom: EnsAtomFactory<import("@ensforge/c
 declare const createApprovePaymentTokenMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ApprovePaymentTokenParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createApproveRenewalPaymentMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ApproveRenewalPaymentParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createCommitNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").CommitNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
-declare const createCompleteRegistrationMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").CompleteRegistrationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
-declare const createRegisterNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").RegisterNameParameters, import("@ensforge/core").RegisterNameResult, import("@ensforge/core").WriteError>;
+declare const createCompleteRegistrationMutationAtom: EnsMutationAtomFactory<{
+  readonly resolver?: import("@ensforge/core").EthereumAddress;
+  readonly name: string;
+  readonly records?: ReadonlyArray<import("@ensforge/core").Hex>;
+  readonly owner: import("@ensforge/core").EthereumAddress;
+  readonly duration: bigint;
+  readonly secret: import("@ensforge/core").Bytes32;
+  readonly subregistry?: import("@ensforge/core").EthereumAddress;
+  readonly reverseRecord?: 0 | 1 | 2;
+  readonly referrer?: import("@ensforge/core").Bytes32;
+} & {
+  readonly paymentToken?: import("@ensforge/core").EthereumAddress;
+  readonly maxPrice?: bigint;
+}, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createRegisterNameMutationAtom: EnsMutationAtomFactory<Omit<{
+  readonly resolver?: import("@ensforge/core").EthereumAddress;
+  readonly name: string;
+  readonly records?: ReadonlyArray<import("@ensforge/core").Hex>;
+  readonly owner: import("@ensforge/core").EthereumAddress;
+  readonly duration: bigint;
+  readonly secret: import("@ensforge/core").Bytes32;
+  readonly subregistry?: import("@ensforge/core").EthereumAddress;
+  readonly reverseRecord?: 0 | 1 | 2;
+  readonly referrer?: import("@ensforge/core").Bytes32;
+}, "records"> & import("@ensforge/core").RegistrationWalletParameters & {
+  readonly paymentToken?: import("@ensforge/core").EthereumAddress;
+  readonly maxPrice?: bigint;
+  readonly records?: ReadonlyArray<import("@ensforge/core").SetRecordInput>;
+  readonly resume?: import("@ensforge/core").RegisterNameResult;
+}, import("@ensforge/core").RegisterNameResult, import("@ensforge/core").WriteError>;
 declare const createRegisterNamesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").RegisterNamesParameters, import("@ensforge/core").RegisterNamesResult, import("@ensforge/core").WriteError>;
-declare const createRenewNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").RenewNameParameters, import("@ensforge/core").RenewNameResult, import("@ensforge/core").WriteError>;
+declare const createRenewNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").RenewNameCallParameters & import("@ensforge/core").RegistrationWalletParameters & {
+  readonly resume?: import("@ensforge/core").RenewNameResult;
+}, import("@ensforge/core").CallExecutionResult | import("@ensforge/core").RenewNameResult, import("@ensforge/core").WriteError>;
 declare const createRenewNamesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").RenewNamesParameters, import("@ensforge/core").RenewNamesResult, import("@ensforge/core").WriteError>;
 //#endregion
 export { createApprovePaymentTokenMutationAtom, createApproveRenewalPaymentMutationAtom, createCommitNameMutationAtom, createCompleteRegistrationMutationAtom, createRegisterNameMutationAtom, createRegisterNamesMutationAtom, createRenewNameMutationAtom, createRenewNamesMutationAtom, getCommitmentStatusAtom, getRegistrationParametersAtom, getRegistrationPlanAtom, getRegistrationPriceAtom, getRenewalPriceAtom, isPaymentTokenSupportedAtom, makeRegistrationCommitmentAtom };

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

@@ -1 +1 @@
-{"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"}
+{"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;;;qBAAA;;;;;;;;;;4BAGZ,8CAAA;cACY,uDAA8B;;;;;;;;;;;;;;;4BAG1C,6CAAA;cACY,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,6BAAA,gDAA2B,mDAAA;;4BAGvC,+CAAA,0CAAA;cACY,8BAAA,gDAA4B,+CAAA,2CAAA"}

package/dist/atoms/resolution.d.ts

@@ -35,11 +35,11 @@ declare const resolveWithResolverAtom: EnsAtomFactory<import("@ensforge/core").R
   readonly data: `0x${string}`;
   readonly resolverAddress: `0x${string}`;
 }, import("@ensforge/core").ResolveError>;
-declare const createCreateResolverMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").CreateResolverParameters, import("@ensforge/core").CreateResolverResult, import("@ensforge/core").WriteError>;
+declare const createCreateResolverMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").CreateResolverParameters, import("@ensforge/core").CallExecutionResult | import("@ensforge/core").CreateResolverResult, import("@ensforge/core").WriteError>;
 declare const createGetOrCreateResolverMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").GetOrCreateResolverParameters, import("@ensforge/core").GetOrCreateResolverResult, import("@ensforge/core").WriteError>;
 declare const createSetResolverMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetResolverParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
 declare const createSetResolverAndRecordsMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetResolverAndRecordsParameters, import("@ensforge/core").SetResolverAndRecordsProgress, import("@ensforge/core").WriteError>;
-declare const createUpgradeResolverMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").UpgradeResolverParameters, import("@ensforge/core").UpgradeResolverResult, import("@ensforge/core").WriteError>;
+declare const createUpgradeResolverMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").UpgradeResolverParameters, import("@ensforge/core").CallExecutionResult | import("@ensforge/core").UpgradeResolverResult, import("@ensforge/core").WriteError>;
 //#endregion
 export { createCreateResolverMutationAtom, createGetOrCreateResolverMutationAtom, createSetResolverAndRecordsMutationAtom, createSetResolverMutationAtom, createUpgradeResolverMutationAtom, getAliasAtom, getResolverAtom, getResolverVersionAtom, predictResolverAddressAtom, resolveAtom, resolveBatchAtom, resolveWithResolverAtom };
 //# sourceMappingURL=resolution.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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,+CAAA;cAIhC,uCAAA,gDAAqC,wDAAA,oDAAA;cAIrC,+BAAA,gDAA6B,gDAAA,8CAAA;cAI7B,yCAAA,gDAAuC,0DAAA,wDAAA;cAIvC,mCAAA,gDAAiC,oDAAA,+CAAA,gDAAA"}

package/dist/atoms/wrapping.d.ts

@@ -1,8 +1,8 @@
 import { EnsAtomFactory } from "./query.js";
 import { EnsMutationAtomFactory } from "./mutation.js";
 //#region src/atoms/wrapping.d.ts
-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 getFusesAtom: EnsAtomFactory<import("@ensforge/core").GetFusesParameters, import("@ensforge/core").GetFusesResult, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getWrapperExpiryAtom: EnsAtomFactory<import("@ensforge/core").GetFusesParameters, 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,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"}
+{"version":3,"file":"wrapping.d.ts","names":[],"sources":["../../src/atoms/wrapping.ts"],"mappings":";;;cAGa,cAAA,wCAAY,6CAAA,yCAAA;cACZ,sBAAA,wCAAoB,6CAAA,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"}