@ensforge/core 0.0.0

package/dist/actions/events/watch-ens-events/index.js

@@ -0,0 +1,59 @@
+import { viemErrorToEffectError } from "../../../internal/errors/viem-error.js";
+import { normalizeName } from "../../../names/normalize.js";
+import { getEnsEventContracts } from "../../../internal/events/contracts.js";
+import { matchesEnsEventFilters, normalizeEnsLog } from "../../../internal/events/normalize-event.js";
+import { Cause, Effect, Queue, Stream } from "effect";
+
+//#region src/actions/events/watch-ens-events/index.ts
+const stream = (config, parameters) => {
+	const normalizedNameEffect = parameters.name === void 0 ? Effect.succeed(void 0) : normalizeName.effect(parameters.name).pipe(Effect.map((name) => name));
+	return Stream.unwrap(normalizedNameEffect.pipe(Effect.map((normalizedName) => {
+		const contracts = getEnsEventContracts(config.deployments);
+		return Stream.callback(Effect.fn("ensforge.watchEnsEvents.stream")(function* (queue) {
+			yield* Effect.acquireRelease(Effect.sync(() => config.publicClient.watchEvent({
+				address: contracts.map((contract) => contract.address),
+				...parameters.fromBlock === void 0 ? {} : { fromBlock: parameters.fromBlock },
+				...parameters.pollingInterval === void 0 ? {} : { pollingInterval: parameters.pollingInterval },
+				onLogs: (logs) => {
+					for (const log of logs) {
+						const event = normalizeEnsLog(log, contracts);
+						if (event !== null && matchesEnsEventFilters(event, {
+							...parameters,
+							fromBlock: parameters.fromBlock ?? 0n
+						}, normalizedName)) Queue.offerUnsafe(queue, event);
+					}
+				},
+				onError: (cause) => Queue.failCauseUnsafe(queue, Cause.fail(viemErrorToEffectError(cause, "watchEvent")))
+			})), (unwatch) => Effect.sync(unwatch));
+		}));
+	})));
+};
+const watch = async (config, parameters, onEvent, onError) => {
+	const normalizedName = parameters.name === void 0 ? void 0 : await Effect.runPromise(normalizeName.effect(parameters.name));
+	const contracts = getEnsEventContracts(config.deployments);
+	return config.publicClient.watchEvent({
+		address: contracts.map((contract) => contract.address),
+		...parameters.fromBlock === void 0 ? {} : { fromBlock: parameters.fromBlock },
+		...parameters.pollingInterval === void 0 ? {} : { pollingInterval: parameters.pollingInterval },
+		onLogs: (logs) => {
+			for (const log of logs) {
+				const event = normalizeEnsLog(log, contracts);
+				if (event !== null && matchesEnsEventFilters(event, {
+					...parameters,
+					fromBlock: parameters.fromBlock ?? 0n
+				}, normalizedName)) onEvent(event);
+			}
+		},
+		onError: (cause) => onError(viemErrorToEffectError(cause, "watchEvent"))
+	});
+};
+const watchEnsEvents = Object.freeze(Object.defineProperty(watch, "stream", {
+	value: stream,
+	enumerable: true,
+	configurable: false,
+	writable: false
+}));
+
+//#endregion
+export { watchEnsEvents };
+//# sourceMappingURL=index.js.map

package/dist/actions/events/watch-ens-events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/actions/events/watch-ens-events/index.ts"],"sourcesContent":["import { Cause, Effect, Queue, Stream } from \"effect\";\n\nimport type { EnsforgeConfig } from \"../../../config/config.js\";\nimport type { NameError } from \"../../../errors/name-error.js\";\nimport { viemErrorToEffectError } from \"../../../internal/errors/viem-error.js\";\nimport { getEnsEventContracts } from \"../../../internal/events/contracts.js\";\nimport {\n  matchesEnsEventFilters,\n  normalizeEnsLog,\n} from \"../../../internal/events/normalize-event.js\";\nimport { normalizeName } from \"../../../names/normalize.js\";\nimport type { NormalizedName } from \"../../../schemas/name.js\";\nimport type { EnsEvent, EnsEventError, WatchEnsEventsParameters } from \"../types.js\";\n\nexport interface WatchEnsEvents {\n  (\n    config: EnsforgeConfig,\n    parameters: WatchEnsEventsParameters,\n    onEvent: (event: EnsEvent) => void,\n    onError: (error: EnsEventError) => void,\n  ): Promise<() => void>;\n  readonly stream: (\n    config: EnsforgeConfig,\n    parameters: WatchEnsEventsParameters,\n  ) => Stream.Stream<EnsEvent, EnsEventError>;\n}\n\nconst stream = (\n  config: EnsforgeConfig,\n  parameters: WatchEnsEventsParameters,\n): Stream.Stream<EnsEvent, EnsEventError> => {\n  const normalizedNameEffect: Effect.Effect<NormalizedName | undefined, NameError> =\n    parameters.name === undefined\n      ? Effect.succeed<NormalizedName | undefined>(undefined)\n      : normalizeName\n          .effect(parameters.name)\n          .pipe(Effect.map((name): NormalizedName | undefined => name));\n  return Stream.unwrap(\n    normalizedNameEffect.pipe(\n      Effect.map((normalizedName) => {\n        const contracts = getEnsEventContracts(config.deployments);\n        return Stream.callback<EnsEvent, EnsEventError>(\n          Effect.fn(\"ensforge.watchEnsEvents.stream\")(function* (queue) {\n            yield* Effect.acquireRelease(\n              Effect.sync(() =>\n                config.publicClient.watchEvent({\n                  address: contracts.map((contract) => contract.address),\n                  ...(parameters.fromBlock === undefined\n                    ? {}\n                    : { fromBlock: parameters.fromBlock }),\n                  ...(parameters.pollingInterval === undefined\n                    ? {}\n                    : { pollingInterval: parameters.pollingInterval }),\n                  onLogs: (logs) => {\n                    for (const log of logs) {\n                      const event = normalizeEnsLog(log, contracts);\n                      if (\n                        event !== null &&\n                        matchesEnsEventFilters(\n                          event,\n                          { ...parameters, fromBlock: parameters.fromBlock ?? 0n },\n                          normalizedName,\n                        )\n                      ) {\n                        Queue.offerUnsafe(queue, event);\n                      }\n                    }\n                  },\n                  onError: (cause) =>\n                    Queue.failCauseUnsafe(\n                      queue,\n                      Cause.fail(viemErrorToEffectError(cause, \"watchEvent\")),\n                    ),\n                }),\n              ),\n              (unwatch) => Effect.sync(unwatch),\n            );\n          }),\n        );\n      }),\n    ),\n  );\n};\n\nconst watch = async (\n  config: EnsforgeConfig,\n  parameters: WatchEnsEventsParameters,\n  onEvent: (event: EnsEvent) => void,\n  onError: (error: EnsEventError) => void,\n): Promise<() => void> => {\n  const normalizedName =\n    parameters.name === undefined\n      ? undefined\n      : await Effect.runPromise(normalizeName.effect(parameters.name));\n  const contracts = getEnsEventContracts(config.deployments);\n  return config.publicClient.watchEvent({\n    address: contracts.map((contract) => contract.address),\n    ...(parameters.fromBlock === undefined ? {} : { fromBlock: parameters.fromBlock }),\n    ...(parameters.pollingInterval === undefined\n      ? {}\n      : { pollingInterval: parameters.pollingInterval }),\n    onLogs: (logs) => {\n      for (const log of logs) {\n        const event = normalizeEnsLog(log, contracts);\n        if (\n          event !== null &&\n          matchesEnsEventFilters(\n            event,\n            { ...parameters, fromBlock: parameters.fromBlock ?? 0n },\n            normalizedName,\n          )\n        ) {\n          onEvent(event);\n        }\n      }\n    },\n    onError: (cause) => onError(viemErrorToEffectError(cause, \"watchEvent\")),\n  });\n};\n\nexport const watchEnsEvents = Object.freeze(\n  Object.defineProperty(watch, \"stream\", {\n    value: stream,\n    enumerable: true,\n    configurable: false,\n    writable: false,\n  }),\n) as WatchEnsEvents;\n\nexport type {\n  EnsEvent,\n  EnsEventError as WatchEnsEventsError,\n  WatchEnsEventsParameters,\n} from \"../types.js\";\n"],"mappings":";;;;;;;AA2BA,MAAM,UACJ,QACA,eAC2C;CAC3C,MAAM,uBACJ,WAAW,SAAS,SAChB,OAAO,QAAoC,MAAS,IACpD,cACG,OAAO,WAAW,IAAI,CAAC,CACvB,KAAK,OAAO,KAAK,SAAqC,IAAI,CAAC;CACpE,OAAO,OAAO,OACZ,qBAAqB,KACnB,OAAO,KAAK,mBAAmB;EAC7B,MAAM,YAAY,qBAAqB,OAAO,WAAW;EACzD,OAAO,OAAO,SACZ,OAAO,GAAG,gCAAgC,CAAC,CAAC,WAAW,OAAO;GAC5D,OAAO,OAAO,eACZ,OAAO,WACL,OAAO,aAAa,WAAW;IAC7B,SAAS,UAAU,KAAK,aAAa,SAAS,OAAO;IACrD,GAAI,WAAW,cAAc,SACzB,CAAC,IACD,EAAE,WAAW,WAAW,UAAU;IACtC,GAAI,WAAW,oBAAoB,SAC/B,CAAC,IACD,EAAE,iBAAiB,WAAW,gBAAgB;IAClD,SAAS,SAAS;KAChB,KAAK,MAAM,OAAO,MAAM;MACtB,MAAM,QAAQ,gBAAgB,KAAK,SAAS;MAC5C,IACE,UAAU,QACV,uBACE,OACA;OAAE,GAAG;OAAY,WAAW,WAAW,aAAa;MAAG,GACvD,cACF,GAEA,MAAM,YAAY,OAAO,KAAK;KAElC;IACF;IACA,UAAU,UACR,MAAM,gBACJ,OACA,MAAM,KAAK,uBAAuB,OAAO,YAAY,CAAC,CACxD;GACJ,CAAC,CACH,IACC,YAAY,OAAO,KAAK,OAAO,CAClC;EACF,CAAC,CACH;CACF,CAAC,CACH,CACF;AACF;AAEA,MAAM,QAAQ,OACZ,QACA,YACA,SACA,YACwB;CACxB,MAAM,iBACJ,WAAW,SAAS,SAChB,SACA,MAAM,OAAO,WAAW,cAAc,OAAO,WAAW,IAAI,CAAC;CACnE,MAAM,YAAY,qBAAqB,OAAO,WAAW;CACzD,OAAO,OAAO,aAAa,WAAW;EACpC,SAAS,UAAU,KAAK,aAAa,SAAS,OAAO;EACrD,GAAI,WAAW,cAAc,SAAY,CAAC,IAAI,EAAE,WAAW,WAAW,UAAU;EAChF,GAAI,WAAW,oBAAoB,SAC/B,CAAC,IACD,EAAE,iBAAiB,WAAW,gBAAgB;EAClD,SAAS,SAAS;GAChB,KAAK,MAAM,OAAO,MAAM;IACtB,MAAM,QAAQ,gBAAgB,KAAK,SAAS;IAC5C,IACE,UAAU,QACV,uBACE,OACA;KAAE,GAAG;KAAY,WAAW,WAAW,aAAa;IAAG,GACvD,cACF,GAEA,QAAQ,KAAK;GAEjB;EACF;EACA,UAAU,UAAU,QAAQ,uBAAuB,OAAO,YAAY,CAAC;CACzE,CAAC;AACH;AAEA,MAAa,iBAAiB,OAAO,OACnC,OAAO,eAAe,OAAO,UAAU;CACrC,OAAO;CACP,YAAY;CACZ,cAAc;CACd,UAAU;AACZ,CAAC,CACH"}

