@ensforge/react 0.0.0

package/dist/atoms/permissions.d.ts

@@ -0,0 +1,16 @@
+import { EnsMutationAtomFactory } from "./mutation.js";
+//#region src/atoms/permissions.d.ts
+declare const createApproveNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ApproveNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createClearNameApprovalMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ClearNameApprovalParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createGrantRegistryRolesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").RegistryRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createGrantResolverRolesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ResolverRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createGrantResolverRootRolesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ResolverRootRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createRevokeRegistryRolesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").RegistryRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createRevokeResolverRolesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ResolverRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createRevokeResolverRootRolesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ResolverRootRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetOperatorApprovalMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetOperatorApprovalParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetRecordPermissionsMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetRecordPermissionsParameters, import("@ensforge/core").SetRecordPermissionsResult, import("@ensforge/core").WriteError>;
+declare const createSetResolverDelegateApprovalMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetResolverDelegateApprovalParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+//#endregion
+export { createApproveNameMutationAtom, createClearNameApprovalMutationAtom, createGrantRegistryRolesMutationAtom, createGrantResolverRolesMutationAtom, createGrantResolverRootRolesMutationAtom, createRevokeRegistryRolesMutationAtom, createRevokeResolverRolesMutationAtom, createRevokeResolverRootRolesMutationAtom, createSetOperatorApprovalMutationAtom, createSetRecordPermissionsMutationAtom, createSetResolverDelegateApprovalMutationAtom };
+//# sourceMappingURL=permissions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","names":[],"sources":["../../src/atoms/permissions.ts"],"mappings":";;cAEa,+BAAA,gDAA6B,gDAAA,8CAAA;cAI7B,qCAAA,gDAAmC,sDAAA,8CAAA;cAInC,sCAAA,gDAAoC,0DAAA,8CAAA;cAIpC,sCAAA,gDAAoC,0DAAA,8CAAA;cAIpC,0CAAA,gDAAwC,8DAAA,8CAAA;cAIxC,uCAAA,gDAAqC,0DAAA,8CAAA;cAIrC,uCAAA,gDAAqC,0DAAA,8CAAA;cAIrC,2CAAA,gDAAyC,8DAAA,8CAAA;cAIzC,uCAAA,gDAAqC,wDAAA,8CAAA;cAIrC,wCAAA,gDAAsC,yDAAA,qDAAA;cAItC,+CAAA,gDAA6C,gEAAA,8CAAA"}

package/dist/atoms/permissions.js

@@ -0,0 +1,18 @@
+import { makeMutationAtom } from "./mutation.js";
+
+//#region src/atoms/permissions.ts
+const createApproveNameMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.approveName);
+const createClearNameApprovalMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.clearNameApproval);
+const createGrantRegistryRolesMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.grantRegistryRoles);
+const createGrantResolverRolesMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.grantResolverRoles);
+const createGrantResolverRootRolesMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.grantResolverRootRoles);
+const createRevokeRegistryRolesMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.revokeRegistryRoles);
+const createRevokeResolverRolesMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.revokeResolverRoles);
+const createRevokeResolverRootRolesMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.revokeResolverRootRoles);
+const createSetOperatorApprovalMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.setOperatorApproval);
+const createSetRecordPermissionsMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.setRecordPermissions);
+const createSetResolverDelegateApprovalMutationAtom = makeMutationAtom("permissions", (sdk) => sdk.permissions.setResolverDelegateApproval);
+
+//#endregion
+export { createApproveNameMutationAtom, createClearNameApprovalMutationAtom, createGrantRegistryRolesMutationAtom, createGrantResolverRolesMutationAtom, createGrantResolverRootRolesMutationAtom, createRevokeRegistryRolesMutationAtom, createRevokeResolverRolesMutationAtom, createRevokeResolverRootRolesMutationAtom, createSetOperatorApprovalMutationAtom, createSetRecordPermissionsMutationAtom, createSetResolverDelegateApprovalMutationAtom };
+//# sourceMappingURL=permissions.js.map

