@ensforge/sdk 0.0.0

package/dist/groups/capabilities.d.ts

@@ -0,0 +1,536 @@
+import { BoundAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/capabilities.d.ts
+declare const makeCapabilitiesActions: (config: EnsforgeConfig) => Readonly<{
+  getNameCapabilities: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetNameCapabilitiesParameters, {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly account: `0x${string}`;
+    readonly registry: {
+      readonly address: `0x${string}`;
+      readonly protocol: "v1" | "v2";
+      readonly kind: "registry" | "name-wrapper" | "permissioned-registry" | "wrapper-registry";
+      readonly owned: boolean;
+      readonly permissioned: boolean;
+      readonly temporal: boolean;
+      readonly tokenized: boolean;
+      readonly wrapped: boolean;
+      readonly setOwner: boolean;
+      readonly setResolver: boolean;
+      readonly createSubname: boolean;
+      readonly transfer: boolean;
+      readonly setExpiry: boolean;
+    };
+    readonly resolver: {
+      readonly address: `0x${string}` | null;
+      readonly node: `0x${string}` & import("effect/Brand").Brand<"Namehash">;
+      readonly inherited: boolean;
+      readonly extended: boolean;
+      readonly permissioned: boolean;
+      readonly authorization: "unknown" | "none" | "owner-delegate" | "role";
+      readonly profiles: {
+        readonly address: boolean;
+        readonly text: boolean;
+        readonly contentHash: boolean;
+        readonly abi: boolean;
+        readonly pubkey: boolean;
+        readonly interface: boolean;
+        readonly name: boolean;
+        readonly data: boolean;
+        readonly dnsRecord: boolean;
+        readonly dnsZone: boolean;
+      };
+    };
+    readonly records: readonly {
+      readonly record: {
+        readonly type: "address";
+        readonly coinType: bigint;
+      } | {
+        readonly type: "text";
+        readonly key: string;
+      } | {
+        readonly type: "contentHash";
+      } | {
+        readonly type: "pubkey";
+      } | {
+        readonly type: "abi";
+        readonly contentType?: bigint | undefined;
+      } | {
+        readonly type: "interface";
+        readonly interfaceId?: (`0x${string}` & import("effect/Brand").Brand<"InterfaceId">) | undefined;
+      } | {
+        readonly type: "name";
+      } | {
+        readonly type: "data";
+        readonly key: string;
+      } | {
+        readonly type: "alias";
+      } | {
+        readonly type: "dnsRecord";
+      } | {
+        readonly type: "dnsZone";
+      } | {
+        readonly type: "clear";
+      };
+      readonly supported: boolean;
+      readonly authorization: {
+        readonly status: "authorized";
+        readonly source: "owner" | "operator-approval" | "token-approval" | "resolver-delegate" | "registry-role" | "resolver-role" | "wrapper-permission";
+      } | {
+        readonly status: "unauthorized";
+        readonly requirement: {
+          readonly kind: "none";
+        } | {
+          readonly kind: "owner";
+        } | {
+          readonly kind: "operator-approval";
+        } | {
+          readonly kind: "token-approval";
+        } | {
+          readonly kind: "resolver-delegate";
+        } | {
+          readonly kind: "registry-role";
+          readonly roles: bigint;
+          readonly resource: bigint;
+        } | {
+          readonly kind: "resolver-role";
+          readonly roles: bigint;
+          readonly resource: bigint;
+        } | {
+          readonly kind: "wrapper-permission";
+        } | {
+          readonly kind: "unsupported";
+        };
+      } | {
+        readonly status: "unknown";
+        readonly reason: "CUSTOM_RESOLVER";
+      };
+      readonly requiredRole: bigint;
+      readonly resource: bigint | null;
+    }[];
+    readonly ownership: {
+      readonly setOwner: boolean;
+      readonly setResolver: boolean;
+      readonly createSubname: boolean;
+      readonly transfer: boolean;
+      readonly setExpiry: boolean;
+    };
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getOperatorApproval: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetOperatorApprovalParameters, {
+    readonly owner: `0x${string}`;
+    readonly operator: `0x${string}`;
+    readonly targets: readonly {
+      readonly kind: "registry" | "resolver" | "registrar" | "wrapper";
+      readonly address: `0x${string}`;
+      readonly supported: boolean;
+      readonly approved: boolean;
+    }[];
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getRecordPermissions: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetRecordPermissionsParameters, {
+    readonly resolver: `0x${string}` | null;
+    readonly inherited: boolean;
+    readonly account: `0x${string}`;
+    readonly records: readonly {
+      readonly record: {
+        readonly type: "address";
+        readonly coinType: bigint;
+      } | {
+        readonly type: "text";
+        readonly key: string;
+      } | {
+        readonly type: "contentHash";
+      } | {
+        readonly type: "pubkey";
+      } | {
+        readonly type: "abi";
+        readonly contentType?: bigint | undefined;
+      } | {
+        readonly type: "interface";
+        readonly interfaceId?: (`0x${string}` & import("effect/Brand").Brand<"InterfaceId">) | undefined;
+      } | {
+        readonly type: "name";
+      } | {
+        readonly type: "data";
+        readonly key: string;
+      } | {
+        readonly type: "alias";
+      } | {
+        readonly type: "dnsRecord";
+      } | {
+        readonly type: "dnsZone";
+      } | {
+        readonly type: "clear";
+      };
+      readonly supported: boolean;
+      readonly authorization: {
+        readonly status: "authorized";
+        readonly source: "owner" | "operator-approval" | "token-approval" | "resolver-delegate" | "registry-role" | "resolver-role" | "wrapper-permission";
+      } | {
+        readonly status: "unauthorized";
+        readonly requirement: {
+          readonly kind: "none";
+        } | {
+          readonly kind: "owner";
+        } | {
+          readonly kind: "operator-approval";
+        } | {
+          readonly kind: "token-approval";
+        } | {
+          readonly kind: "resolver-delegate";
+        } | {
+          readonly kind: "registry-role";
+          readonly roles: bigint;
+          readonly resource: bigint;
+        } | {
+          readonly kind: "resolver-role";
+          readonly roles: bigint;
+          readonly resource: bigint;
+        } | {
+          readonly kind: "wrapper-permission";
+        } | {
+          readonly kind: "unsupported";
+        };
+      } | {
+        readonly status: "unknown";
+        readonly reason: "CUSTOM_RESOLVER";
+      };
+      readonly requiredRole: bigint;
+      readonly resource: bigint | null;
+    }[];
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getRegistryCapabilities: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetRegistryCapabilitiesParameters, {
+    readonly address: `0x${string}`;
+    readonly protocol: "v1" | "v2";
+    readonly kind: "registry" | "name-wrapper" | "permissioned-registry" | "wrapper-registry";
+    readonly owned: boolean;
+    readonly permissioned: boolean;
+    readonly temporal: boolean;
+    readonly tokenized: boolean;
+    readonly wrapped: boolean;
+    readonly setOwner: boolean;
+    readonly setResolver: boolean;
+    readonly createSubname: boolean;
+    readonly transfer: boolean;
+    readonly setExpiry: boolean;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getRegistryRoles: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetRegistryRolesParameters, {
+    readonly supported: false;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "RESOLVER_NOT_FOUND" | "ROLE_BASED_PERMISSIONS_UNSUPPORTED";
+  } | {
+    readonly supported: true;
+    readonly protocol: "v2";
+    readonly registry: `0x${string}`;
+    readonly resource: bigint;
+    readonly account: `0x${string}`;
+    readonly roles: bigint;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getRequiredAuthorization: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetRequiredAuthorizationParameters, {
+    readonly account: `0x${string}`;
+    readonly operation: {
+      readonly type: "address";
+      readonly coinType: bigint;
+    } | {
+      readonly type: "text";
+      readonly key: string;
+    } | {
+      readonly type: "contentHash";
+    } | {
+      readonly type: "pubkey";
+    } | {
+      readonly type: "abi";
+      readonly contentType?: bigint | undefined;
+    } | {
+      readonly type: "interface";
+      readonly interfaceId?: (`0x${string}` & import("effect/Brand").Brand<"InterfaceId">) | undefined;
+    } | {
+      readonly type: "name";
+    } | {
+      readonly type: "data";
+      readonly key: string;
+    } | {
+      readonly type: "alias";
+    } | {
+      readonly type: "dnsRecord";
+    } | {
+      readonly type: "dnsZone";
+    } | {
+      readonly type: "clear";
+    } | {
+      readonly type: "setOwner";
+    } | {
+      readonly type: "setTtl";
+    } | {
+      readonly type: "setResolver";
+    } | {
+      readonly type: "createSubname";
+    } | {
+      readonly type: "transfer";
+    } | {
+      readonly type: "setExpiry";
+    };
+    readonly target: {
+      readonly available: false;
+      readonly protocol: "v1" | "v2";
+      readonly reason: "NAME_NOT_REGISTERED" | "RESOLVER_NOT_FOUND" | "OPERATION_UNSUPPORTED";
+    } | {
+      readonly available: true;
+      readonly protocol: "v1" | "v2";
+      readonly kind: "registry" | "name-wrapper" | "wrapper-registry" | "resolver" | "registrar";
+      readonly address: `0x${string}`;
+      readonly operation: {
+        readonly type: "address";
+        readonly coinType: bigint;
+      } | {
+        readonly type: "text";
+        readonly key: string;
+      } | {
+        readonly type: "contentHash";
+      } | {
+        readonly type: "pubkey";
+      } | {
+        readonly type: "abi";
+        readonly contentType?: bigint | undefined;
+      } | {
+        readonly type: "interface";
+        readonly interfaceId?: (`0x${string}` & import("effect/Brand").Brand<"InterfaceId">) | undefined;
+      } | {
+        readonly type: "name";
+      } | {
+        readonly type: "data";
+        readonly key: string;
+      } | {
+        readonly type: "alias";
+      } | {
+        readonly type: "dnsRecord";
+      } | {
+        readonly type: "dnsZone";
+      } | {
+        readonly type: "clear";
+      } | {
+        readonly type: "setOwner";
+      } | {
+        readonly type: "setTtl";
+      } | {
+        readonly type: "setResolver";
+      } | {
+        readonly type: "createSubname";
+      } | {
+        readonly type: "transfer";
+      } | {
+        readonly type: "setExpiry";
+      };
+      readonly node: `0x${string}` & import("effect/Brand").Brand<"Namehash">;
+      readonly tokenId: bigint | null;
+      readonly resource: bigint | null;
+      readonly inheritedResolver: boolean;
+    };
+    readonly authorization: {
+      readonly status: "authorized";
+      readonly source: "owner" | "operator-approval" | "token-approval" | "resolver-delegate" | "registry-role" | "resolver-role" | "wrapper-permission";
+    } | {
+      readonly status: "unauthorized";
+      readonly requirement: {
+        readonly kind: "none";
+      } | {
+        readonly kind: "owner";
+      } | {
+        readonly kind: "operator-approval";
+      } | {
+        readonly kind: "token-approval";
+      } | {
+        readonly kind: "resolver-delegate";
+      } | {
+        readonly kind: "registry-role";
+        readonly roles: bigint;
+        readonly resource: bigint;
+      } | {
+        readonly kind: "resolver-role";
+        readonly roles: bigint;
+        readonly resource: bigint;
+      } | {
+        readonly kind: "wrapper-permission";
+      } | {
+        readonly kind: "unsupported";
+      };
+    } | {
+      readonly status: "unknown";
+      readonly reason: "CUSTOM_RESOLVER";
+    };
+    readonly blockers: readonly ("NAME_NOT_REGISTERED" | "RESOLVER_NOT_FOUND" | "OPERATION_UNSUPPORTED" | "WRAPPER_FUSE" | "TRANSFER_ROLE")[];
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getResolverCapabilities: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetRegistryCapabilitiesParameters, {
+    readonly address: `0x${string}` | null;
+    readonly node: `0x${string}` & import("effect/Brand").Brand<"Namehash">;
+    readonly inherited: boolean;
+    readonly extended: boolean;
+    readonly permissioned: boolean;
+    readonly authorization: "unknown" | "none" | "owner-delegate" | "role";
+    readonly profiles: {
+      readonly address: boolean;
+      readonly text: boolean;
+      readonly contentHash: boolean;
+      readonly abi: boolean;
+      readonly pubkey: boolean;
+      readonly interface: boolean;
+      readonly name: boolean;
+      readonly data: boolean;
+      readonly dnsRecord: boolean;
+      readonly dnsZone: boolean;
+    };
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getResolverDelegateApproval: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetResolverDelegateApprovalParameters, {
+    readonly supported: false;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "RESOLVER_NOT_FOUND" | "DELEGATE_APPROVAL_UNSUPPORTED";
+  } | {
+    readonly supported: true;
+    readonly protocol: "v1" | "v2";
+    readonly resolver: `0x${string}`;
+    readonly owner: `0x${string}`;
+    readonly delegate: `0x${string}`;
+    readonly approved: boolean;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getResolverRoles: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetResolverRolesParameters, {
+    readonly supported: false;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "RESOLVER_NOT_FOUND" | "ROLE_BASED_PERMISSIONS_UNSUPPORTED";
+  } | {
+    readonly supported: true;
+    readonly protocol: "v2";
+    readonly resolver: `0x${string}`;
+    readonly resource: bigint;
+    readonly account: `0x${string}`;
+    readonly roles: bigint;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getTokenApproval: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetRegistryCapabilitiesParameters, {
+    readonly supported: false;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "PER_TOKEN_APPROVAL_UNSUPPORTED" | "NAME_NOT_TOKENIZED";
+  } | {
+    readonly supported: true;
+    readonly protocol: "v1";
+    readonly kind: "name-wrapper" | "registrar";
+    readonly contract: `0x${string}`;
+    readonly tokenId: bigint;
+    readonly approved: `0x${string}` | null;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getWrapperPermissions: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetRegistryRolesParameters, {
+    readonly supported: false;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "NAME_NOT_WRAPPED";
+  } | {
+    readonly supported: true;
+    readonly protocol: "v1";
+    readonly wrapper: `0x${string}`;
+    readonly account: `0x${string}`;
+    readonly owner: `0x${string}`;
+    readonly tokenId: bigint;
+    readonly fuses: number;
+    readonly expiry: bigint;
+    readonly approved: `0x${string}` | null;
+    readonly operatorApproved: boolean;
+    readonly canModify: boolean;
+    readonly canExtendSubnames: boolean;
+    readonly canUnwrap: boolean;
+    readonly canTransfer: boolean;
+    readonly canSetResolver: boolean;
+    readonly canSetTtl: boolean;
+    readonly canCreateSubname: boolean;
+    readonly canApprove: boolean;
+  } | {
+    readonly supported: true;
+    readonly protocol: "v2";
+    readonly wrapper: `0x${string}`;
+    readonly account: `0x${string}`;
+    readonly resource: bigint;
+    readonly roles: bigint;
+    readonly operatorApproved: boolean;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  getWriteTarget: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetWriteTargetParameters, {
+    readonly available: false;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "NAME_NOT_REGISTERED" | "RESOLVER_NOT_FOUND" | "OPERATION_UNSUPPORTED";
+  } | {
+    readonly available: true;
+    readonly protocol: "v1" | "v2";
+    readonly kind: "registry" | "name-wrapper" | "wrapper-registry" | "resolver" | "registrar";
+    readonly address: `0x${string}`;
+    readonly operation: {
+      readonly type: "address";
+      readonly coinType: bigint;
+    } | {
+      readonly type: "text";
+      readonly key: string;
+    } | {
+      readonly type: "contentHash";
+    } | {
+      readonly type: "pubkey";
+    } | {
+      readonly type: "abi";
+      readonly contentType?: bigint | undefined;
+    } | {
+      readonly type: "interface";
+      readonly interfaceId?: (`0x${string}` & import("effect/Brand").Brand<"InterfaceId">) | undefined;
+    } | {
+      readonly type: "name";
+    } | {
+      readonly type: "data";
+      readonly key: string;
+    } | {
+      readonly type: "alias";
+    } | {
+      readonly type: "dnsRecord";
+    } | {
+      readonly type: "dnsZone";
+    } | {
+      readonly type: "clear";
+    } | {
+      readonly type: "setOwner";
+    } | {
+      readonly type: "setTtl";
+    } | {
+      readonly type: "setResolver";
+    } | {
+      readonly type: "createSubname";
+    } | {
+      readonly type: "transfer";
+    } | {
+      readonly type: "setExpiry";
+    };
+    readonly node: `0x${string}` & import("effect/Brand").Brand<"Namehash">;
+    readonly tokenId: bigint | null;
+    readonly resource: bigint | null;
+    readonly inheritedResolver: boolean;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  hasRegistryRoles: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").HasRegistryRolesParameters, {
+    readonly supported: false;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "RESOLVER_NOT_FOUND" | "ROLE_BASED_PERMISSIONS_UNSUPPORTED";
+  } | {
+    readonly supported: true;
+    readonly protocol: "v2";
+    readonly registry: `0x${string}`;
+    readonly resource: bigint;
+    readonly account: `0x${string}`;
+    readonly roles: bigint;
+    readonly authorized: boolean;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+  hasResolverRoles: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").HasResolverRolesParameters, {
+    readonly supported: false;
+    readonly protocol: "v1" | "v2";
+    readonly reason: "RESOLVER_NOT_FOUND" | "ROLE_BASED_PERMISSIONS_UNSUPPORTED";
+  } | {
+    readonly supported: true;
+    readonly protocol: "v2";
+    readonly resolver: `0x${string}`;
+    readonly resource: bigint;
+    readonly account: `0x${string}`;
+    readonly roles: bigint;
+    readonly authorized: boolean;
+  }, import("@ensforge/core").GetCanonicalResourceError>>;
+}>;
+type CapabilitiesActions = ReturnType<typeof makeCapabilitiesActions>;
+//#endregion
+export { CapabilitiesActions, makeCapabilitiesActions };
+//# sourceMappingURL=capabilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","names":[],"sources":["../../src/groups/capabilities.ts"],"mappings":";;;;cAoBa,0BAA2B,QAAQ,mBAAc;uBAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkBpC,sBAAsB,kBAAkB"}

package/dist/groups/capabilities.js

@@ -0,0 +1,24 @@
+import { bindAction } from "../internal/bind-action.js";
+import { getNameCapabilities, getOperatorApproval, getRecordPermissions, getRegistryCapabilities, getRegistryRoles, getRequiredAuthorization, getResolverCapabilities, getResolverDelegateApproval, getResolverRoles, getTokenApproval, getWrapperPermissions, getWriteTarget, hasRegistryRoles, hasResolverRoles } from "@ensforge/core";
+
+//#region src/groups/capabilities.ts
+const makeCapabilitiesActions = (config) => Object.freeze({
+	getNameCapabilities: bindAction(config, getNameCapabilities),
+	getOperatorApproval: bindAction(config, getOperatorApproval),
+	getRecordPermissions: bindAction(config, getRecordPermissions),
+	getRegistryCapabilities: bindAction(config, getRegistryCapabilities),
+	getRegistryRoles: bindAction(config, getRegistryRoles),
+	getRequiredAuthorization: bindAction(config, getRequiredAuthorization),
+	getResolverCapabilities: bindAction(config, getResolverCapabilities),
+	getResolverDelegateApproval: bindAction(config, getResolverDelegateApproval),
+	getResolverRoles: bindAction(config, getResolverRoles),
+	getTokenApproval: bindAction(config, getTokenApproval),
+	getWrapperPermissions: bindAction(config, getWrapperPermissions),
+	getWriteTarget: bindAction(config, getWriteTarget),
+	hasRegistryRoles: bindAction(config, hasRegistryRoles),
+	hasResolverRoles: bindAction(config, hasResolverRoles)
+});
+
+//#endregion
+export { makeCapabilitiesActions };
+//# sourceMappingURL=capabilities.js.map

package/dist/groups/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","names":[],"sources":["../../src/groups/capabilities.ts"],"sourcesContent":["import {\n  getNameCapabilities,\n  getOperatorApproval,\n  getRecordPermissions,\n  getRegistryCapabilities,\n  getRegistryRoles,\n  getRequiredAuthorization,\n  getResolverCapabilities,\n  getResolverDelegateApproval,\n  getResolverRoles,\n  getTokenApproval,\n  getWrapperPermissions,\n  getWriteTarget,\n  hasRegistryRoles,\n  hasResolverRoles,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeCapabilitiesActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    getNameCapabilities: bindAction(config, getNameCapabilities),\n    getOperatorApproval: bindAction(config, getOperatorApproval),\n    getRecordPermissions: bindAction(config, getRecordPermissions),\n    getRegistryCapabilities: bindAction(config, getRegistryCapabilities),\n    getRegistryRoles: bindAction(config, getRegistryRoles),\n    getRequiredAuthorization: bindAction(config, getRequiredAuthorization),\n    getResolverCapabilities: bindAction(config, getResolverCapabilities),\n    getResolverDelegateApproval: bindAction(config, getResolverDelegateApproval),\n    getResolverRoles: bindAction(config, getResolverRoles),\n    getTokenApproval: bindAction(config, getTokenApproval),\n    getWrapperPermissions: bindAction(config, getWrapperPermissions),\n    getWriteTarget: bindAction(config, getWriteTarget),\n    hasRegistryRoles: bindAction(config, hasRegistryRoles),\n    hasResolverRoles: bindAction(config, hasResolverRoles),\n  });\n\nexport type CapabilitiesActions = ReturnType<typeof makeCapabilitiesActions>;\n"],"mappings":";;;;AAoBA,MAAa,2BAA2B,WACtC,OAAO,OAAO;CACZ,qBAAqB,WAAW,QAAQ,mBAAmB;CAC3D,qBAAqB,WAAW,QAAQ,mBAAmB;CAC3D,sBAAsB,WAAW,QAAQ,oBAAoB;CAC7D,yBAAyB,WAAW,QAAQ,uBAAuB;CACnE,kBAAkB,WAAW,QAAQ,gBAAgB;CACrD,0BAA0B,WAAW,QAAQ,wBAAwB;CACrE,yBAAyB,WAAW,QAAQ,uBAAuB;CACnE,6BAA6B,WAAW,QAAQ,2BAA2B;CAC3E,kBAAkB,WAAW,QAAQ,gBAAgB;CACrD,kBAAkB,WAAW,QAAQ,gBAAgB;CACrD,uBAAuB,WAAW,QAAQ,qBAAqB;CAC/D,gBAAgB,WAAW,QAAQ,cAAc;CACjD,kBAAkB,WAAW,QAAQ,gBAAgB;CACrD,kBAAkB,WAAW,QAAQ,gBAAgB;AACvD,CAAC"}

package/dist/groups/dns.d.ts

@@ -0,0 +1,79 @@
+import { BoundAction } from "../internal/bind-action.js";
+import "../index.js";
+import { EnsforgeConfig } from "@ensforge/core";
+//#region src/groups/dns.d.ts
+declare const makeDnsActions: (config: EnsforgeConfig) => Readonly<{
+  claimDnsName: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").ClaimDnsNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  getDnsClaimStatus: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetDnsClaimStatusParameters, {
+    readonly status: "unsupported";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+  } | {
+    readonly status: "claimed";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly owner: `0x${string}`;
+    readonly resolver: `0x${string}` | null;
+    readonly previousInception: bigint;
+  } | {
+    readonly status: "proof-required";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly previousInception: bigint;
+  }, import("@ensforge/core").GetDnsClaimStatusError>>;
+  getDnsImportPlan: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetDnsImportPlanParameters, {
+    readonly status: "unsupported";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+  } | {
+    readonly status: "already-claimed";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly registrar: `0x${string}`;
+    readonly oracle: `0x${string}`;
+    readonly owner: `0x${string}`;
+    readonly resolver: `0x${string}` | null;
+  } | {
+    readonly status: "proof-required";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly registrar: `0x${string}`;
+    readonly oracle: `0x${string}`;
+    readonly proofRequest: {
+      readonly name: `0x${string}` & import("effect/Brand").Brand<"DnsEncodedName">;
+      readonly previousInception: bigint;
+    };
+  }, import("@ensforge/core").GetDnsClaimStatusError>>;
+  getDnsRecord: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetDnsRecordParameters, {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resource: number;
+    readonly resolver: `0x${string}` | null;
+    readonly value: `0x${string}` | null;
+  }, import("@ensforge/core").GetDnsClaimStatusError>>;
+  getDnsRecords: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetDnsRecordsParameters, {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resolver: `0x${string}` | null;
+    readonly records: readonly {
+      readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+      readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+      readonly resource: number;
+      readonly resolver: `0x${string}` | null;
+      readonly value: `0x${string}` | null;
+    }[];
+  }, import("@ensforge/core").GetDnsClaimStatusError>>;
+  getZoneHash: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").GetZoneHashParameters, {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resolver: `0x${string}` | null;
+    readonly value: `0x${string}` | null;
+  }, import("@ensforge/core").GetDnsClaimStatusError>>;
+  hasDnsRecords: BoundAction<import("@ensforge/core").EnsReadAction<import("@ensforge/core").HasDnsRecordsParameters, {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resolver: `0x${string}` | null;
+    readonly exists: boolean;
+  }, import("@ensforge/core").GetDnsClaimStatusError>>;
+  importDnsName: BoundAction<import("@ensforge/core").EnsAction<import("@ensforge/core").ImportDnsNameParameters, import("@ensforge/core").ImportDnsNameResult, import("@ensforge/core").WriteError>>;
+  setDnsRecords: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetDnsRecordsParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+  setZoneHash: BoundAction<import("@ensforge/core").EnsWriteAction<import("@ensforge/core").SetZoneHashParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>>;
+}>;
+type DnsActions = ReturnType<typeof makeDnsActions>;
+//#endregion
+export { DnsActions, makeDnsActions };
+//# sourceMappingURL=dns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dns.d.ts","names":[],"sources":["../../src/groups/dns.ts"],"mappings":";;;;cAgBa,iBAAkB,QAAQ,mBAAc;gBAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAc3B,aAAa,kBAAkB"}

package/dist/groups/dns.js

@@ -0,0 +1,20 @@
+import { bindAction } from "../internal/bind-action.js";
+import { claimDnsName, getDnsClaimStatus, getDnsImportPlan, getDnsRecord, getDnsRecords, getZoneHash, hasDnsRecords, importDnsName, setDnsRecords, setZoneHash } from "@ensforge/core";
+
+//#region src/groups/dns.ts
+const makeDnsActions = (config) => Object.freeze({
+	claimDnsName: bindAction(config, claimDnsName),
+	getDnsClaimStatus: bindAction(config, getDnsClaimStatus),
+	getDnsImportPlan: bindAction(config, getDnsImportPlan),
+	getDnsRecord: bindAction(config, getDnsRecord),
+	getDnsRecords: bindAction(config, getDnsRecords),
+	getZoneHash: bindAction(config, getZoneHash),
+	hasDnsRecords: bindAction(config, hasDnsRecords),
+	importDnsName: bindAction(config, importDnsName),
+	setDnsRecords: bindAction(config, setDnsRecords),
+	setZoneHash: bindAction(config, setZoneHash)
+});
+
+//#endregion
+export { makeDnsActions };
+//# sourceMappingURL=dns.js.map

package/dist/groups/dns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns.js","names":[],"sources":["../../src/groups/dns.ts"],"sourcesContent":["import {\n  claimDnsName,\n  getDnsClaimStatus,\n  getDnsImportPlan,\n  getDnsRecord,\n  getDnsRecords,\n  getZoneHash,\n  hasDnsRecords,\n  importDnsName,\n  setDnsRecords,\n  setZoneHash,\n  type EnsforgeConfig,\n} from \"@ensforge/core\";\n\nimport { bindAction } from \"../internal/bind-action.js\";\n\nexport const makeDnsActions = (config: EnsforgeConfig) =>\n  Object.freeze({\n    claimDnsName: bindAction(config, claimDnsName),\n    getDnsClaimStatus: bindAction(config, getDnsClaimStatus),\n    getDnsImportPlan: bindAction(config, getDnsImportPlan),\n    getDnsRecord: bindAction(config, getDnsRecord),\n    getDnsRecords: bindAction(config, getDnsRecords),\n    getZoneHash: bindAction(config, getZoneHash),\n    hasDnsRecords: bindAction(config, hasDnsRecords),\n    importDnsName: bindAction(config, importDnsName),\n    setDnsRecords: bindAction(config, setDnsRecords),\n    setZoneHash: bindAction(config, setZoneHash),\n  });\n\nexport type DnsActions = ReturnType<typeof makeDnsActions>;\n"],"mappings":";;;;AAgBA,MAAa,kBAAkB,WAC7B,OAAO,OAAO;CACZ,cAAc,WAAW,QAAQ,YAAY;CAC7C,mBAAmB,WAAW,QAAQ,iBAAiB;CACvD,kBAAkB,WAAW,QAAQ,gBAAgB;CACrD,cAAc,WAAW,QAAQ,YAAY;CAC7C,eAAe,WAAW,QAAQ,aAAa;CAC/C,aAAa,WAAW,QAAQ,WAAW;CAC3C,eAAe,WAAW,QAAQ,aAAa;CAC/C,eAAe,WAAW,QAAQ,aAAa;CAC/C,eAAe,WAAW,QAAQ,aAAa;CAC/C,aAAa,WAAW,QAAQ,WAAW;AAC7C,CAAC"}