package/dist/actions/index.d.ts

@@ -0,0 +1,199 @@
+import { ReadBatch, ReadBatchError, ReadBatchOptions, ReadBatchOutcome, ReadBatchResult, ReadBatchSettled, ReadBatchSettledResult, readBatch, readBatchSettled } from "./batch/read-batch.js";
+import { executeWritePlan } from "./batch/execute-write-plan.js";
+import { estimateCalls } from "./batch/estimate-calls.js";
+import { getWalletCapabilities } from "./batch/get-wallet-capabilities.js";
+import { getCallsStatus } from "./batch/get-calls-status.js";
+import { prepareCalls } from "./batch/prepare-calls.js";
+import { sendCalls } from "./batch/send-calls.js";
+import { resumeCalls } from "./batch/resume-calls.js";
+import { simulateCalls } from "./batch/simulate-calls.js";
+import "./batch/index.js";
+import { AvailableNameState, GetNameStateError, GetNameStateParameters, NameState, NameStatus, V1UnwrappedNameState, V1WrappedNameState, V2MigratedNameState, V2NativeNameState, V2ReservedNameState } from "./name/get-name-state/types.js";
+import { AccountCapabilityParameters, AuthorizationDecision, AuthorizationRequirement, AuthorizationSource, CapabilityError, HasRegistryRolesResult, HasResolverRolesResult, NameCapabilities, NameCapabilityParameters, OperatorApprovalResult, OperatorApprovalTarget, RecordOperation, RecordPermission, RecordPermissionsResult, RegistryCapabilities, RegistryOperation, RegistryRolesResult, RequiredAuthorizationResult, ResolverCapabilities, ResolverDelegateApprovalResult, ResolverProfiles, ResolverRolesResult, TokenApprovalResult, WrapperPermissionsResult, WriteOperation, WriteTarget } from "./capabilities/types.js";
+import { GetNameCapabilitiesParameters, getNameCapabilities } from "./capabilities/get-name-capabilities/index.js";
+import { getRegistryCapabilities } from "./capabilities/get-registry-capabilities/index.js";
+import { getRegistryRoles } from "./capabilities/get-registry-roles/index.js";
+import { GetRecordPermissionsParameters, getRecordPermissions } from "./capabilities/get-record-permissions/index.js";
+import { GetRequiredAuthorizationParameters, getRequiredAuthorization } from "./capabilities/get-required-authorization/index.js";
+import { GetOperatorApprovalParameters, getOperatorApproval } from "./capabilities/get-operator-approval/index.js";
+import { getResolverCapabilities } from "./capabilities/get-resolver-capabilities/index.js";
+import { GetResolverDelegateApprovalParameters, getResolverDelegateApproval } from "./capabilities/get-resolver-delegate-approval/index.js";
+import { GetResolverRolesParameters, getResolverRoles } from "./capabilities/get-resolver-roles/index.js";
+import { getTokenApproval } from "./capabilities/get-token-approval/index.js";
+import { getWrapperPermissions } from "./capabilities/get-wrapper-permissions/index.js";
+import { GetWriteTargetParameters, getWriteTarget } from "./capabilities/get-write-target/index.js";
+import { HasRegistryRolesParameters, hasRegistryRoles } from "./capabilities/has-registry-roles/index.js";
+import { HasResolverRolesParameters, hasResolverRoles } from "./capabilities/has-resolver-roles/index.js";
+import "./capabilities/index.js";
+import { ClaimDnsNameError, ClaimDnsNameIntent, ClaimDnsNameParameters, ClaimDnsNameResult, DnsClaimStatus, DnsImportPlan, DnsReadError, DnsRecordQuery, DnsRecordResult, DnsRecordsExistence, DnsRecordsResult, DnsResource, DnssecProof, DnssecProofChain, GetDnsRecordParameters, GetDnsRecordsParameters, ImportDnsNameError, ImportDnsNameParameters, ImportDnsNameResult, ZoneHashResult } from "./dns/types.js";
+import { claimDnsName } from "./dns/claim-dns-name/index.js";
+import { importDnsName } from "./dns/import-dns-name/index.js";
+import { SetDnsRecordsError, SetDnsRecordsParameters, SetDnsRecordsResult } from "./dns/set-dns-records/types.js";
+import { setDnsRecords } from "./dns/set-dns-records/index.js";
+import { SetZoneHashError, SetZoneHashParameters, SetZoneHashResult } from "./dns/set-zone-hash/types.js";
+import { setZoneHash } from "./dns/set-zone-hash/index.js";
+import { GetDnsClaimStatusParameters, getDnsClaimStatus } from "./dns/get-dns-claim-status/index.js";
+import { GetDnsImportPlanParameters, getDnsImportPlan } from "./dns/get-dns-import-plan/index.js";
+import { getDnsRecord } from "./dns/get-dns-record/index.js";
+import { getDnsRecords } from "./dns/get-dns-records/index.js";
+import { GetZoneHashParameters, getZoneHash } from "./dns/get-zone-hash/index.js";
+import { HasDnsRecordsParameters, hasDnsRecords } from "./dns/has-dns-records/index.js";
+import "./dns/index.js";
+import { EnsEvent, EnsEventContractKind, EnsEventError, EnsEventKind, GetEnsEventsParameters, GetNameHistoryParameters, NameHistory, WatchEnsEventsParameters } from "./events/types.js";
+import { getEnsEvents } from "./events/get-ens-events/index.js";
+import { getNameHistory } from "./events/get-name-history/index.js";
+import { WatchEnsEvents, watchEnsEvents } from "./events/watch-ens-events/index.js";
+import "./events/index.js";
+import { ApproveMigrationParameters, ApproveMigrationResult, MigrateNameAction, MigrateNameCallParameters, MigrateNameParameters, MigrateNameResult, MigrateNamesParameters, MigrationBatchApproval, MigrationBatchEntry, MigrationBatchProgress, MigrationBlocker, MigrationEligibility, MigrationNameParameters, MigrationNameProgress, MigrationPlan, MigrationReadError, MigrationStatus, MigrationTarget, MigrationUnsupportedReason, MigrationValues, MigrationWalletParameters, MigrationWriteError } from "./migration/types.js";
+import { GetMigrationEligibilityParameters, getMigrationEligibility } from "./migration/get-migration-eligibility/index.js";
+import { GetMigrationPlanParameters, getMigrationPlan } from "./migration/get-migration-plan/index.js";
+import { getMigrationStatus } from "./migration/get-migration-status/index.js";
+import { getMigrationTarget } from "./migration/get-migration-target/index.js";
+import { migrateName } from "./migration/migrate-name/index.js";
+import { migrateNames } from "./migration/migrate-names/index.js";
+import { approveMigration } from "./migration/mutation.js";
+import "./migration/index.js";
+import { ExpiryResult, ExpirySource, GetExpiryError, GetExpiryParameters } from "./name/get-expiry/types.js";
+import { getExpiry } from "./name/get-expiry/index.js";
+import { GetCanonicalResourceResult, getCanonicalResource } from "./name/get-canonical-resource/index.js";
+import { GetManagerResult, getManager } from "./name/get-manager/index.js";
+import { getNameState } from "./name/get-name-state/index.js";
+import { getNameStatus } from "./name/get-name-status/index.js";
+import { GetOwnerError, GetOwnerParameters, OwnerResult, OwnershipLevel } from "./name/get-owner/types.js";
+import { getOwner } from "./name/get-owner/index.js";
+import { GetRegistrantResult, getRegistrant } from "./name/get-registrant/index.js";
+import { GetProtocolResult, getProtocol } from "./name/get-protocol/index.js";
+import { GetRegistryResult, getRegistry } from "./name/get-registry/index.js";
+import { GetTokenIdResult, getTokenId } from "./name/get-token-id/index.js";
+import { isAvailable } from "./name/is-available/index.js";
+import { isMigrated } from "./name/is-migrated/index.js";
+import { isRenewable } from "./name/is-renewable/index.js";
+import { isReserved } from "./name/is-reserved/index.js";
+import { isWrapped } from "./name/is-wrapped/index.js";
+import "./name/index.js";
+import { OwnershipWriteError, OwnershipWriteResult, ReclaimNameParameters, SetManagerParameters, SetTtlParameters, TransferNameError, TransferNameParameters, TransferNameProgress, TransferNameResult, TransferNameStrategy, TransferRegistrantParameters, TtlResult } from "./ownership/types.js";
+import { getTtl } from "./ownership/get-ttl/index.js";
+import { reclaimName } from "./ownership/reclaim-name/index.js";
+import { setManager } from "./ownership/set-manager/index.js";
+import { setTtl } from "./ownership/set-ttl/index.js";
+import { transferName } from "./ownership/transfer-name/index.js";
+import { transferRegistrant } from "./ownership/transfer-registrant/index.js";
+import "./ownership/index.js";
+import { ApproveNameError, ApproveNameIntent, ApproveNameParameters, ApproveNameResult, ClearNameApprovalError, ClearNameApprovalIntent, ClearNameApprovalParameters, ClearNameApprovalResult } from "./permissions/name-approval/types.js";
+import { approveName, clearNameApproval } from "./permissions/name-approval/index.js";
+import { OperatorApprovalKind, SetOperatorApprovalError, SetOperatorApprovalIntent, SetOperatorApprovalParameters, SetOperatorApprovalResult } from "./permissions/operator-approval/types.js";
+import { setOperatorApproval } from "./permissions/operator-approval/index.js";
+import { GrantRegistryRolesError, GrantRegistryRolesIntent, GrantRegistryRolesParameters, GrantRegistryRolesResult, RegistryRolesMutationParameters, RevokeRegistryRolesError, RevokeRegistryRolesIntent, RevokeRegistryRolesParameters, RevokeRegistryRolesResult } from "./permissions/registry-roles/types.js";
+import { grantRegistryRoles, revokeRegistryRoles } from "./permissions/registry-roles/index.js";
+import { SetResolverDelegateApprovalError, SetResolverDelegateApprovalIntent, SetResolverDelegateApprovalParameters, SetResolverDelegateApprovalResult } from "./permissions/resolver-delegate-approval/types.js";
+import { setResolverDelegateApproval } from "./permissions/resolver-delegate-approval/index.js";
+import { GrantResolverRolesError, GrantResolverRolesIntent, GrantResolverRolesParameters, GrantResolverRolesResult, GrantResolverRootRolesError, GrantResolverRootRolesIntent, GrantResolverRootRolesParameters, GrantResolverRootRolesResult, ResolverRolesMutationParameters, ResolverRootRolesMutationParameters, RevokeResolverRolesError, RevokeResolverRolesIntent, RevokeResolverRolesParameters, RevokeResolverRolesResult, RevokeResolverRootRolesError, RevokeResolverRootRolesIntent, RevokeResolverRootRolesParameters, RevokeResolverRootRolesResult } from "./permissions/resolver-roles/types.js";
+import { grantResolverRoles, grantResolverRootRoles, revokeResolverRoles, revokeResolverRootRoles } from "./permissions/resolver-roles/index.js";
+import { AppliedRecordPermission, SetRecordPermissionsError, SetRecordPermissionsParameters, SetRecordPermissionsResult } from "./permissions/set-record-permissions/types.js";
+import { setRecordPermissions } from "./permissions/set-record-permissions/index.js";
+import "./permissions/index.js";
+import { AbiResult, GetAbiError, GetAbiParameters } from "./records/get-abi/types.js";
+import { getAbi } from "./records/get-abi/index.js";
+import { ClearRecordsError, ClearRecordsParameters, ClearRecordsResult } from "./records/clear-records/types.js";
+import { clearRecords } from "./records/clear-records/index.js";
+import { SetAliasError, SetAliasParameters, SetAliasResult } from "./records/set-alias/types.js";
+import { setAlias } from "./records/set-alias/index.js";
+import { AddressResult, GetAddressError, GetAddressParameters, GetAddressesError, GetAddressesParameters } from "./records/get-address/types.js";
+import { getAddress, getAddresses } from "./records/get-address/index.js";
+import { AvatarResult, GetAvatarError, GetAvatarParameters } from "./records/get-avatar/types.js";
+import { getAvatar } from "./records/get-avatar/index.js";
+import { ContentHashResult, GetContentHashError, GetContentHashParameters } from "./records/get-content-hash/types.js";
+import { getContentHash } from "./records/get-content-hash/index.js";
+import { DataResult, GetDataError, GetDataParameters } from "./records/get-data/types.js";
+import { getData } from "./records/get-data/index.js";
+import { GetInterfaceError, GetInterfaceParameters, InterfaceResult } from "./records/get-interface/types.js";
+import { getInterface } from "./records/get-interface/index.js";
+import { GetNameError, GetNameParameters, NameResult } from "./records/get-name/types.js";
+import { getName } from "./records/get-name/index.js";
+import { GetPubkeyError, GetPubkeyParameters, PubkeyResult } from "./records/get-pubkey/types.js";
+import { getPubkey } from "./records/get-pubkey/index.js";
+import { GetTextError, GetTextParameters, GetTextsError, GetTextsParameters, TextResult } from "./records/get-text/types.js";
+import { GetRecordsAction, GetRecordsError, GetRecordsParameters, GetRecordsResult, GetRecordsSelection } from "./records/get-records/types.js";
+import { getRecords } from "./records/get-records/index.js";
+import { getText, getTexts } from "./records/get-text/index.js";
+import { ResolverMulticallResult, SetRecordInput, SetRecordsAction, SetRecordsError, SetRecordsParameters, SetRecordsResult } from "./records/set-records/types.js";
+import { setRecords } from "./records/set-records/index.js";
+import { SetTextError, SetTextParameters, SetTextResult } from "./records/set-text/types.js";
+import { setText } from "./records/set-text/index.js";
+import { SetTextsError, SetTextsParameters, SetTextsResult, TextRecordInput } from "./records/set-texts/types.js";
+import { setTexts } from "./records/set-texts/index.js";
+import { AddressRecordInput, SetAddressError, SetAddressParameters, SetAddressResult, SetAddressesError, SetAddressesParameters, SetAddressesResult } from "./records/set-address/types.js";
+import { setAddress, setAddresses } from "./records/set-address/index.js";
+import { SetContentHashError, SetContentHashParameters, SetContentHashResult } from "./records/set-content-hash/types.js";
+import { setContentHash } from "./records/set-content-hash/index.js";
+import { SetAbiError, SetAbiParameters, SetAbiResult } from "./records/set-abi/types.js";
+import { setAbi } from "./records/set-abi/index.js";
+import { SetPubkeyError, SetPubkeyParameters, SetPubkeyResult } from "./records/set-pubkey/types.js";
+import { setPubkey } from "./records/set-pubkey/index.js";
+import { SetInterfaceError, SetInterfaceParameters, SetInterfaceResult } from "./records/set-interface/types.js";
+import { setInterface } from "./records/set-interface/index.js";
+import { SetDataError, SetDataParameters, SetDataResult } from "./records/set-data/types.js";
+import { setData } from "./records/set-data/index.js";
+import { SetNameError, SetNameParameters, SetNameResult } from "./records/set-name/types.js";
+import { setName } from "./records/set-name/index.js";
+import { ClearAvatarError, ClearAvatarParameters, ClearAvatarResult, SetAvatarError, SetAvatarParameters, SetAvatarResult } from "./records/set-avatar/types.js";
+import { clearAvatar, setAvatar } from "./records/set-avatar/index.js";
+import "./records/index.js";
+import { ApprovePaymentTokenParameters, ApproveRenewalPaymentParameters, AvailableRegistrationPrice, CommitNameParameters, CommitmentStatus, CompleteRegistrationParameters, Erc20PaymentCurrency, NativePaymentCurrency, PaymentCurrency, PaymentTokenSupport, RegisterNameParameters, RegisterNameResult, RegisterNamesEntryParameters, RegisterNamesParameters, RegisterNamesResult, RegistrationCommitment, RegistrationCommitmentParameters, RegistrationParameters, RegistrationPlan, RegistrationPriceParameters, RegistrationPriceResult, RegistrationReadError, RegistrationWriteError, RegistrationWriteIntent, RegistrationWriteResult, RenewNameAction, RenewNameCallParameters, RenewNameParameters, RenewNameResult, RenewNamesEntryParameters, RenewNamesParameters, RenewNamesResult, RenewalApproval, RenewalPriceResult, RenewalRoute } from "./registration/types.js";
+import { GetCommitmentStatusParameters, getCommitmentStatus } from "./registration/get-commitment-status/index.js";
+import { GetRegistrationParametersParameters, getRegistrationParameters } from "./registration/get-registration-parameters/index.js";
+import { GetRegistrationPlanParameters, getRegistrationPlan } from "./registration/get-registration-plan/index.js";
+import { getRegistrationPrice } from "./registration/get-registration-price/index.js";
+import { getRenewalPrice } from "./registration/get-renewal-price/index.js";
+import { IsPaymentTokenSupportedParameters, isPaymentTokenSupported } from "./registration/is-payment-token-supported/index.js";
+import { makeRegistrationCommitment } from "./registration/make-registration-commitment/index.js";
+import { approvePaymentToken, commitName, completeRegistration } from "./registration/mutation.js";
+import { registerName } from "./registration/register-name/index.js";
+import { registerNames } from "./registration/register-names/index.js";
+import { renewName } from "./registration/renew-name/index.js";
+import { renewNames } from "./registration/renew-names/index.js";
+import { approveRenewalPayment } from "./registration/renewal-mutation.js";
+import "./registration/index.js";
+import { CreateResolverError, CreateResolverIntent, CreateResolverParameters, CreateResolverResult } from "./resolution/create-resolver/types.js";
+import { createResolver, predictResolverAddress } from "./resolution/create-resolver/index.js";
+import { GetResolverError, GetResolverParameters, GetResolverResult } from "./resolution/get-resolver/types.js";
+import { AliasResult, GetAliasError, GetAliasParameters } from "./resolution/get-alias/types.js";
+import { getAlias } from "./resolution/get-alias/index.js";
+import { GetOrCreateResolverError, GetOrCreateResolverParameters, GetOrCreateResolverResult } from "./resolution/get-or-create-resolver/types.js";
+import { getOrCreateResolver } from "./resolution/get-or-create-resolver/index.js";
+import { getResolver } from "./resolution/get-resolver/index.js";
+import { GetResolverVersionError, GetResolverVersionParameters, ResolverVersionResult } from "./resolution/get-resolver-version/types.js";
+import { getResolverVersion } from "./resolution/get-resolver-version/index.js";
+import { UpgradeResolverError, UpgradeResolverIntent, UpgradeResolverParameters, UpgradeResolverResult } from "./resolution/upgrade-resolver/types.js";
+import { upgradeResolver } from "./resolution/upgrade-resolver/index.js";
+import { SetResolverError, SetResolverParameters, SetResolverResult } from "./resolution/set-resolver/types.js";
+import { setResolver } from "./resolution/set-resolver/index.js";
+import { ResolverSource, SetResolverAndRecordsError, SetResolverAndRecordsParameters, SetResolverAndRecordsProgress, SetResolverAndRecordsResult } from "./resolution/set-resolver-and-records/types.js";
+import { setResolverAndRecords } from "./resolution/set-resolver-and-records/index.js";
+import { ResolveError, ResolveParameters, ResolveResult, ResolveWithResolverError, ResolveWithResolverParameters, ResolveWithResolverResult } from "./resolution/resolve/types.js";
+import { resolve, resolveWithResolver } from "./resolution/resolve/index.js";
+import { ResolveBatchCall, ResolveBatchError, ResolveBatchParameters, ResolveBatchResult } from "./resolution/resolve-batch/types.js";
+import { resolveBatch } from "./resolution/resolve-batch/index.js";
+import "./resolution/index.js";
+import { GetPrimaryNameError, GetPrimaryNameParameters, PrimaryNameResult } from "./reverse/get-primary-name/types.js";
+import { getPrimaryName } from "./reverse/get-primary-name/index.js";
+import { ClearPrimaryNameParameters, ReverseNameWriteError, ReverseNameWriteResult, SetContractPrimaryNameParameters, SetPrimaryNameForAddressParameters, SetPrimaryNameParameters } from "./reverse/types.js";
+import { clearPrimaryName } from "./reverse/clear-primary-name/index.js";
+import { setContractPrimaryName } from "./reverse/set-contract-primary-name/index.js";
+import { setPrimaryName } from "./reverse/set-primary-name/index.js";
+import { setPrimaryNameForAddress } from "./reverse/set-primary-name-for-address/index.js";
+import "./reverse/index.js";
+import { CreateSubnameParameters, CreateSubnameResult, SetSubnameExpiryParameters, SetSubnameManagerParameters, SetSubnameRecordParameters, SetSubnameRecordResult, SetSubnameResolverParameters, SubnameError, SubnameParameters, SubnameWriteResult, TransferSubnameParameters } from "./subnames/types.js";
+import { createSubname } from "./subnames/create-subname/index.js";
+import { deleteSubname, setSubnameExpiry, setSubnameManager, setSubnameResolver } from "./subnames/mutation.js";
+import { setSubnameRecord } from "./subnames/set-subname-record/index.js";
+import { transferSubname } from "./subnames/transfer-subname/index.js";
+import "./subnames/index.js";
+import { NameWrapperFuseName, decodeFuseMask, encodeFuseMask, nameWrapperFuseNames, wrapperFuseMasks } from "./wrapping/fuse-mask.js";
+import { ExtendSubnameExpiryParameters, GetFusesResult, GetWrapperExpiryResult, SetChildFusesParameters, SetFusesParameters, UnwrapNameParameters, WrapNameParameters, WrapNameResult, WrapperReadError, WrapperReadParameters, WrapperUnsupportedReason, WrapperWriteError, WrapperWriteIntent, WrapperWriteResult } from "./wrapping/types.js";
+import { extendSubnameExpiry, setChildFuses, setFuses, unwrapName } from "./wrapping/mutation.js";
+import { getFuses } from "./wrapping/get-fuses/index.js";
+import { getWrapperExpiry } from "./wrapping/get-wrapper-expiry/index.js";
+import { wrapName } from "./wrapping/wrap-name/index.js";
+import "./wrapping/index.js";
+export { AbiResult, AccountCapabilityParameters, type AddressRecordInput, AddressResult, AliasResult, type AppliedRecordPermission, type ApproveMigrationParameters, type ApproveMigrationResult, type ApproveNameError, type ApproveNameIntent, type ApproveNameParameters, type ApproveNameResult, type ApprovePaymentTokenParameters, type ApproveRenewalPaymentParameters, AuthorizationDecision, AuthorizationRequirement, AuthorizationSource, AvailableNameState, type AvailableRegistrationPrice, AvatarResult, CapabilityError, type ClaimDnsNameError, type ClaimDnsNameIntent, type ClaimDnsNameParameters, type ClaimDnsNameResult, type ClearAvatarError, type ClearAvatarParameters, type ClearAvatarResult, type ClearNameApprovalError, type ClearNameApprovalIntent, type ClearNameApprovalParameters, type ClearNameApprovalResult, type ReverseNameWriteError as ClearPrimaryNameError, type ClearPrimaryNameParameters, type ReverseNameWriteResult as ClearPrimaryNameResult, type ClearRecordsError, type ClearRecordsParameters, type ClearRecordsResult, type CommitNameParameters, CommitmentStatus, type CompleteRegistrationParameters, ContentHashResult, type CreateResolverError, type CreateResolverIntent, type CreateResolverParameters, type CreateResolverResult, type SubnameError as CreateSubnameError, type CreateSubnameParameters, type CreateSubnameResult, DataResult, type SubnameError as DeleteSubnameError, type SubnameParameters as DeleteSubnameParameters, type SubnameWriteResult as DeleteSubnameResult, DnsClaimStatus, DnsImportPlan, type DnsReadError, type DnsRecordQuery, DnsRecordResult, DnsRecordsExistence, DnsRecordsResult, DnsResource, DnssecProof, DnssecProofChain, EnsEvent, EnsEventContractKind, type EnsEventError, EnsEventKind, Erc20PaymentCurrency, ExpiryResult, ExpirySource, type WrapperWriteError as ExtendSubnameExpiryError, type WrapperWriteIntent as ExtendSubnameExpiryIntent, type ExtendSubnameExpiryParameters, type WrapperWriteResult as ExtendSubnameExpiryResult, type GetAbiError, type GetAbiParameters, type GetAddressError, type GetAddressParameters, type GetAddressesError, type GetAddressesParameters, type GetAliasError, type GetAliasParameters, type GetAvatarError, type GetAvatarParameters, type GetNameStateError as GetCanonicalResourceError, type GetNameStateParameters as GetCanonicalResourceParameters, type GetCanonicalResourceResult, type RegistrationReadError as GetCommitmentStatusError, type GetCommitmentStatusParameters, type GetContentHashError, type GetContentHashParameters, type GetDataError, type GetDataParameters, type DnsReadError as GetDnsClaimStatusError, type GetDnsClaimStatusParameters, type DnsReadError as GetDnsImportPlanError, type GetDnsImportPlanParameters, type DnsReadError as GetDnsRecordError, type GetDnsRecordParameters, type DnsReadError as GetDnsRecordsError, type GetDnsRecordsParameters, type EnsEventError as GetEnsEventsError, type GetEnsEventsParameters, type GetExpiryError, type GetExpiryParameters, type WrapperReadError as GetFusesError, type WrapperReadParameters as GetFusesParameters, type GetFusesResult, type GetInterfaceError, type GetInterfaceParameters, type GetNameStateError as GetManagerError, type GetNameStateParameters as GetManagerParameters, type GetManagerResult, type MigrationReadError as GetMigrationEligibilityError, type GetMigrationEligibilityParameters, type MigrationReadError as GetMigrationPlanError, type GetMigrationPlanParameters, type MigrationReadError as GetMigrationStatusError, type MigrationNameParameters as GetMigrationStatusParameters, type MigrationReadError as GetMigrationTargetError, type MigrationNameParameters as GetMigrationTargetParameters, type CapabilityError as GetNameCapabilitiesError, GetNameCapabilitiesParameters, type GetNameError, type EnsEventError as GetNameHistoryError, type GetNameHistoryParameters, type GetNameParameters, type GetNameStateError, type GetNameStateParameters, type GetNameStateError as GetNameStatusError, type GetNameStateParameters as GetNameStatusParameters, type NameStatus as GetNameStatusResult, type CapabilityError as GetOperatorApprovalError, GetOperatorApprovalParameters, type GetOrCreateResolverError, type GetOrCreateResolverParameters, type GetOrCreateResolverResult, type GetOwnerError, type GetOwnerParameters, type GetPrimaryNameError, type GetPrimaryNameParameters, type GetNameStateError as GetProtocolError, type GetNameStateParameters as GetProtocolParameters, type GetProtocolResult, type GetPubkeyError, type GetPubkeyParameters, type CapabilityError as GetRecordPermissionsError, GetRecordPermissionsParameters, type GetRecordsAction, type GetRecordsError, type GetRecordsParameters, type GetRecordsResult, type GetRecordsSelection, type GetNameStateError as GetRegistrantError, type GetNameStateParameters as GetRegistrantParameters, type GetRegistrantResult, type RegistrationReadError as GetRegistrationParametersError, type GetRegistrationParametersParameters, type RegistrationReadError as GetRegistrationPlanError, type GetRegistrationPlanParameters, type RegistrationReadError as GetRegistrationPriceError, type RegistrationPriceParameters as GetRegistrationPriceParameters, type CapabilityError as GetRegistryCapabilitiesError, type NameCapabilityParameters as GetRegistryCapabilitiesParameters, type GetNameStateError as GetRegistryError, type GetNameStateParameters as GetRegistryParameters, type GetRegistryResult, type CapabilityError as GetRegistryRolesError, type AccountCapabilityParameters as GetRegistryRolesParameters, type RegistrationReadError as GetRenewalPriceError, type RegistrationPriceParameters as GetRenewalPriceParameters, type CapabilityError as GetRequiredAuthorizationError, GetRequiredAuthorizationParameters, type CapabilityError as GetResolverCapabilitiesError, type NameCapabilityParameters as GetResolverCapabilitiesParameters, type CapabilityError as GetResolverDelegateApprovalError, GetResolverDelegateApprovalParameters, type GetResolverError, type GetResolverParameters, type GetResolverResult, type CapabilityError as GetResolverRolesError, GetResolverRolesParameters, type GetResolverVersionError, type GetResolverVersionParameters, type GetTextError, type GetTextParameters, type GetTextsError, type GetTextsParameters, type CapabilityError as GetTokenApprovalError, type NameCapabilityParameters as GetTokenApprovalParameters, type GetNameStateError as GetTokenIdError, type GetNameStateParameters as GetTokenIdParameters, type GetTokenIdResult, type GetNameStateError as GetTtlError, type GetNameStateParameters as GetTtlParameters, type TtlResult as GetTtlResult, type WrapperReadError as GetWrapperExpiryError, type WrapperReadParameters as GetWrapperExpiryParameters, type GetWrapperExpiryResult, type CapabilityError as GetWrapperPermissionsError, type AccountCapabilityParameters as GetWrapperPermissionsParameters, type CapabilityError as GetWriteTargetError, GetWriteTargetParameters, type DnsReadError as GetZoneHashError, type GetZoneHashParameters, type GrantRegistryRolesError, type GrantRegistryRolesIntent, type GrantRegistryRolesParameters, type GrantRegistryRolesResult, type GrantResolverRolesError, type GrantResolverRolesIntent, type GrantResolverRolesParameters, type GrantResolverRolesResult, type GrantResolverRootRolesError, type GrantResolverRootRolesIntent, type GrantResolverRootRolesParameters, type GrantResolverRootRolesResult, type DnsReadError as HasDnsRecordsError, type HasDnsRecordsParameters, type CapabilityError as HasRegistryRolesError, HasRegistryRolesParameters, HasRegistryRolesResult, type CapabilityError as HasResolverRolesError, HasResolverRolesParameters, HasResolverRolesResult, type ImportDnsNameError, type ImportDnsNameParameters, type ImportDnsNameResult, InterfaceResult, type GetNameStateError as IsAvailableError, type GetNameStateParameters as IsAvailableParameters, type GetNameStateError as IsMigratedError, type GetNameStateParameters as IsMigratedParameters, type RegistrationReadError as IsPaymentTokenSupportedError, type IsPaymentTokenSupportedParameters, type GetNameStateError as IsRenewableError, type GetNameStateParameters as IsRenewableParameters, type GetNameStateError as IsReservedError, type GetNameStateParameters as IsReservedParameters, type GetNameStateError as IsWrappedError, type GetNameStateParameters as IsWrappedParameters, type RegistrationReadError as MakeRegistrationCommitmentError, type RegistrationCommitmentParameters as MakeRegistrationCommitmentParameters, type MigrateNameAction, type MigrateNameCallParameters, type MigrateNameParameters, type MigrateNameResult, type MigrateNamesParameters, type MigrationBatchApproval, type MigrationBatchEntry, type MigrationBatchProgress, MigrationBlocker, MigrationEligibility, type MigrationNameParameters, type MigrationNameProgress, MigrationPlan, type MigrationReadError, MigrationStatus, MigrationTarget, MigrationUnsupportedReason, type MigrationValues, type MigrationWalletParameters, type MigrationWriteError, NameCapabilities, NameCapabilityParameters, NameHistory, NameResult, NameState, NameStatus, type NameWrapperFuseName, NativePaymentCurrency, type OperatorApprovalKind, OperatorApprovalResult, OperatorApprovalTarget, OwnerResult, OwnershipLevel, PaymentCurrency, PaymentTokenSupport, PrimaryNameResult, PubkeyResult, type ReadBatch, type ReadBatchError, type ReadBatchOptions, type ReadBatchOutcome, type ReadBatchResult, type ReadBatchSettled, type ReadBatchSettledResult, type OwnershipWriteError as ReclaimNameError, type ReclaimNameParameters, type OwnershipWriteResult as ReclaimNameResult, RecordOperation, RecordPermission, RecordPermissionsResult, type RegisterNameParameters, type RegisterNameResult, type RegisterNamesEntryParameters, type RegisterNamesParameters, type RegisterNamesResult, RegistrationCommitment, RegistrationParameters, RegistrationPlan, RegistrationPriceResult, type RegistrationReadError, type RegistrationWriteError, type RegistrationWriteIntent, type RegistrationWriteResult, RegistryCapabilities, RegistryOperation, type RegistryRolesMutationParameters, RegistryRolesResult, type RenewNameAction, type RenewNameCallParameters, type RenewNameParameters, type RenewNameResult, type RenewNamesEntryParameters, type RenewNamesParameters, type RenewNamesResult, type RenewalApproval, RenewalPriceResult, RenewalRoute, RequiredAuthorizationResult, type ResolveBatchCall, type ResolveBatchError, type ResolveBatchParameters, type ResolveBatchResult, type ResolveError, type ResolveParameters, ResolveResult, type ResolveWithResolverError, type ResolveWithResolverParameters, ResolveWithResolverResult, ResolverCapabilities, ResolverDelegateApprovalResult, type ResolverMulticallResult, ResolverProfiles, type ResolverRolesMutationParameters, ResolverRolesResult, type ResolverRootRolesMutationParameters, type ResolverSource, ResolverVersionResult, type ReverseNameWriteError, type ReverseNameWriteResult, type RevokeRegistryRolesError, type RevokeRegistryRolesIntent, type RevokeRegistryRolesParameters, type RevokeRegistryRolesResult, type RevokeResolverRolesError, type RevokeResolverRolesIntent, type RevokeResolverRolesParameters, type RevokeResolverRolesResult, type RevokeResolverRootRolesError, type RevokeResolverRootRolesIntent, type RevokeResolverRootRolesParameters, type RevokeResolverRootRolesResult, type SetAbiError, type SetAbiParameters, type SetAbiResult, type SetAddressError, type SetAddressParameters, type SetAddressResult, type SetAddressesError, type SetAddressesParameters, type SetAddressesResult, type SetAliasError, type SetAliasParameters, type SetAliasResult, type SetAvatarError, type SetAvatarParameters, type SetAvatarResult, type WrapperWriteError as SetChildFusesError, type WrapperWriteIntent as SetChildFusesIntent, type SetChildFusesParameters, type WrapperWriteResult as SetChildFusesResult, type SetContentHashError, type SetContentHashParameters, type SetContentHashResult, type ReverseNameWriteError as SetContractPrimaryNameError, type SetContractPrimaryNameParameters, type ReverseNameWriteResult as SetContractPrimaryNameResult, type SetDataError, type SetDataParameters, type SetDataResult, type SetDnsRecordsError, type SetDnsRecordsParameters, type SetDnsRecordsResult, type WrapperWriteError as SetFusesError, type WrapperWriteIntent as SetFusesIntent, type SetFusesParameters, type WrapperWriteResult as SetFusesResult, type SetInterfaceError, type SetInterfaceParameters, type SetInterfaceResult, type OwnershipWriteError as SetManagerError, type SetManagerParameters, type OwnershipWriteResult as SetManagerResult, type SetNameError, type SetNameParameters, type SetNameResult, type SetOperatorApprovalError, type SetOperatorApprovalIntent, type SetOperatorApprovalParameters, type SetOperatorApprovalResult, type ReverseNameWriteError as SetPrimaryNameError, type ReverseNameWriteError as SetPrimaryNameForAddressError, type SetPrimaryNameForAddressParameters, type ReverseNameWriteResult as SetPrimaryNameForAddressResult, type SetPrimaryNameParameters, type ReverseNameWriteResult as SetPrimaryNameResult, type SetPubkeyError, type SetPubkeyParameters, type SetPubkeyResult, type SetRecordInput, type SetRecordPermissionsError, type SetRecordPermissionsParameters, type SetRecordPermissionsResult, type SetRecordsAction, type SetRecordsError, type SetRecordsParameters, type SetRecordsResult, type SetResolverAndRecordsError, type SetResolverAndRecordsParameters, type SetResolverAndRecordsProgress, type SetResolverAndRecordsResult, type SetResolverDelegateApprovalError, type SetResolverDelegateApprovalIntent, type SetResolverDelegateApprovalParameters, type SetResolverDelegateApprovalResult, type SetResolverError, type SetResolverParameters, type SetResolverResult, type SubnameError as SetSubnameExpiryError, type SetSubnameExpiryParameters, type SubnameWriteResult as SetSubnameExpiryResult, type SubnameError as SetSubnameManagerError, type SetSubnameManagerParameters, type SubnameWriteResult as SetSubnameManagerResult, type SubnameError as SetSubnameRecordError, type SetSubnameRecordParameters, type SetSubnameRecordResult, type SubnameError as SetSubnameResolverError, type SetSubnameResolverParameters, type SubnameWriteResult as SetSubnameResolverResult, type SetTextError, type SetTextParameters, type SetTextResult, type SetTextsError, type SetTextsParameters, type SetTextsResult, type OwnershipWriteError as SetTtlError, type SetTtlParameters, type OwnershipWriteResult as SetTtlResult, type SetZoneHashError, type SetZoneHashParameters, type SetZoneHashResult, type TextRecordInput, TextResult, TokenApprovalResult, type TransferNameError, type TransferNameParameters, type TransferNameProgress, type TransferNameResult, type TransferNameStrategy, type OwnershipWriteError as TransferRegistrantError, type TransferRegistrantParameters, type OwnershipWriteResult as TransferRegistrantResult, type SubnameError as TransferSubnameError, type TransferSubnameParameters, type WrapperWriteError as UnwrapNameError, type WrapperWriteIntent as UnwrapNameIntent, type UnwrapNameParameters, type WrapperWriteResult as UnwrapNameResult, type UpgradeResolverError, type UpgradeResolverIntent, type UpgradeResolverParameters, type UpgradeResolverResult, V1UnwrappedNameState, V1WrappedNameState, V2MigratedNameState, V2NativeNameState, V2ReservedNameState, type WatchEnsEvents, type EnsEventError as WatchEnsEventsError, type WatchEnsEventsParameters, type WrapperWriteError as WrapNameError, type WrapNameParameters, type WrapNameResult, WrapperPermissionsResult, type WrapperReadError, type WrapperReadParameters, type WrapperUnsupportedReason, type WrapperWriteError, type WrapperWriteIntent, type WrapperWriteResult, WriteOperation, WriteTarget, ZoneHashResult, approveMigration, approveName, approvePaymentToken, approveRenewalPayment, claimDnsName, clearAvatar, clearNameApproval, clearPrimaryName, clearRecords, commitName, completeRegistration, createResolver, createSubname, decodeFuseMask, deleteSubname, encodeFuseMask, estimateCalls, executeWritePlan, extendSubnameExpiry, getAbi, getAddress, getAddresses, getAlias, getAvatar, getCallsStatus, getCanonicalResource, getCommitmentStatus, getContentHash, getData, getDnsClaimStatus, getDnsImportPlan, getDnsRecord, getDnsRecords, getEnsEvents, getExpiry, getFuses, getInterface, getManager, getMigrationEligibility, getMigrationPlan, getMigrationStatus, getMigrationTarget, getName, getNameCapabilities, getNameHistory, getNameState, getNameStatus, getOperatorApproval, getOrCreateResolver, getOwner, getPrimaryName, getProtocol, getPubkey, getRecordPermissions, getRecords, getRegistrant, getRegistrationParameters, getRegistrationPlan, getRegistrationPrice, getRegistry, getRegistryCapabilities, getRegistryRoles, getRenewalPrice, getRequiredAuthorization, getResolver, getResolverCapabilities, getResolverDelegateApproval, getResolverRoles, getResolverVersion, getText, getTexts, getTokenApproval, getTokenId, getTtl, getWalletCapabilities, getWrapperExpiry, getWrapperPermissions, getWriteTarget, getZoneHash, grantRegistryRoles, grantResolverRoles, grantResolverRootRoles, hasDnsRecords, hasRegistryRoles, hasResolverRoles, importDnsName, isAvailable, isMigrated, isPaymentTokenSupported, isRenewable, isReserved, isWrapped, makeRegistrationCommitment, migrateName, migrateNames, nameWrapperFuseNames, predictResolverAddress, prepareCalls, readBatch, readBatchSettled, reclaimName, registerName, registerNames, renewName, renewNames, resolve, resolveBatch, resolveWithResolver, resumeCalls, revokeRegistryRoles, revokeResolverRoles, revokeResolverRootRoles, sendCalls, setAbi, setAddress, setAddresses, setAlias, setAvatar, setChildFuses, setContentHash, setContractPrimaryName, setData, setDnsRecords, setFuses, setInterface, setManager, setName, setOperatorApproval, setPrimaryName, setPrimaryNameForAddress, setPubkey, setRecordPermissions, setRecords, setResolver, setResolverAndRecords, setResolverDelegateApproval, setSubnameExpiry, setSubnameManager, setSubnameRecord, setSubnameResolver, setText, setTexts, setTtl, setZoneHash, simulateCalls, transferName, transferRegistrant, transferSubname, unwrapName, upgradeResolver, watchEnsEvents, wrapName, wrapperFuseMasks };

