@ensforge/sdk 0.0.0

package/dist/groups/events.d.ts

@@ -0,0 +1,66 @@
+import { BoundAction, BoundWatchEnsEvents } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/events.d.ts
+declare const makeEventsActions: (config: EnsforgeConfig) => Readonly<{
+  getEnsEvents: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").GetEnsEventsParameters, readonly {
+    readonly blockNumber: bigint | null;
+    readonly transactionHash: `0x${string}` | null;
+    readonly protocol: "v1" | "v2";
+    readonly raw: {
+      readonly topics: readonly `0x${string}`[];
+      readonly data: `0x${string}`;
+      readonly args: unknown;
+    };
+    readonly kind: "records" | "ownership" | "resolver" | "commitment" | "registration" | "manager" | "renewal" | "subname" | "migration" | "other";
+    readonly contract: `0x${string}`;
+    readonly transactionIndex: number | null;
+    readonly logIndex: number | null;
+    readonly contractKind: "registry" | "name-wrapper" | "resolver" | "registrar" | "migration-controller";
+    readonly eventName: string;
+    readonly removed: boolean;
+    readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+    readonly to?: `0x${string}` | undefined;
+    readonly from?: `0x${string}` | undefined;
+    readonly node?: `0x${string}` | undefined;
+    readonly owner?: `0x${string}` | undefined;
+    readonly resolver?: `0x${string}` | undefined;
+    readonly label?: string | undefined;
+    readonly tokenId?: bigint | undefined;
+    readonly commitment?: `0x${string}` | undefined;
+  }[], import("@ensforge/core").GetEnsEventsError>>;
+  getNameHistory: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").GetNameHistoryParameters, {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly events: readonly {
+      readonly blockNumber: bigint | null;
+      readonly transactionHash: `0x${string}` | null;
+      readonly protocol: "v1" | "v2";
+      readonly raw: {
+        readonly topics: readonly `0x${string}`[];
+        readonly data: `0x${string}`;
+        readonly args: unknown;
+      };
+      readonly kind: "records" | "ownership" | "resolver" | "commitment" | "registration" | "manager" | "renewal" | "subname" | "migration" | "other";
+      readonly contract: `0x${string}`;
+      readonly transactionIndex: number | null;
+      readonly logIndex: number | null;
+      readonly contractKind: "registry" | "name-wrapper" | "resolver" | "registrar" | "migration-controller";
+      readonly eventName: string;
+      readonly removed: boolean;
+      readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+      readonly to?: `0x${string}` | undefined;
+      readonly from?: `0x${string}` | undefined;
+      readonly node?: `0x${string}` | undefined;
+      readonly owner?: `0x${string}` | undefined;
+      readonly resolver?: `0x${string}` | undefined;
+      readonly label?: string | undefined;
+      readonly tokenId?: bigint | undefined;
+      readonly commitment?: `0x${string}` | undefined;
+    }[];
+  }, import("@ensforge/core").GetEnsEventsError>>;
+  watchEnsEvents: BoundWatchEnsEvents;
+}>;
+type EventsActions = ReturnType<typeof makeEventsActions>;
+//#endregion
+export { EventsActions, makeEventsActions };
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","names":[],"sources":["../../src/groups/events.ts"],"mappings":";;;;cAIa,oBAAqB,QAAQ,mBAAc;gBAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO9B,gBAAgB,kBAAkB"}

package/dist/groups/events.js

@@ -0,0 +1,13 @@
+import { bindAction } from "../internal/bind-action.js";
+import { getEnsEvents, getNameHistory, watchEnsEvents } from "@ensforge/core";
+
+//#region src/groups/events.ts
+const makeEventsActions = (config) => Object.freeze({
+	getEnsEvents: bindAction(config, getEnsEvents),
+	getNameHistory: bindAction(config, getNameHistory),
+	watchEnsEvents: bindAction(config, watchEnsEvents)
+});
+
+//#endregion
+export { makeEventsActions };
+//# sourceMappingURL=events.js.map