package/dist/atoms/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.js","names":[],"sources":["../../src/atoms/permissions.ts"],"sourcesContent":["import { makeMutationAtom } from \"./mutation.js\";\n\nexport const createApproveNameMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.approveName,\n);\nexport const createClearNameApprovalMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.clearNameApproval,\n);\nexport const createGrantRegistryRolesMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.grantRegistryRoles,\n);\nexport const createGrantResolverRolesMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.grantResolverRoles,\n);\nexport const createGrantResolverRootRolesMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.grantResolverRootRoles,\n);\nexport const createRevokeRegistryRolesMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.revokeRegistryRoles,\n);\nexport const createRevokeResolverRolesMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.revokeResolverRoles,\n);\nexport const createRevokeResolverRootRolesMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.revokeResolverRootRoles,\n);\nexport const createSetOperatorApprovalMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.setOperatorApproval,\n);\nexport const createSetRecordPermissionsMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.setRecordPermissions,\n);\nexport const createSetResolverDelegateApprovalMutationAtom = makeMutationAtom(\n  \"permissions\",\n  (sdk) => sdk.permissions.setResolverDelegateApproval,\n);\n"],"mappings":";;;AAEA,MAAa,gCAAgC,iBAC3C,gBACC,QAAQ,IAAI,YAAY,WAC3B;AACA,MAAa,sCAAsC,iBACjD,gBACC,QAAQ,IAAI,YAAY,iBAC3B;AACA,MAAa,uCAAuC,iBAClD,gBACC,QAAQ,IAAI,YAAY,kBAC3B;AACA,MAAa,uCAAuC,iBAClD,gBACC,QAAQ,IAAI,YAAY,kBAC3B;AACA,MAAa,2CAA2C,iBACtD,gBACC,QAAQ,IAAI,YAAY,sBAC3B;AACA,MAAa,wCAAwC,iBACnD,gBACC,QAAQ,IAAI,YAAY,mBAC3B;AACA,MAAa,wCAAwC,iBACnD,gBACC,QAAQ,IAAI,YAAY,mBAC3B;AACA,MAAa,4CAA4C,iBACvD,gBACC,QAAQ,IAAI,YAAY,uBAC3B;AACA,MAAa,wCAAwC,iBACnD,gBACC,QAAQ,IAAI,YAAY,mBAC3B;AACA,MAAa,yCAAyC,iBACpD,gBACC,QAAQ,IAAI,YAAY,oBAC3B;AACA,MAAa,gDAAgD,iBAC3D,gBACC,QAAQ,IAAI,YAAY,2BAC3B"}

package/dist/atoms/query.d.ts

@@ -0,0 +1,18 @@
+import { BoundEffectAction } from "../internal/action-types.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 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>;
+//#endregion
+export { EnsQueryAtom, EnsQueryAtomFactory, QueryAtomOptions, defaultQueryAtomOptions, makeQueryAtom };
+//# sourceMappingURL=query.d.ts.map

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

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

package/dist/atoms/query.js

@@ -0,0 +1,30 @@
+import { atomRuntime } from "../internal/runtime.js";
+import { makeReactivityKeys } from "../query/keys.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 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;
+	});
+	return (sdk, parameters, options) => family(new QueryAtomInput({
+		options,
+		parameters,
+		sdk
+	}));
+};
+
+//#endregion
+export { defaultQueryAtomOptions, makeQueryAtom };
+//# sourceMappingURL=query.js.map

package/dist/atoms/query.js.map

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

package/dist/atoms/records.d.ts