package/dist/actions/migration/get-migration-eligibility/index.d.ts

@@ -0,0 +1,71 @@
+import { EnsReadAction } from "../../../action/read-request.js";
+import { EthereumAddress } from "../../../schemas/identity.js";
+import { GetNameStateError } from "../../name/get-name-state/types.js";
+import { MigrationEligibility, MigrationNameParameters, MigrationReadError } from "../types.js";
+import "../../index.js";
+import "../../../index.js";
+//#region src/actions/migration/get-migration-eligibility/index.d.ts
+type GetMigrationEligibilityParameters = MigrationNameParameters & {
+  readonly account: EthereumAddress;
+};
+declare const getMigrationEligibility: EnsReadAction<GetMigrationEligibilityParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly eligible: boolean;
+  readonly status: {
+    readonly status: "unsupported";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED";
+  } | {
+    readonly status: "not-required";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "V2_NATIVE" | "AVAILABLE";
+  } | {
+    readonly status: "reserved-unwrapped";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  } | {
+    readonly status: "locked-child-pending-parent";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly parent: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly fuses: number;
+  } | {
+    readonly status: "reserved-wrapped-unlocked";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly fuses: number;
+  } | {
+    readonly status: "reserved-wrapped-locked";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly fuses: number;
+  } | {
+    readonly status: "mirrored-child";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly parentRegistry: `0x${string}`;
+    readonly fuses: number;
+  } | {
+    readonly status: "migrated-unlocked";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  } | {
+    readonly status: "migrated-locked";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly registry: `0x${string}`;
+  };
+  readonly target: {
+    readonly supported: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "MIGRATION_UNSUPPORTED" | "MIGRATION_NOT_REQUIRED" | "PARENT_NOT_MIGRATED";
+  } | {
+    readonly supported: true;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly route: "unwrapped" | "wrapped-unlocked" | "wrapped-locked" | "locked-child";
+    readonly tokenContract: `0x${string}`;
+    readonly tokenId: bigint;
+    readonly tokenStandard: "erc721" | "erc1155";
+    readonly receiver: `0x${string}`;
+  };
+  readonly account: `0x${string}`;
+  readonly owner: `0x${string}` | null;
+  readonly authorized: boolean;
+  readonly blockers: readonly ("ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED" | "PARENT_NOT_MIGRATED" | "NAME_ALREADY_MIGRATED" | "NAME_AVAILABLE" | "ACCOUNT_NOT_OWNER_OR_OPERATOR" | "INVALID_WRAPPER_STATE" | "FROZEN_TOKEN_APPROVAL" | "TRANSFER_DISABLED")[];
+}, GetNameStateError>;
+//#endregion
+export { type MigrationReadError as GetMigrationEligibilityError, GetMigrationEligibilityParameters, getMigrationEligibility };
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/migration/get-migration-eligibility/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/migration/get-migration-eligibility/index.ts"],"mappings":";;;;;;;KA4BY,oCAAoC;WACrC,SAAS;;cA8HP,yBAImB,cAJI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA"}