package/dist/groups/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":[],"sources":["../../src/groups/events.ts"],"sourcesContent":["import { getEnsEvents, getNameHistory, watchEnsEvents, type EnsforgeConfig } from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeEventsActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    getEnsEvents: bindAction(config, getEnsEvents),\n    getNameHistory: bindAction(config, getNameHistory),\n    watchEnsEvents: bindAction(config, watchEnsEvents),\n  });\n\nexport type EventsActions = ReturnType<typeof makeEventsActions>;\n"],"mappings":";;;;AAIA,MAAa,qBAAqB,WAChC,OAAO,OAAO;CACZ,cAAc,WAAW,QAAQ,YAAY;CAC7C,gBAAgB,WAAW,QAAQ,cAAc;CACjD,gBAAgB,WAAW,QAAQ,cAAc;AACnD,CAAC"}

package/dist/groups/index.d.ts

@@ -0,0 +1,15 @@
+import { BatchActions, makeBatchActions } from "./batch.js";
+import { CapabilitiesActions, makeCapabilitiesActions } from "./capabilities.js";
+import { DnsActions, makeDnsActions } from "./dns.js";
+import { EventsActions, makeEventsActions } from "./events.js";
+import { MigrationActions, makeMigrationActions } from "./migration.js";
+import { NameActions, makeNameActions } from "./name.js";
+import { OwnershipActions, makeOwnershipActions } from "./ownership.js";
+import { PermissionsActions, makePermissionsActions } from "./permissions.js";
+import { RecordsActions, makeRecordsActions } from "./records.js";
+import { RegistrationActions, makeRegistrationActions } from "./registration.js";
+import { ResolutionActions, makeResolutionActions } from "./resolution.js";
+import { ReverseActions, makeReverseActions } from "./reverse.js";
+import { SubnameActions, makeSubnameActions } from "./subnames.js";
+import { WrappingActions, makeWrappingActions } from "./wrapping.js";
+export type { BatchActions, CapabilitiesActions, DnsActions, EventsActions, MigrationActions, NameActions, OwnershipActions, PermissionsActions, RecordsActions, RegistrationActions, ResolutionActions, ReverseActions, SubnameActions, WrappingActions };

package/dist/groups/migration.d.ts

@@ -0,0 +1,175 @@
+import { BoundAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/migration.d.ts
+declare const makeMigrationActions: (config: EnsforgeConfig) => Readonly<{
+  approveMigration: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ApproveMigrationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  getMigrationEligibility: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").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")[];
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getMigrationPlan: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").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")[];
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getMigrationStatus: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetMigrationStatusParameters, {
+    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}`;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getMigrationTarget: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetMigrationStatusParameters, {
+    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}`;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  migrateName: BoundAction<import("@ensforge/core").MigrateNameAction>;
+  migrateNames: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").MigrateNamesParameters, import("@ensforge/core").MigrationBatchProgress, import("@ensforge/core").WriteError>>;
+}>;
+type MigrationActions = ReturnType<typeof makeMigrationActions>;
+//#endregion
+export { MigrationActions, makeMigrationActions };
+//# sourceMappingURL=migration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","names":[],"sources":["../../src/groups/migration.ts"],"mappings":";;;;cAaa,uBAAwB,QAAQ,mBAAc;oBAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAWjC,mBAAmB,kBAAkB"}

package/dist/groups/migration.js

@@ -0,0 +1,17 @@
+import { bindAction } from "../internal/bind-action.js";
+import { approveMigration, getMigrationEligibility, getMigrationPlan, getMigrationStatus, getMigrationTarget, migrateName, migrateNames } from "@ensforge/core";
+
+//#region src/groups/migration.ts
+const makeMigrationActions = (config) => Object.freeze({
+	approveMigration: bindAction(config, approveMigration),
+	getMigrationEligibility: bindAction(config, getMigrationEligibility),
+	getMigrationPlan: bindAction(config, getMigrationPlan),
+	getMigrationStatus: bindAction(config, getMigrationStatus),
+	getMigrationTarget: bindAction(config, getMigrationTarget),
+	migrateName: bindAction(config, migrateName),
+	migrateNames: bindAction(config, migrateNames)
+});
+
+//#endregion
+export { makeMigrationActions };
+//# sourceMappingURL=migration.js.map