@@ -0,0 +1,93 @@
+import { EnsQueryAtomFactory } from "./query.js";
+import { EnsMutationAtomFactory } from "./mutation.js";
+//#region src/atoms/records.d.ts
+declare const getAbiAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAbiParameters, {
+  readonly contentType: "json" | "zlib-json" | "cbor";
+  readonly value: import("viem").Abi;
+  readonly raw: `0x${string}` & import("effect/Brand").Brand<"AbiRecordData">;
+} | {
+  readonly contentType: "uri";
+  readonly value: string;
+  readonly raw: `0x${string}` & import("effect/Brand").Brand<"AbiRecordData">;
+} | {
+  readonly contentType: null;
+  readonly value: null;
+  readonly raw: null;
+}, import("@ensforge/core").GetAbiError>;
+declare const getAddressAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAddressParameters, {
+  readonly coinType: bigint & import("effect/Brand").Brand<"CoinType">;
+  readonly address: string;
+  readonly raw: `0x${string}` & import("effect/Brand").Brand<"AddressRecordData">;
+} | {
+  readonly coinType: bigint & import("effect/Brand").Brand<"CoinType">;
+  readonly address: null;
+  readonly raw: null;
+}, import("@ensforge/core").GetAddressError>;
+declare const getAddressesAtom: EnsQueryAtomFactory<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">;
+} | {
+  readonly coinType: bigint & import("effect/Brand").Brand<"CoinType">;
+  readonly address: null;
+  readonly raw: null;
+})[], import("@ensforge/core").GetAddressError>;
+declare const getAvatarAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAvatarParameters, {
+  readonly status: "resolved";
+  readonly record: string;
+  readonly uri: string;
+} | {
+  readonly status: "unsupported-chain";
+  readonly record: string;
+  readonly chainId: number;
+} | null, import("@ensforge/core").GetAvatarError>;
+declare const getContentHashAtom: EnsQueryAtomFactory<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">;
+} | {
+  readonly protocol: null;
+  readonly value: null;
+  readonly raw: null;
+}, import("@ensforge/core").GetContentHashError>;
+declare const getDataAtom: EnsQueryAtomFactory<import("@ensforge/core").GetDataParameters, {
+  readonly key: string;
+  readonly value: `0x${string}` | null;
+}, import("@ensforge/core").GetDataError>;
+declare const getInterfaceAtom: EnsQueryAtomFactory<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, {
+  readonly name: string | null;
+}, import("@ensforge/core").GetNameError>;
+declare const getPubkeyAtom: EnsQueryAtomFactory<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, {
+  readonly key: string;
+  readonly value: string | null;
+}, import("@ensforge/core").GetTextError>;
+declare const getTextsAtom: EnsQueryAtomFactory<import("@ensforge/core").GetTextsParameters, readonly {
+  readonly key: string;
+  readonly value: string | null;
+}[], import("@ensforge/core").GetTextError>;
+declare const createClearAvatarMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ClearAvatarParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createClearRecordsMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ClearRecordsParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetAbiMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetAbiParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetAddressMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetAddressParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetAddressesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetAddressesParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetAliasMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetAliasParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetAvatarMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetAvatarParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetContentHashMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetContentHashParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetDataMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetDataParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+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 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
+export { createClearAvatarMutationAtom, createClearRecordsMutationAtom, createSetAbiMutationAtom, createSetAddressMutationAtom, createSetAddressesMutationAtom, createSetAliasMutationAtom, createSetAvatarMutationAtom, createSetContentHashMutationAtom, createSetDataMutationAtom, createSetInterfaceMutationAtom, createSetNameMutationAtom, createSetPubkeyMutationAtom, createSetRecordsMutationAtom, createSetTextMutationAtom, createSetTextsMutationAtom, getAbiAtom, getAddressAtom, getAddressesAtom, getAvatarAtom, getContentHashAtom, getDataAtom, getInterfaceAtom, getNameAtom, getPubkeyAtom, getTextAtom, getTextsAtom };
+//# sourceMappingURL=records.d.ts.map

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

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

package/dist/atoms/records.js

@@ -0,0 +1,34 @@
+import { makeMutationAtom } from "./mutation.js";
+import { makeQueryAtom } from "./query.js";
+
+//#region src/atoms/records.ts
+const getAbiAtom = makeQueryAtom("records", (sdk) => sdk.records.getAbi);
+const getAddressAtom = makeQueryAtom("records", (sdk) => sdk.records.getAddress);
+const getAddressesAtom = makeQueryAtom("records", (sdk) => sdk.records.getAddresses);
+const getAvatarAtom = makeQueryAtom("records", (sdk) => sdk.records.getAvatar);
+const getContentHashAtom = makeQueryAtom("records", (sdk) => sdk.records.getContentHash);
+const getDataAtom = makeQueryAtom("records", (sdk) => sdk.records.getData);
+const getInterfaceAtom = makeQueryAtom("records", (sdk) => sdk.records.getInterface);
+const getNameAtom = makeQueryAtom("records", (sdk) => sdk.records.getName);
+const getPubkeyAtom = makeQueryAtom("records", (sdk) => sdk.records.getPubkey);
+const getTextAtom = makeQueryAtom("records", (sdk) => sdk.records.getText);
+const getTextsAtom = makeQueryAtom("records", (sdk) => sdk.records.getTexts);
+const createClearAvatarMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.clearAvatar);
+const createClearRecordsMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.clearRecords);
+const createSetAbiMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setAbi);
+const createSetAddressMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setAddress);
+const createSetAddressesMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setAddresses);
+const createSetAliasMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setAlias);
+const createSetAvatarMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setAvatar);
+const createSetContentHashMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setContentHash);
+const createSetDataMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setData);
+const createSetInterfaceMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setInterface);
+const createSetNameMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setName);
+const createSetPubkeyMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setPubkey);
+const createSetRecordsMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setRecords);
+const createSetTextMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setText);
+const createSetTextsMutationAtom = makeMutationAtom("records", (sdk) => sdk.records.setTexts);
+
+//#endregion
+export { createClearAvatarMutationAtom, createClearRecordsMutationAtom, createSetAbiMutationAtom, createSetAddressMutationAtom, createSetAddressesMutationAtom, createSetAliasMutationAtom, createSetAvatarMutationAtom, createSetContentHashMutationAtom, createSetDataMutationAtom, createSetInterfaceMutationAtom, createSetNameMutationAtom, createSetPubkeyMutationAtom, createSetRecordsMutationAtom, createSetTextMutationAtom, createSetTextsMutationAtom, getAbiAtom, getAddressAtom, getAddressesAtom, getAvatarAtom, getContentHashAtom, getDataAtom, getInterfaceAtom, getNameAtom, getPubkeyAtom, getTextAtom, getTextsAtom };
+//# sourceMappingURL=records.js.map