package/dist/actions/migration/get-migration-eligibility/index.js

@@ -0,0 +1,88 @@
+import { defineReadAction } from "../../../action/read-request.js";
+import { executeRead } from "../../../internal/read/execute-read.js";
+import { normalizeName } from "../../../names/normalize.js";
+import { EthereumClient } from "../../../internal/client/ethereum-client.js";
+import { getMigrationStatus } from "../get-migration-status/index.js";
+import { getMigrationTarget } from "../get-migration-target/index.js";
+import { Effect } from "effect";
+import { isAddressEqual, zeroAddress } from "viem";
+import { baseRegistrarV1GetApprovedAbi, baseRegistrarV1IsApprovedForAllAbi, baseRegistrarV1OwnerOfAbi, nameWrapperFuses, nameWrapperV1GetApprovedAbi, nameWrapperV1GetDataAbi, nameWrapperV1IsApprovedForAllAbi } from "@ensforge/contracts/v1";
+
+//#region src/actions/migration/get-migration-eligibility/index.ts
+const getMigrationEligibilityEffect = Effect.fn("ensforge.getMigrationEligibility")(function* (config, parameters) {
+	const name = yield* normalizeName.effect(parameters.name);
+	return yield* executeRead(config, parameters, Effect.gen(function* () {
+		const [status, target] = yield* Effect.all([getMigrationStatus.effect(config, parameters), getMigrationTarget.effect(config, parameters)], { concurrency: "unbounded" });
+		const blockers = [];
+		if (!target.supported) {
+			if (status.status === "locked-child-pending-parent") blockers.push("PARENT_NOT_MIGRATED");
+			else if (status.status === "unsupported") blockers.push(status.reason);
+			else if (status.status === "migrated-unlocked" || status.status === "migrated-locked") blockers.push("NAME_ALREADY_MIGRATED");
+			else blockers.push("NAME_AVAILABLE");
+			return {
+				name,
+				eligible: false,
+				status,
+				target,
+				account: parameters.account,
+				owner: null,
+				authorized: false,
+				blockers
+			};
+		}
+		const ethereum = yield* EthereumClient;
+		const owner = target.tokenStandard === "erc721" ? yield* ethereum.readContract({
+			address: target.tokenContract,
+			abi: baseRegistrarV1OwnerOfAbi,
+			functionName: "ownerOf",
+			args: [target.tokenId]
+		}) : yield* ethereum.readContract({
+			address: target.tokenContract,
+			abi: nameWrapperV1GetDataAbi,
+			functionName: "getData",
+			args: [target.tokenId]
+		}).pipe(Effect.map(([wrappedOwner]) => wrappedOwner));
+		const [approved, operatorApproved] = target.tokenStandard === "erc721" ? yield* Effect.all([ethereum.readContract({
+			address: target.tokenContract,
+			abi: baseRegistrarV1GetApprovedAbi,
+			functionName: "getApproved",
+			args: [target.tokenId]
+		}), ethereum.readContract({
+			address: target.tokenContract,
+			abi: baseRegistrarV1IsApprovedForAllAbi,
+			functionName: "isApprovedForAll",
+			args: [owner, parameters.account]
+		})], { concurrency: "unbounded" }) : yield* Effect.all([ethereum.readContract({
+			address: target.tokenContract,
+			abi: nameWrapperV1GetApprovedAbi,
+			functionName: "getApproved",
+			args: [target.tokenId]
+		}), ethereum.readContract({
+			address: target.tokenContract,
+			abi: nameWrapperV1IsApprovedForAllAbi,
+			functionName: "isApprovedForAll",
+			args: [owner, parameters.account]
+		})], { concurrency: "unbounded" });
+		const authorized = isAddressEqual(owner, parameters.account) || isAddressEqual(approved, parameters.account) || operatorApproved;
+		if (!authorized) blockers.push("ACCOUNT_NOT_OWNER_OR_OPERATOR");
+		if (status.status === "reserved-wrapped-locked" || status.status === "reserved-wrapped-unlocked" || status.status === "mirrored-child") {
+			if ((status.fuses & nameWrapperFuses.cannotTransfer) !== 0) blockers.push("TRANSFER_DISABLED");
+			if ((status.fuses & nameWrapperFuses.cannotApprove) !== 0 && !isAddressEqual(approved, zeroAddress)) blockers.push("FROZEN_TOKEN_APPROVAL");
+		}
+		return {
+			name,
+			eligible: blockers.length === 0,
+			status,
+			target,
+			account: parameters.account,
+			owner,
+			authorized,
+			blockers
+		};
+	}));
+});
+const getMigrationEligibility = defineReadAction(getMigrationEligibilityEffect);
+
+//#endregion
+export { getMigrationEligibility };
+//# sourceMappingURL=index.js.map