package/dist/groups/migration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.js","names":[],"sources":["../../src/groups/migration.ts"],"sourcesContent":["import {\n  approveMigration,\n  getMigrationEligibility,\n  getMigrationPlan,\n  getMigrationStatus,\n  getMigrationTarget,\n  migrateName,\n  migrateNames,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeMigrationActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    approveMigration: bindAction(config, approveMigration),\n    getMigrationEligibility: bindAction(config, getMigrationEligibility),\n    getMigrationPlan: bindAction(config, getMigrationPlan),\n    getMigrationStatus: bindAction(config, getMigrationStatus),\n    getMigrationTarget: bindAction(config, getMigrationTarget),\n    migrateName: bindAction(config, migrateName),\n    migrateNames: bindAction(config, migrateNames),\n  });\n\nexport type MigrationActions = ReturnType<typeof makeMigrationActions>;\n"],"mappings":";;;;AAaA,MAAa,wBAAwB,WACnC,OAAO,OAAO;CACZ,kBAAkB,WAAW,QAAQ,gBAAgB;CACrD,yBAAyB,WAAW,QAAQ,uBAAuB;CACnE,kBAAkB,WAAW,QAAQ,gBAAgB;CACrD,oBAAoB,WAAW,QAAQ,kBAAkB;CACzD,oBAAoB,WAAW,QAAQ,kBAAkB;CACzD,aAAa,WAAW,QAAQ,WAAW;CAC3C,cAAc,WAAW,QAAQ,YAAY;AAC/C,CAAC"}

package/dist/groups/name.d.ts