package/dist/atoms/records.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.js","names":[],"sources":["../../src/atoms/records.ts"],"sourcesContent":["import { makeMutationAtom } from \"./mutation.js\";\nimport { makeQueryAtom } from \"./query.js\";\n\nexport const getAbiAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getAbi);\nexport const getAddressAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getAddress);\nexport const getAddressesAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getAddresses);\nexport const getAvatarAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getAvatar);\nexport const getContentHashAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getContentHash);\nexport const getDataAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getData);\nexport const getInterfaceAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getInterface);\nexport const getNameAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getName);\nexport const getPubkeyAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getPubkey);\nexport const getTextAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getText);\nexport const getTextsAtom = makeQueryAtom(\"records\", (sdk) => sdk.records.getTexts);\n\nexport const createClearAvatarMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.clearAvatar,\n);\nexport const createClearRecordsMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.clearRecords,\n);\nexport const createSetAbiMutationAtom = makeMutationAtom(\"records\", (sdk) => sdk.records.setAbi);\nexport const createSetAddressMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.setAddress,\n);\nexport const createSetAddressesMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.setAddresses,\n);\nexport const createSetAliasMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.setAlias,\n);\nexport const createSetAvatarMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.setAvatar,\n);\nexport const createSetContentHashMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.setContentHash,\n);\nexport const createSetDataMutationAtom = makeMutationAtom(\"records\", (sdk) => sdk.records.setData);\nexport const createSetInterfaceMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.setInterface,\n);\nexport const createSetNameMutationAtom = makeMutationAtom(\"records\", (sdk) => sdk.records.setName);\nexport const createSetPubkeyMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.setPubkey,\n);\nexport const createSetRecordsMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.setRecords,\n);\nexport const createSetTextMutationAtom = makeMutationAtom(\"records\", (sdk) => sdk.records.setText);\nexport const createSetTextsMutationAtom = makeMutationAtom(\n  \"records\",\n  (sdk) => sdk.records.setTexts,\n);\n"],"mappings":";;;;AAGA,MAAa,aAAa,cAAc,YAAY,QAAQ,IAAI,QAAQ,MAAM;AAC9E,MAAa,iBAAiB,cAAc,YAAY,QAAQ,IAAI,QAAQ,UAAU;AACtF,MAAa,mBAAmB,cAAc,YAAY,QAAQ,IAAI,QAAQ,YAAY;AAC1F,MAAa,gBAAgB,cAAc,YAAY,QAAQ,IAAI,QAAQ,SAAS;AACpF,MAAa,qBAAqB,cAAc,YAAY,QAAQ,IAAI,QAAQ,cAAc;AAC9F,MAAa,cAAc,cAAc,YAAY,QAAQ,IAAI,QAAQ,OAAO;AAChF,MAAa,mBAAmB,cAAc,YAAY,QAAQ,IAAI,QAAQ,YAAY;AAC1F,MAAa,cAAc,cAAc,YAAY,QAAQ,IAAI,QAAQ,OAAO;AAChF,MAAa,gBAAgB,cAAc,YAAY,QAAQ,IAAI,QAAQ,SAAS;AACpF,MAAa,cAAc,cAAc,YAAY,QAAQ,IAAI,QAAQ,OAAO;AAChF,MAAa,eAAe,cAAc,YAAY,QAAQ,IAAI,QAAQ,QAAQ;AAElF,MAAa,gCAAgC,iBAC3C,YACC,QAAQ,IAAI,QAAQ,WACvB;AACA,MAAa,iCAAiC,iBAC5C,YACC,QAAQ,IAAI,QAAQ,YACvB;AACA,MAAa,2BAA2B,iBAAiB,YAAY,QAAQ,IAAI,QAAQ,MAAM;AAC/F,MAAa,+BAA+B,iBAC1C,YACC,QAAQ,IAAI,QAAQ,UACvB;AACA,MAAa,iCAAiC,iBAC5C,YACC,QAAQ,IAAI,QAAQ,YACvB;AACA,MAAa,6BAA6B,iBACxC,YACC,QAAQ,IAAI,QAAQ,QACvB;AACA,MAAa,8BAA8B,iBACzC,YACC,QAAQ,IAAI,QAAQ,SACvB;AACA,MAAa,mCAAmC,iBAC9C,YACC,QAAQ,IAAI,QAAQ,cACvB;AACA,MAAa,4BAA4B,iBAAiB,YAAY,QAAQ,IAAI,QAAQ,OAAO;AACjG,MAAa,iCAAiC,iBAC5C,YACC,QAAQ,IAAI,QAAQ,YACvB;AACA,MAAa,4BAA4B,iBAAiB,YAAY,QAAQ,IAAI,QAAQ,OAAO;AACjG,MAAa,8BAA8B,iBACzC,YACC,QAAQ,IAAI,QAAQ,SACvB;AACA,MAAa,+BAA+B,iBAC1C,YACC,QAAQ,IAAI,QAAQ,UACvB;AACA,MAAa,4BAA4B,iBAAiB,YAAY,QAAQ,IAAI,QAAQ,OAAO;AACjG,MAAa,6BAA6B,iBACxC,YACC,QAAQ,IAAI,QAAQ,QACvB"}