package/dist/actions/migration/get-migration-eligibility/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/actions/migration/get-migration-eligibility/index.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport {\n  baseRegistrarV1GetApprovedAbi,\n  baseRegistrarV1IsApprovedForAllAbi,\n  baseRegistrarV1OwnerOfAbi,\n  nameWrapperFuses,\n  nameWrapperV1GetApprovedAbi,\n  nameWrapperV1GetDataAbi,\n  nameWrapperV1IsApprovedForAllAbi,\n} from \"@ensforge/contracts/v1\";\nimport { isAddressEqual, zeroAddress } from \"viem\";\n\nimport { defineReadAction } from \"../../../action/read-request.js\";\nimport type { EnsforgeConfig } from \"../../../config/config.js\";\nimport { EthereumClient } from \"../../../internal/client/ethereum-client.js\";\nimport { executeRead } from \"../../../internal/read/execute-read.js\";\nimport { normalizeName } from \"../../../names/normalize.js\";\nimport type { EthereumAddress } from \"../../../schemas/identity.js\";\nimport { getMigrationStatus } from \"../get-migration-status/index.js\";\nimport { getMigrationTarget } from \"../get-migration-target/index.js\";\nimport type {\n  MigrationBlocker,\n  MigrationEligibility,\n  MigrationNameParameters,\n  MigrationReadError,\n} from \"../types.js\";\n\nexport type GetMigrationEligibilityParameters = MigrationNameParameters & {\n  readonly account: EthereumAddress;\n};\n\nconst getMigrationEligibilityEffect = Effect.fn(\"ensforge.getMigrationEligibility\")(function* (\n  config: EnsforgeConfig,\n  parameters: GetMigrationEligibilityParameters,\n) {\n  const name = yield* normalizeName.effect(parameters.name);\n  return yield* executeRead(\n    config,\n    parameters,\n    Effect.gen(function* () {\n      const [status, target] = yield* Effect.all(\n        [\n          getMigrationStatus.effect(config, parameters),\n          getMigrationTarget.effect(config, parameters),\n        ] as const,\n        { concurrency: \"unbounded\" },\n      );\n      const blockers: Array<MigrationBlocker> = [];\n      if (!target.supported) {\n        if (status.status === \"locked-child-pending-parent\") blockers.push(\"PARENT_NOT_MIGRATED\");\n        else if (status.status === \"unsupported\") blockers.push(status.reason);\n        else if (status.status === \"migrated-unlocked\" || status.status === \"migrated-locked\") {\n          blockers.push(\"NAME_ALREADY_MIGRATED\");\n        } else blockers.push(\"NAME_AVAILABLE\");\n        return {\n          name,\n          eligible: false,\n          status,\n          target,\n          account: parameters.account,\n          owner: null,\n          authorized: false,\n          blockers,\n        } satisfies MigrationEligibility;\n      }\n\n      const ethereum = yield* EthereumClient;\n      const owner =\n        target.tokenStandard === \"erc721\"\n          ? yield* ethereum.readContract({\n              address: target.tokenContract,\n              abi: baseRegistrarV1OwnerOfAbi,\n              functionName: \"ownerOf\",\n              args: [target.tokenId],\n            })\n          : yield* ethereum\n              .readContract({\n                address: target.tokenContract,\n                abi: nameWrapperV1GetDataAbi,\n                functionName: \"getData\",\n                args: [target.tokenId],\n              })\n              .pipe(Effect.map(([wrappedOwner]) => wrappedOwner));\n      const [approved, operatorApproved] =\n        target.tokenStandard === \"erc721\"\n          ? yield* Effect.all(\n              [\n                ethereum.readContract({\n                  address: target.tokenContract,\n                  abi: baseRegistrarV1GetApprovedAbi,\n                  functionName: \"getApproved\",\n                  args: [target.tokenId],\n                }),\n                ethereum.readContract({\n                  address: target.tokenContract,\n                  abi: baseRegistrarV1IsApprovedForAllAbi,\n                  functionName: \"isApprovedForAll\",\n                  args: [owner, parameters.account],\n                }),\n              ] as const,\n              { concurrency: \"unbounded\" },\n            )\n          : yield* Effect.all(\n              [\n                ethereum.readContract({\n                  address: target.tokenContract,\n                  abi: nameWrapperV1GetApprovedAbi,\n                  functionName: \"getApproved\",\n                  args: [target.tokenId],\n                }),\n                ethereum.readContract({\n                  address: target.tokenContract,\n                  abi: nameWrapperV1IsApprovedForAllAbi,\n                  functionName: \"isApprovedForAll\",\n                  args: [owner, parameters.account],\n                }),\n              ] as const,\n              { concurrency: \"unbounded\" },\n            );\n      const authorized =\n        isAddressEqual(owner, parameters.account) ||\n        isAddressEqual(approved, parameters.account) ||\n        operatorApproved;\n      if (!authorized) blockers.push(\"ACCOUNT_NOT_OWNER_OR_OPERATOR\");\n\n      if (\n        status.status === \"reserved-wrapped-locked\" ||\n        status.status === \"reserved-wrapped-unlocked\" ||\n        status.status === \"mirrored-child\"\n      ) {\n        if ((status.fuses & nameWrapperFuses.cannotTransfer) !== 0) {\n          blockers.push(\"TRANSFER_DISABLED\");\n        }\n        if (\n          (status.fuses & nameWrapperFuses.cannotApprove) !== 0 &&\n          !isAddressEqual(approved, zeroAddress)\n        ) {\n          blockers.push(\"FROZEN_TOKEN_APPROVAL\");\n        }\n      }\n      return {\n        name,\n        eligible: blockers.length === 0,\n        status,\n        target,\n        account: parameters.account,\n        owner,\n        authorized,\n        blockers,\n      } satisfies MigrationEligibility;\n    }),\n  );\n});\n\nexport const getMigrationEligibility = defineReadAction<\n  GetMigrationEligibilityParameters,\n  MigrationEligibility,\n  MigrationReadError\n>(getMigrationEligibilityEffect);\n\nexport type {\n  MigrationEligibility,\n  MigrationReadError as GetMigrationEligibilityError,\n} from \"../types.js\";\n"],"mappings":";;;;;;;;;;;AAgCA,MAAM,gCAAgC,OAAO,GAAG,kCAAkC,CAAC,CAAC,WAClF,QACA,YACA;CACA,MAAM,OAAO,OAAO,cAAc,OAAO,WAAW,IAAI;CACxD,OAAO,OAAO,YACZ,QACA,YACA,OAAO,IAAI,aAAa;EACtB,MAAM,CAAC,QAAQ,UAAU,OAAO,OAAO,IACrC,CACE,mBAAmB,OAAO,QAAQ,UAAU,GAC5C,mBAAmB,OAAO,QAAQ,UAAU,CAC9C,GACA,EAAE,aAAa,YAAY,CAC7B;EACA,MAAM,WAAoC,CAAC;EAC3C,IAAI,CAAC,OAAO,WAAW;GACrB,IAAI,OAAO,WAAW,+BAA+B,SAAS,KAAK,qBAAqB;QACnF,IAAI,OAAO,WAAW,eAAe,SAAS,KAAK,OAAO,MAAM;QAChE,IAAI,OAAO,WAAW,uBAAuB,OAAO,WAAW,mBAClE,SAAS,KAAK,uBAAuB;QAChC,SAAS,KAAK,gBAAgB;GACrC,OAAO;IACL;IACA,UAAU;IACV;IACA;IACA,SAAS,WAAW;IACpB,OAAO;IACP,YAAY;IACZ;GACF;EACF;EAEA,MAAM,WAAW,OAAO;EACxB,MAAM,QACJ,OAAO,kBAAkB,WACrB,OAAO,SAAS,aAAa;GAC3B,SAAS,OAAO;GAChB,KAAK;GACL,cAAc;GACd,MAAM,CAAC,OAAO,OAAO;EACvB,CAAC,IACD,OAAO,SACJ,aAAa;GACZ,SAAS,OAAO;GAChB,KAAK;GACL,cAAc;GACd,MAAM,CAAC,OAAO,OAAO;EACvB,CAAC,CAAC,CACD,KAAK,OAAO,KAAK,CAAC,kBAAkB,YAAY,CAAC;EAC1D,MAAM,CAAC,UAAU,oBACf,OAAO,kBAAkB,WACrB,OAAO,OAAO,IACZ,CACE,SAAS,aAAa;GACpB,SAAS,OAAO;GAChB,KAAK;GACL,cAAc;GACd,MAAM,CAAC,OAAO,OAAO;EACvB,CAAC,GACD,SAAS,aAAa;GACpB,SAAS,OAAO;GAChB,KAAK;GACL,cAAc;GACd,MAAM,CAAC,OAAO,WAAW,OAAO;EAClC,CAAC,CACH,GACA,EAAE,aAAa,YAAY,CAC7B,IACA,OAAO,OAAO,IACZ,CACE,SAAS,aAAa;GACpB,SAAS,OAAO;GAChB,KAAK;GACL,cAAc;GACd,MAAM,CAAC,OAAO,OAAO;EACvB,CAAC,GACD,SAAS,aAAa;GACpB,SAAS,OAAO;GAChB,KAAK;GACL,cAAc;GACd,MAAM,CAAC,OAAO,WAAW,OAAO;EAClC,CAAC,CACH,GACA,EAAE,aAAa,YAAY,CAC7B;EACN,MAAM,aACJ,eAAe,OAAO,WAAW,OAAO,KACxC,eAAe,UAAU,WAAW,OAAO,KAC3C;EACF,IAAI,CAAC,YAAY,SAAS,KAAK,+BAA+B;EAE9D,IACE,OAAO,WAAW,6BAClB,OAAO,WAAW,+BAClB,OAAO,WAAW,kBAClB;GACA,KAAK,OAAO,QAAQ,iBAAiB,oBAAoB,GACvD,SAAS,KAAK,mBAAmB;GAEnC,KACG,OAAO,QAAQ,iBAAiB,mBAAmB,KACpD,CAAC,eAAe,UAAU,WAAW,GAErC,SAAS,KAAK,uBAAuB;EAEzC;EACA,OAAO;GACL;GACA,UAAU,SAAS,WAAW;GAC9B;GACA;GACA,SAAS,WAAW;GACpB;GACA;GACA;EACF;CACF,CAAC,CACH;AACF,CAAC;AAED,MAAa,0BAA0B,iBAIrC,6BAA6B"}