@@ -0,0 +1,146 @@
+import { BoundAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/name.d.ts
+declare const makeNameActions: (config: EnsforgeConfig) => Readonly<{
+  getCanonicalResource: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, bigint | null, import("@ensforge/core").GetCanonicalResourceError>>;
+  getExpiry: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetExpiryParameters, {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly expiry: bigint;
+    readonly gracePeriod: bigint;
+    readonly gracePeriodEnd: bigint;
+    readonly protocol: "v1" | "v2";
+    readonly source: "registry" | "nameWrapper" | "baseRegistrar";
+  } | null, import("@ensforge/core").GetExpiryError>>;
+  getManager: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}` | null, import("@ensforge/core").GetCanonicalResourceError>>;
+  getNameState: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, {
+    readonly kind: "available";
+    readonly protocol: "v1" | "v2";
+    readonly wrapped: false;
+    readonly migrated: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+    readonly owner: `0x${string}` | null;
+    readonly manager: `0x${string}` | null;
+    readonly registrant: `0x${string}` | null;
+    readonly registry: `0x${string}`;
+    readonly resolver: `0x${string}` | null;
+    readonly expiry: bigint | null;
+    readonly gracePeriodEnd: bigint | null;
+    readonly tokenId: bigint | null;
+    readonly resource: bigint | null;
+    readonly available: boolean;
+    readonly renewable: boolean;
+  } | {
+    readonly kind: "v1-unwrapped";
+    readonly protocol: "v1";
+    readonly wrapped: false;
+    readonly migrated: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+    readonly owner: `0x${string}` | null;
+    readonly manager: `0x${string}` | null;
+    readonly registrant: `0x${string}` | null;
+    readonly registry: `0x${string}`;
+    readonly resolver: `0x${string}` | null;
+    readonly expiry: bigint | null;
+    readonly gracePeriodEnd: bigint | null;
+    readonly tokenId: bigint | null;
+    readonly resource: bigint | null;
+    readonly available: boolean;
+    readonly renewable: boolean;
+  } | {
+    readonly kind: "v1-wrapped";
+    readonly protocol: "v1";
+    readonly wrapped: true;
+    readonly migrated: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+    readonly owner: `0x${string}` | null;
+    readonly manager: `0x${string}` | null;
+    readonly registrant: `0x${string}` | null;
+    readonly registry: `0x${string}`;
+    readonly resolver: `0x${string}` | null;
+    readonly expiry: bigint | null;
+    readonly gracePeriodEnd: bigint | null;
+    readonly tokenId: bigint | null;
+    readonly resource: bigint | null;
+    readonly available: boolean;
+    readonly renewable: boolean;
+  } | {
+    readonly kind: "v2-native";
+    readonly protocol: "v2";
+    readonly wrapped: boolean;
+    readonly migrated: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+    readonly owner: `0x${string}` | null;
+    readonly manager: `0x${string}` | null;
+    readonly registrant: `0x${string}` | null;
+    readonly registry: `0x${string}`;
+    readonly resolver: `0x${string}` | null;
+    readonly expiry: bigint | null;
+    readonly gracePeriodEnd: bigint | null;
+    readonly tokenId: bigint | null;
+    readonly resource: bigint | null;
+    readonly available: boolean;
+    readonly renewable: boolean;
+  } | {
+    readonly kind: "v2-migrated";
+    readonly protocol: "v2";
+    readonly wrapped: boolean;
+    readonly migrated: true;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+    readonly owner: `0x${string}` | null;
+    readonly manager: `0x${string}` | null;
+    readonly registrant: `0x${string}` | null;
+    readonly registry: `0x${string}`;
+    readonly resolver: `0x${string}` | null;
+    readonly expiry: bigint | null;
+    readonly gracePeriodEnd: bigint | null;
+    readonly tokenId: bigint | null;
+    readonly resource: bigint | null;
+    readonly available: boolean;
+    readonly renewable: boolean;
+  } | {
+    readonly kind: "v2-reserved";
+    readonly protocol: "v1";
+    readonly wrapped: boolean;
+    readonly migrated: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+    readonly owner: `0x${string}` | null;
+    readonly manager: `0x${string}` | null;
+    readonly registrant: `0x${string}` | null;
+    readonly registry: `0x${string}`;
+    readonly resolver: `0x${string}` | null;
+    readonly expiry: bigint | null;
+    readonly gracePeriodEnd: bigint | null;
+    readonly tokenId: bigint | null;
+    readonly resource: bigint | null;
+    readonly available: boolean;
+    readonly renewable: boolean;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getNameStatus: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, "available" | "reserved" | "active" | "grace" | "expired", import("@ensforge/core").GetCanonicalResourceError>>;
+  getOwner: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetOwnerParameters, {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly owner: `0x${string}` | null;
+    readonly registrant: `0x${string}` | null;
+    readonly protocol: "v1" | "v2";
+    readonly ownershipLevel: "registry" | "registrar" | "nameWrapper";
+  } | null, import("@ensforge/core").GetOwnerError>>;
+  getProtocol: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, "v1" | "v2", import("@ensforge/core").GetCanonicalResourceError>>;
+  getRegistrant: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}` | null, import("@ensforge/core").GetCanonicalResourceError>>;
+  getRegistry: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}`, import("@ensforge/core").GetCanonicalResourceError>>;
+  getTokenId: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, bigint | null, import("@ensforge/core").GetCanonicalResourceError>>;
+  isAvailable: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>>;
+  isMigrated: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>>;
+  isRenewable: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>>;
+  isReserved: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>>;
+  isWrapped: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>>;
+}>;
+type NameActions = ReturnType<typeof makeNameActions>;
+//#endregion
+export { NameActions, makeNameActions };
+//# sourceMappingURL=name.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"name.d.ts","names":[],"sources":["../../src/groups/name.ts"],"mappings":";;;;cAqBa,kBAAmB,QAAQ,mBAAc;wBAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmB5B,cAAc,kBAAkB"}

package/dist/groups/name.js

@@ -0,0 +1,25 @@
+import { bindAction } from "../internal/bind-action.js";
+import { getCanonicalResource, getExpiry, getManager, getNameState, getNameStatus, getOwner, getProtocol, getRegistrant, getRegistry, getTokenId, isAvailable, isMigrated, isRenewable, isReserved, isWrapped } from "@ensforge/core";
+
+//#region src/groups/name.ts
+const makeNameActions = (config) => Object.freeze({
+	getCanonicalResource: bindAction(config, getCanonicalResource),
+	getExpiry: bindAction(config, getExpiry),
+	getManager: bindAction(config, getManager),
+	getNameState: bindAction(config, getNameState),
+	getNameStatus: bindAction(config, getNameStatus),
+	getOwner: bindAction(config, getOwner),
+	getProtocol: bindAction(config, getProtocol),
+	getRegistrant: bindAction(config, getRegistrant),
+	getRegistry: bindAction(config, getRegistry),
+	getTokenId: bindAction(config, getTokenId),
+	isAvailable: bindAction(config, isAvailable),
+	isMigrated: bindAction(config, isMigrated),
+	isRenewable: bindAction(config, isRenewable),
+	isReserved: bindAction(config, isReserved),
+	isWrapped: bindAction(config, isWrapped)
+});
+
+//#endregion
+export { makeNameActions };
+//# sourceMappingURL=name.js.map

package/dist/groups/name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"name.js","names":[],"sources":["../../src/groups/name.ts"],"sourcesContent":["import {\n  getCanonicalResource,\n  getExpiry,\n  getManager,\n  getNameState,\n  getNameStatus,\n  getOwner,\n  getProtocol,\n  getRegistrant,\n  getRegistry,\n  getTokenId,\n  isAvailable,\n  isMigrated,\n  isRenewable,\n  isReserved,\n  isWrapped,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeNameActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    getCanonicalResource: bindAction(config, getCanonicalResource),\n    getExpiry: bindAction(config, getExpiry),\n    getManager: bindAction(config, getManager),\n    getNameState: bindAction(config, getNameState),\n    getNameStatus: bindAction(config, getNameStatus),\n    getOwner: bindAction(config, getOwner),\n    getProtocol: bindAction(config, getProtocol),\n    getRegistrant: bindAction(config, getRegistrant),\n    getRegistry: bindAction(config, getRegistry),\n    getTokenId: bindAction(config, getTokenId),\n    isAvailable: bindAction(config, isAvailable),\n    isMigrated: bindAction(config, isMigrated),\n    isRenewable: bindAction(config, isRenewable),\n    isReserved: bindAction(config, isReserved),\n    isWrapped: bindAction(config, isWrapped),\n  });\n\nexport type NameActions = ReturnType<typeof makeNameActions>;\n"],"mappings":";;;;AAqBA,MAAa,mBAAmB,WAC9B,OAAO,OAAO;CACZ,sBAAsB,WAAW,QAAQ,oBAAoB;CAC7D,WAAW,WAAW,QAAQ,SAAS;CACvC,YAAY,WAAW,QAAQ,UAAU;CACzC,cAAc,WAAW,QAAQ,YAAY;CAC7C,eAAe,WAAW,QAAQ,aAAa;CAC/C,UAAU,WAAW,QAAQ,QAAQ;CACrC,aAAa,WAAW,QAAQ,WAAW;CAC3C,eAAe,WAAW,QAAQ,aAAa;CAC/C,aAAa,WAAW,QAAQ,WAAW;CAC3C,YAAY,WAAW,QAAQ,UAAU;CACzC,aAAa,WAAW,QAAQ,WAAW;CAC3C,YAAY,WAAW,QAAQ,UAAU;CACzC,aAAa,WAAW,QAAQ,WAAW;CAC3C,YAAY,WAAW,QAAQ,UAAU;CACzC,WAAW,WAAW,QAAQ,SAAS;AACzC,CAAC"}

package/dist/groups/ownership.d.ts

@@ -0,0 +1,16 @@
+import { BoundAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/ownership.d.ts
+declare const makeOwnershipActions: (config: EnsforgeConfig) => Readonly<{
+  getTtl: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetCanonicalResourceParameters, import("@ensforge/core").GetTtlResult, import("@ensforge/core").GetCanonicalResourceError>>;
+  reclaimName: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ReclaimNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setManager: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetManagerParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setTtl: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetTtlParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  transferName: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").TransferNameParameters, import("@ensforge/core").TransferNameProgress, import("@ensforge/core").WriteError>>;
+  transferRegistrant: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").TransferRegistrantParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+}>;
+type OwnershipActions = ReturnType<typeof makeOwnershipActions>;
+//#endregion
+export { OwnershipActions, makeOwnershipActions };
+//# sourceMappingURL=ownership.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.d.ts","names":[],"sources":["../../src/groups/ownership.ts"],"mappings":";;;;cAYa,uBAAwB,QAAQ,mBAAc;UAAd;;;;;;;KAUjC,mBAAmB,kBAAkB"}

package/dist/groups/ownership.js

@@ -0,0 +1,16 @@
+import { bindAction } from "../internal/bind-action.js";
+import { getTtl, reclaimName, setManager, setTtl, transferName, transferRegistrant } from "@ensforge/core";
+
+//#region src/groups/ownership.ts
+const makeOwnershipActions = (config) => Object.freeze({
+	getTtl: bindAction(config, getTtl),
+	reclaimName: bindAction(config, reclaimName),
+	setManager: bindAction(config, setManager),
+	setTtl: bindAction(config, setTtl),
+	transferName: bindAction(config, transferName),
+	transferRegistrant: bindAction(config, transferRegistrant)
+});
+
+//#endregion
+export { makeOwnershipActions };
+//# sourceMappingURL=ownership.js.map

package/dist/groups/ownership.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.js","names":[],"sources":["../../src/groups/ownership.ts"],"sourcesContent":["import {\n  getTtl,\n  reclaimName,\n  setManager,\n  setTtl,\n  transferName,\n  transferRegistrant,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeOwnershipActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    getTtl: bindAction(config, getTtl),\n    reclaimName: bindAction(config, reclaimName),\n    setManager: bindAction(config, setManager),\n    setTtl: bindAction(config, setTtl),\n    transferName: bindAction(config, transferName),\n    transferRegistrant: bindAction(config, transferRegistrant),\n  });\n\nexport type OwnershipActions = ReturnType<typeof makeOwnershipActions>;\n"],"mappings":";;;;AAYA,MAAa,wBAAwB,WACnC,OAAO,OAAO;CACZ,QAAQ,WAAW,QAAQ,MAAM;CACjC,aAAa,WAAW,QAAQ,WAAW;CAC3C,YAAY,WAAW,QAAQ,UAAU;CACzC,QAAQ,WAAW,QAAQ,MAAM;CACjC,cAAc,WAAW,QAAQ,YAAY;CAC7C,oBAAoB,WAAW,QAAQ,kBAAkB;AAC3D,CAAC"}

package/dist/groups/permissions.d.ts

@@ -0,0 +1,21 @@
+import { BoundAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/permissions.d.ts
+declare const makePermissionsActions: (config: EnsforgeConfig) => Readonly<{
+  approveName: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ApproveNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  clearNameApproval: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ClearNameApprovalParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  grantRegistryRoles: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").RegistryRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  grantResolverRoles: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ResolverRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  grantResolverRootRoles: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ResolverRootRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  revokeRegistryRoles: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").RegistryRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  revokeResolverRoles: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ResolverRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  revokeResolverRootRoles: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ResolverRootRolesMutationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setOperatorApproval: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetOperatorApprovalParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setRecordPermissions: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").SetRecordPermissionsParameters, import("@ensforge/core").SetRecordPermissionsResult, import("@ensforge/core").WriteError>>;
+  setResolverDelegateApproval: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetResolverDelegateApprovalParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+}>;
+type PermissionsActions = ReturnType<typeof makePermissionsActions>;
+//#endregion
+export { PermissionsActions, makePermissionsActions };
+//# sourceMappingURL=permissions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","names":[],"sources":["../../src/groups/permissions.ts"],"mappings":";;;;cAiBa,yBAA0B,QAAQ,mBAAc;eAAd;;;;;;;;;;;;KAenC,qBAAqB,kBAAkB"}

package/dist/groups/permissions.js

@@ -0,0 +1,21 @@
+import { bindAction } from "../internal/bind-action.js";
+import { approveName, clearNameApproval, grantRegistryRoles, grantResolverRoles, grantResolverRootRoles, revokeRegistryRoles, revokeResolverRoles, revokeResolverRootRoles, setOperatorApproval, setRecordPermissions, setResolverDelegateApproval } from "@ensforge/core";
+
+//#region src/groups/permissions.ts
+const makePermissionsActions = (config) => Object.freeze({
+	approveName: bindAction(config, approveName),
+	clearNameApproval: bindAction(config, clearNameApproval),
+	grantRegistryRoles: bindAction(config, grantRegistryRoles),
+	grantResolverRoles: bindAction(config, grantResolverRoles),
+	grantResolverRootRoles: bindAction(config, grantResolverRootRoles),
+	revokeRegistryRoles: bindAction(config, revokeRegistryRoles),
+	revokeResolverRoles: bindAction(config, revokeResolverRoles),
+	revokeResolverRootRoles: bindAction(config, revokeResolverRootRoles),
+	setOperatorApproval: bindAction(config, setOperatorApproval),
+	setRecordPermissions: bindAction(config, setRecordPermissions),
+	setResolverDelegateApproval: bindAction(config, setResolverDelegateApproval)
+});
+
+//#endregion
+export { makePermissionsActions };
+//# sourceMappingURL=permissions.js.map

package/dist/groups/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.js","names":[],"sources":["../../src/groups/permissions.ts"],"sourcesContent":["import {\n  approveName,\n  clearNameApproval,\n  grantRegistryRoles,\n  grantResolverRoles,\n  grantResolverRootRoles,\n  revokeRegistryRoles,\n  revokeResolverRoles,\n  revokeResolverRootRoles,\n  setOperatorApproval,\n  setRecordPermissions,\n  setResolverDelegateApproval,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makePermissionsActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    approveName: bindAction(config, approveName),\n    clearNameApproval: bindAction(config, clearNameApproval),\n    grantRegistryRoles: bindAction(config, grantRegistryRoles),\n    grantResolverRoles: bindAction(config, grantResolverRoles),\n    grantResolverRootRoles: bindAction(config, grantResolverRootRoles),\n    revokeRegistryRoles: bindAction(config, revokeRegistryRoles),\n    revokeResolverRoles: bindAction(config, revokeResolverRoles),\n    revokeResolverRootRoles: bindAction(config, revokeResolverRootRoles),\n    setOperatorApproval: bindAction(config, setOperatorApproval),\n    setRecordPermissions: bindAction(config, setRecordPermissions),\n    setResolverDelegateApproval: bindAction(config, setResolverDelegateApproval),\n  });\n\nexport type PermissionsActions = ReturnType<typeof makePermissionsActions>;\n"],"mappings":";;;;AAiBA,MAAa,0BAA0B,WACrC,OAAO,OAAO;CACZ,aAAa,WAAW,QAAQ,WAAW;CAC3C,mBAAmB,WAAW,QAAQ,iBAAiB;CACvD,oBAAoB,WAAW,QAAQ,kBAAkB;CACzD,oBAAoB,WAAW,QAAQ,kBAAkB;CACzD,wBAAwB,WAAW,QAAQ,sBAAsB;CACjE,qBAAqB,WAAW,QAAQ,mBAAmB;CAC3D,qBAAqB,WAAW,QAAQ,mBAAmB;CAC3D,yBAAyB,WAAW,QAAQ,uBAAuB;CACnE,qBAAqB,WAAW,QAAQ,mBAAmB;CAC3D,sBAAsB,WAAW,QAAQ,oBAAoB;CAC7D,6BAA6B,WAAW,QAAQ,2BAA2B;AAC7E,CAAC"}