package/dist/atoms/registration.d.ts

@@ -0,0 +1,253 @@
+import { EnsQueryAtomFactory } from "./query.js";
+import { EnsMutationAtomFactory } from "./mutation.js";
+//#region src/atoms/registration.d.ts
+declare const getCommitmentStatusAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCommitmentStatusParameters, {
+  readonly status: "not-found";
+  readonly protocol: "v1" | "v2";
+} | {
+  readonly status: "pending";
+  readonly protocol: "v1" | "v2";
+  readonly submittedAt: bigint;
+  readonly readyAt: bigint;
+  readonly expiresAt: bigint;
+  readonly remainingSeconds: bigint;
+} | {
+  readonly status: "ready";
+  readonly protocol: "v1" | "v2";
+  readonly submittedAt: bigint;
+  readonly readyAt: bigint;
+  readonly expiresAt: bigint;
+  readonly remainingSeconds: bigint;
+} | {
+  readonly status: "expired";
+  readonly protocol: "v1" | "v2";
+  readonly submittedAt: bigint;
+  readonly readyAt: bigint;
+  readonly expiresAt: bigint;
+}, import("@ensforge/core").GetCommitmentStatusError>;
+declare const getRegistrationParametersAtom: EnsQueryAtomFactory<import("@ensforge/core").BlockParameters, {
+  readonly protocol: "v1";
+  readonly registrar: `0x${string}`;
+  readonly priceOracle: `0x${string}`;
+  readonly minimumRegistrationDuration: bigint;
+  readonly minimumRenewalDuration: bigint;
+  readonly minimumCommitmentAge: bigint;
+  readonly maximumCommitmentAge: bigint;
+  readonly payment: {
+    readonly kind: "native";
+  };
+} | {
+  readonly protocol: "v2";
+  readonly registrar: `0x${string}`;
+  readonly priceOracle: `0x${string}`;
+  readonly minimumRegistrationDuration: bigint;
+  readonly minimumRenewalDuration: bigint;
+  readonly minimumCommitmentAge: bigint;
+  readonly maximumCommitmentAge: bigint;
+  readonly payment: {
+    readonly kind: "erc20";
+    readonly enumerable: false;
+  };
+}, import("@ensforge/core").GetCommitmentStatusError>;
+declare const getRegistrationPlanAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistrationPlanParameters, {
+  readonly status: "unavailable";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+} | {
+  readonly status: "payment-token-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+} | {
+  readonly status: "unsupported-payment-token";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly paymentToken: `0x${string}`;
+} | {
+  readonly status: "ready" | "commitment-required" | "commitment-pending" | "commitment-expired";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly parameters: {
+    readonly protocol: "v1";
+    readonly registrar: `0x${string}`;
+    readonly priceOracle: `0x${string}`;
+    readonly minimumRegistrationDuration: bigint;
+    readonly minimumRenewalDuration: bigint;
+    readonly minimumCommitmentAge: bigint;
+    readonly maximumCommitmentAge: bigint;
+    readonly payment: {
+      readonly kind: "native";
+    };
+  } | {
+    readonly protocol: "v2";
+    readonly registrar: `0x${string}`;
+    readonly priceOracle: `0x${string}`;
+    readonly minimumRegistrationDuration: bigint;
+    readonly minimumRenewalDuration: bigint;
+    readonly minimumCommitmentAge: bigint;
+    readonly maximumCommitmentAge: bigint;
+    readonly payment: {
+      readonly kind: "erc20";
+      readonly enumerable: false;
+    };
+  };
+  readonly price: {
+    readonly status: "available";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly registrar: `0x${string}`;
+    readonly duration: bigint;
+    readonly base: bigint;
+    readonly premium: bigint;
+    readonly total: bigint;
+    readonly currency: {
+      readonly kind: "native";
+      readonly symbol: "ETH";
+      readonly decimals: 18;
+    } | {
+      readonly kind: "erc20";
+      readonly address: `0x${string}`;
+      readonly symbol: string;
+      readonly decimals: number;
+    };
+  } | {
+    readonly status: "unavailable";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "NAME_UNAVAILABLE";
+  } | {
+    readonly status: "payment-token-required";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+  } | {
+    readonly status: "unsupported-payment-token";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly paymentToken: `0x${string}`;
+  };
+  readonly commitment: {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly protocol: "v1" | "v2";
+    readonly registrar: `0x${string}`;
+    readonly commitment: `0x${string}`;
+  };
+  readonly commitmentStatus: {
+    readonly status: "not-found";
+    readonly protocol: "v1" | "v2";
+  } | {
+    readonly status: "pending";
+    readonly protocol: "v1" | "v2";
+    readonly submittedAt: bigint;
+    readonly readyAt: bigint;
+    readonly expiresAt: bigint;
+    readonly remainingSeconds: bigint;
+  } | {
+    readonly status: "ready";
+    readonly protocol: "v1" | "v2";
+    readonly submittedAt: bigint;
+    readonly readyAt: bigint;
+    readonly expiresAt: bigint;
+    readonly remainingSeconds: bigint;
+  } | {
+    readonly status: "expired";
+    readonly protocol: "v1" | "v2";
+    readonly submittedAt: bigint;
+    readonly readyAt: bigint;
+    readonly expiresAt: bigint;
+  };
+}, import("@ensforge/core").GetCommitmentStatusError>;
+declare const getRegistrationPriceAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistrationPriceParameters, {
+  readonly status: "available";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly protocol: "v1" | "v2";
+  readonly registrar: `0x${string}`;
+  readonly duration: bigint;
+  readonly base: bigint;
+  readonly premium: bigint;
+  readonly total: bigint;
+  readonly currency: {
+    readonly kind: "native";
+    readonly symbol: "ETH";
+    readonly decimals: 18;
+  } | {
+    readonly kind: "erc20";
+    readonly address: `0x${string}`;
+    readonly symbol: string;
+    readonly decimals: number;
+  };
+} | {
+  readonly status: "unavailable";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly protocol: "v1" | "v2";
+  readonly reason: "NAME_UNAVAILABLE";
+} | {
+  readonly status: "payment-token-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly protocol: "v1" | "v2";
+} | {
+  readonly status: "unsupported-payment-token";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly protocol: "v1" | "v2";
+  readonly paymentToken: `0x${string}`;
+}, import("@ensforge/core").GetCommitmentStatusError>;
+declare const getRenewalPriceAtom: EnsQueryAtomFactory<import("@ensforge/core").GetRegistrationPriceParameters, {
+  readonly status: "payment-token-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly protocol: "v1" | "v2";
+} | {
+  readonly status: "unsupported-payment-token";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly protocol: "v1" | "v2";
+  readonly paymentToken: `0x${string}`;
+} | {
+  readonly status: "renewable";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly protocol: "v1" | "v2";
+  readonly route: "v1-controller" | "v2-registrar" | "v1-renewer";
+  readonly renewer: `0x${string}`;
+  readonly duration: bigint;
+  readonly price: bigint;
+  readonly currency: {
+    readonly kind: "native";
+    readonly symbol: "ETH";
+    readonly decimals: 18;
+  } | {
+    readonly kind: "erc20";
+    readonly address: `0x${string}`;
+    readonly symbol: string;
+    readonly decimals: number;
+  };
+} | {
+  readonly status: "not-renewable";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly protocol: "v1" | "v2";
+  readonly reason: "NAME_NOT_RENEWABLE";
+}, import("@ensforge/core").GetCommitmentStatusError>;
+declare const isPaymentTokenSupportedAtom: EnsQueryAtomFactory<import("@ensforge/core").IsPaymentTokenSupportedParameters, {
+  readonly protocol: "v1";
+  readonly supported: false;
+  readonly reason: "NATIVE_PAYMENT_ONLY";
+} | {
+  readonly protocol: "v2";
+  readonly supported: false;
+  readonly token: `0x${string}`;
+  readonly reason: "PAYMENT_TOKEN_NOT_SUPPORTED";
+} | {
+  readonly protocol: "v2";
+  readonly supported: true;
+  readonly token: `0x${string}`;
+  readonly symbol: string;
+  readonly decimals: number;
+}, import("@ensforge/core").GetCommitmentStatusError>;
+declare const makeRegistrationCommitmentAtom: EnsQueryAtomFactory<import("@ensforge/core").MakeRegistrationCommitmentParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly protocol: "v1" | "v2";
+  readonly registrar: `0x${string}`;
+  readonly commitment: `0x${string}`;
+}, import("@ensforge/core").GetCommitmentStatusError>;
+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 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 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 };
+//# sourceMappingURL=registration.d.ts.map

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

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