package/dist/actions/migration/get-migration-plan/index.d.ts

@@ -0,0 +1,70 @@
+import { EnsReadAction } from "../../../action/read-request.js";
+import { EthereumAddress } from "../../../schemas/identity.js";
+import { GetNameStateError } from "../../name/get-name-state/types.js";
+import { MigrationNameParameters, MigrationPlan, MigrationReadError } from "../types.js";
+import "../../index.js";
+import "../../../index.js";
+//#region src/actions/migration/get-migration-plan/index.d.ts
+type GetMigrationPlanParameters = MigrationNameParameters & {
+  readonly account: EthereumAddress;
+  readonly owner?: EthereumAddress;
+  readonly resolver?: EthereumAddress;
+  readonly subregistry?: EthereumAddress;
+};
+declare const getMigrationPlan: EnsReadAction<GetMigrationPlanParameters, {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly blockers: readonly ("ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED" | "PARENT_NOT_MIGRATED" | "NAME_ALREADY_MIGRATED" | "NAME_AVAILABLE" | "ACCOUNT_NOT_OWNER_OR_OPERATOR" | "INVALID_WRAPPER_STATE" | "FROZEN_TOKEN_APPROVAL" | "TRANSFER_DISABLED")[];
+} | {
+  readonly status: "not-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "V2_NATIVE" | "AVAILABLE" | "ALREADY_MIGRATED";
+} | {
+  readonly status: "blocked";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly blockers: readonly ("ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED" | "PARENT_NOT_MIGRATED" | "NAME_ALREADY_MIGRATED" | "NAME_AVAILABLE" | "ACCOUNT_NOT_OWNER_OR_OPERATOR" | "INVALID_WRAPPER_STATE" | "FROZEN_TOKEN_APPROVAL" | "TRANSFER_DISABLED")[];
+} | {
+  readonly status: "authorization-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly account: `0x${string}`;
+  readonly owner: `0x${string}`;
+  readonly target: {
+    readonly supported: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "MIGRATION_UNSUPPORTED" | "MIGRATION_NOT_REQUIRED" | "PARENT_NOT_MIGRATED";
+  } | {
+    readonly supported: true;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly route: "unwrapped" | "wrapped-unlocked" | "wrapped-locked" | "locked-child";
+    readonly tokenContract: `0x${string}`;
+    readonly tokenId: bigint;
+    readonly tokenStandard: "erc721" | "erc1155";
+    readonly receiver: `0x${string}`;
+  };
+} | {
+  readonly status: "ready";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly target: {
+    readonly supported: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "MIGRATION_UNSUPPORTED" | "MIGRATION_NOT_REQUIRED" | "PARENT_NOT_MIGRATED";
+  } | {
+    readonly supported: true;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly route: "unwrapped" | "wrapped-unlocked" | "wrapped-locked" | "locked-child";
+    readonly tokenContract: `0x${string}`;
+    readonly tokenId: bigint;
+    readonly tokenStandard: "erc721" | "erc1155";
+    readonly receiver: `0x${string}`;
+  };
+  readonly migration: {
+    readonly label: string;
+    readonly owner: `0x${string}`;
+    readonly resolver: `0x${string}`;
+    readonly subregistry: `0x${string}`;
+  };
+  readonly warnings: readonly ("SUBREGISTRY_IGNORED_FOR_LOCKED_NAME" | "RESOLVER_MAY_BE_PRESERVED")[];
+}, GetNameStateError>;
+//#endregion
+export { type MigrationReadError as GetMigrationPlanError, GetMigrationPlanParameters, getMigrationPlan };
+//# sourceMappingURL=index.d.ts.map

package/dist/actions/migration/get-migration-plan/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/actions/migration/get-migration-plan/index.ts"],"mappings":";;;;;;;KAcY,6BAA6B;WAC9B,SAAS;WACT,QAAQ;WACR,WAAW;WACX,cAAc;;cAsEZ,kBAIY,cAJI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA"}