package/dist/atoms/registration.js

@@ -0,0 +1,23 @@
+import { makeMutationAtom } from "./mutation.js";
+import { makeQueryAtom } from "./query.js";
+
+//#region src/atoms/registration.ts
+const getCommitmentStatusAtom = makeQueryAtom("registration", (sdk) => sdk.registration.getCommitmentStatus);
+const getRegistrationParametersAtom = makeQueryAtom("registration", (sdk) => sdk.registration.getRegistrationParameters);
+const getRegistrationPlanAtom = makeQueryAtom("registration", (sdk) => sdk.registration.getRegistrationPlan);
+const getRegistrationPriceAtom = makeQueryAtom("registration", (sdk) => sdk.registration.getRegistrationPrice);
+const getRenewalPriceAtom = makeQueryAtom("registration", (sdk) => sdk.registration.getRenewalPrice);
+const isPaymentTokenSupportedAtom = makeQueryAtom("registration", (sdk) => sdk.registration.isPaymentTokenSupported);
+const makeRegistrationCommitmentAtom = makeQueryAtom("registration", (sdk) => sdk.registration.makeRegistrationCommitment);
+const createApprovePaymentTokenMutationAtom = makeMutationAtom("registration", (sdk) => sdk.registration.approvePaymentToken);
+const createApproveRenewalPaymentMutationAtom = makeMutationAtom("registration", (sdk) => sdk.registration.approveRenewalPayment);
+const createCommitNameMutationAtom = makeMutationAtom("registration", (sdk) => sdk.registration.commitName);
+const createCompleteRegistrationMutationAtom = makeMutationAtom("registration", (sdk) => sdk.registration.completeRegistration);
+const createRegisterNameMutationAtom = makeMutationAtom("registration", (sdk) => sdk.registration.registerName);
+const createRegisterNamesMutationAtom = makeMutationAtom("registration", (sdk) => sdk.registration.registerNames);
+const createRenewNameMutationAtom = makeMutationAtom("registration", (sdk) => sdk.registration.renewName);
+const createRenewNamesMutationAtom = makeMutationAtom("registration", (sdk) => sdk.registration.renewNames);
+
+//#endregion
+export { createApprovePaymentTokenMutationAtom, createApproveRenewalPaymentMutationAtom, createCommitNameMutationAtom, createCompleteRegistrationMutationAtom, createRegisterNameMutationAtom, createRegisterNamesMutationAtom, createRenewNameMutationAtom, createRenewNamesMutationAtom, getCommitmentStatusAtom, getRegistrationParametersAtom, getRegistrationPlanAtom, getRegistrationPriceAtom, getRenewalPriceAtom, isPaymentTokenSupportedAtom, makeRegistrationCommitmentAtom };
+//# sourceMappingURL=registration.js.map

package/dist/atoms/registration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration.js","names":[],"sources":["../../src/atoms/registration.ts"],"sourcesContent":["import { makeMutationAtom } from \"./mutation.js\";\nimport { makeQueryAtom } from \"./query.js\";\n\nexport const getCommitmentStatusAtom = makeQueryAtom(\n  \"registration\",\n  (sdk) => sdk.registration.getCommitmentStatus,\n);\nexport const getRegistrationParametersAtom = makeQueryAtom(\n  \"registration\",\n  (sdk) => sdk.registration.getRegistrationParameters,\n);\nexport const getRegistrationPlanAtom = makeQueryAtom(\n  \"registration\",\n  (sdk) => sdk.registration.getRegistrationPlan,\n);\nexport const getRegistrationPriceAtom = makeQueryAtom(\n  \"registration\",\n  (sdk) => sdk.registration.getRegistrationPrice,\n);\nexport const getRenewalPriceAtom = makeQueryAtom(\n  \"registration\",\n  (sdk) => sdk.registration.getRenewalPrice,\n);\nexport const isPaymentTokenSupportedAtom = makeQueryAtom(\n  \"registration\",\n  (sdk) => sdk.registration.isPaymentTokenSupported,\n);\nexport const makeRegistrationCommitmentAtom = makeQueryAtom(\n  \"registration\",\n  (sdk) => sdk.registration.makeRegistrationCommitment,\n);\n\nexport const createApprovePaymentTokenMutationAtom = makeMutationAtom(\n  \"registration\",\n  (sdk) => sdk.registration.approvePaymentToken,\n);\nexport const createApproveRenewalPaymentMutationAtom = makeMutationAtom(\n  \"registration\",\n  (sdk) => sdk.registration.approveRenewalPayment,\n);\nexport const createCommitNameMutationAtom = makeMutationAtom(\n  \"registration\",\n  (sdk) => sdk.registration.commitName,\n);\nexport const createCompleteRegistrationMutationAtom = makeMutationAtom(\n  \"registration\",\n  (sdk) => sdk.registration.completeRegistration,\n);\nexport const createRegisterNameMutationAtom = makeMutationAtom(\n  \"registration\",\n  (sdk) => sdk.registration.registerName,\n);\nexport const createRegisterNamesMutationAtom = makeMutationAtom(\n  \"registration\",\n  (sdk) => sdk.registration.registerNames,\n);\nexport const createRenewNameMutationAtom = makeMutationAtom(\n  \"registration\",\n  (sdk) => sdk.registration.renewName,\n);\nexport const createRenewNamesMutationAtom = makeMutationAtom(\n  \"registration\",\n  (sdk) => sdk.registration.renewNames,\n);\n"],"mappings":";;;;AAGA,MAAa,0BAA0B,cACrC,iBACC,QAAQ,IAAI,aAAa,mBAC5B;AACA,MAAa,gCAAgC,cAC3C,iBACC,QAAQ,IAAI,aAAa,yBAC5B;AACA,MAAa,0BAA0B,cACrC,iBACC,QAAQ,IAAI,aAAa,mBAC5B;AACA,MAAa,2BAA2B,cACtC,iBACC,QAAQ,IAAI,aAAa,oBAC5B;AACA,MAAa,sBAAsB,cACjC,iBACC,QAAQ,IAAI,aAAa,eAC5B;AACA,MAAa,8BAA8B,cACzC,iBACC,QAAQ,IAAI,aAAa,uBAC5B;AACA,MAAa,iCAAiC,cAC5C,iBACC,QAAQ,IAAI,aAAa,0BAC5B;AAEA,MAAa,wCAAwC,iBACnD,iBACC,QAAQ,IAAI,aAAa,mBAC5B;AACA,MAAa,0CAA0C,iBACrD,iBACC,QAAQ,IAAI,aAAa,qBAC5B;AACA,MAAa,+BAA+B,iBAC1C,iBACC,QAAQ,IAAI,aAAa,UAC5B;AACA,MAAa,yCAAyC,iBACpD,iBACC,QAAQ,IAAI,aAAa,oBAC5B;AACA,MAAa,iCAAiC,iBAC5C,iBACC,QAAQ,IAAI,aAAa,YAC5B;AACA,MAAa,kCAAkC,iBAC7C,iBACC,QAAQ,IAAI,aAAa,aAC5B;AACA,MAAa,8BAA8B,iBACzC,iBACC,QAAQ,IAAI,aAAa,SAC5B;AACA,MAAa,+BAA+B,iBAC1C,iBACC,QAAQ,IAAI,aAAa,UAC5B"}

package/dist/atoms/resolution.d.ts

@@ -0,0 +1,45 @@
+import { EnsQueryAtomFactory } from "./query.js";
+import { EnsMutationAtomFactory } from "./mutation.js";
+//#region src/atoms/resolution.d.ts
+declare const getAliasAtom: EnsQueryAtomFactory<import("@ensforge/core").GetAliasParameters, {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly reason: "RESOLVER_NOT_FOUND" | "ALIASING_UNSUPPORTED";
+} | {
+  readonly supported: true;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}`;
+  readonly target: (string & import("effect/Brand").Brand<"NormalizedName">) | null;
+  readonly raw: `0x${string}`;
+}, 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, {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly reason: "RESOLVER_NOT_FOUND" | "VERSIONING_UNSUPPORTED";
+} | {
+  readonly supported: true;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}`;
+  readonly version: bigint;
+}, 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, {
+  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, {
+  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 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>;
+//#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

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