@ensforge/sdk 0.1.0 → 0.2.0

package/dist/groups/capabilities.d.ts

@@ -1,536 +1,22 @@
 import { BoundAction } from "../internal/bind-action.js";
-import "../index.js";
-import { EnsforgeConfig } from "@ensforge/core";
+import { EnsforgeConfig, getNameCapabilities, getOperatorApproval, getRecordPermissions, getRegistryCapabilities, getRegistryRoles, getRequiredAuthorization, getResolverCapabilities, getResolverDelegateApproval, getResolverRoles, getTokenApproval, getWrapperPermissions, getWriteTarget, hasRegistryRoles, hasResolverRoles } 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: "resolver" | "registrar" | "registry" | "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: "resolver" | "registrar" | "registry" | "name-wrapper" | "wrapper-registry";
-      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: "registrar" | "name-wrapper";
-    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: "resolver" | "registrar" | "registry" | "name-wrapper" | "wrapper-registry";
-    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>;
+interface CapabilitiesActions {
+  readonly getNameCapabilities: BoundAction<typeof getNameCapabilities>;
+  readonly getOperatorApproval: BoundAction<typeof getOperatorApproval>;
+  readonly getRecordPermissions: BoundAction<typeof getRecordPermissions>;
+  readonly getRegistryCapabilities: BoundAction<typeof getRegistryCapabilities>;
+  readonly getRegistryRoles: BoundAction<typeof getRegistryRoles>;
+  readonly getRequiredAuthorization: BoundAction<typeof getRequiredAuthorization>;
+  readonly getResolverCapabilities: BoundAction<typeof getResolverCapabilities>;
+  readonly getResolverDelegateApproval: BoundAction<typeof getResolverDelegateApproval>;
+  readonly getResolverRoles: BoundAction<typeof getResolverRoles>;
+  readonly getTokenApproval: BoundAction<typeof getTokenApproval>;
+  readonly getWrapperPermissions: BoundAction<typeof getWrapperPermissions>;
+  readonly getWriteTarget: BoundAction<typeof getWriteTarget>;
+  readonly hasRegistryRoles: BoundAction<typeof hasRegistryRoles>;
+  readonly hasResolverRoles: BoundAction<typeof hasResolverRoles>;
+}
 //#endregion
-export { CapabilitiesActions, makeCapabilitiesActions };
+export { CapabilitiesActions };
 //# sourceMappingURL=capabilities.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","names":[],"sources":["../../src/groups/capabilities.ts"],"mappings":";;;;cAoBa,0BAA2B,QAAQ,mBAAc;uBAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkBpC,sBAAsB,kBAAkB"}
+{"version":3,"file":"capabilities.d.ts","names":[],"sources":["../../src/groups/capabilities.ts"],"mappings":";;;UAoBiB;WACN,qBAAqB,mBAAmB;WACxC,qBAAqB,mBAAmB;WACxC,sBAAsB,mBAAmB;WACzC,yBAAyB,mBAAmB;WAC5C,kBAAkB,mBAAmB;WACrC,0BAA0B,mBAAmB;WAC7C,yBAAyB,mBAAmB;WAC5C,6BAA6B,mBAAmB;WAChD,kBAAkB,mBAAmB;WACrC,kBAAkB,mBAAmB;WACrC,uBAAuB,mBAAmB;WAC1C,gBAAgB,mBAAmB;WACnC,kBAAkB,mBAAmB;WACrC,kBAAkB,mBAAmB"}

package/dist/groups/capabilities.js.map

@@ -1 +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"}
+{"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, type BoundAction } from \"../internal/bind-action.js\";\n\nexport interface CapabilitiesActions {\n  readonly getNameCapabilities: BoundAction<typeof getNameCapabilities>;\n  readonly getOperatorApproval: BoundAction<typeof getOperatorApproval>;\n  readonly getRecordPermissions: BoundAction<typeof getRecordPermissions>;\n  readonly getRegistryCapabilities: BoundAction<typeof getRegistryCapabilities>;\n  readonly getRegistryRoles: BoundAction<typeof getRegistryRoles>;\n  readonly getRequiredAuthorization: BoundAction<typeof getRequiredAuthorization>;\n  readonly getResolverCapabilities: BoundAction<typeof getResolverCapabilities>;\n  readonly getResolverDelegateApproval: BoundAction<typeof getResolverDelegateApproval>;\n  readonly getResolverRoles: BoundAction<typeof getResolverRoles>;\n  readonly getTokenApproval: BoundAction<typeof getTokenApproval>;\n  readonly getWrapperPermissions: BoundAction<typeof getWrapperPermissions>;\n  readonly getWriteTarget: BoundAction<typeof getWriteTarget>;\n  readonly hasRegistryRoles: BoundAction<typeof hasRegistryRoles>;\n  readonly hasResolverRoles: BoundAction<typeof hasResolverRoles>;\n}\n\nexport const makeCapabilitiesActions = (config: EnsforgeConfig): CapabilitiesActions =>\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"],"mappings":";;;;AAqCA,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

@@ -1,79 +1,18 @@
 import { BoundAction } from "../internal/bind-action.js";
-import "../index.js";
-import { EnsforgeConfig } from "@ensforge/core";
+import { EnsforgeConfig, claimDnsName, getDnsClaimStatus, getDnsImportPlan, getDnsRecord, getDnsRecords, getZoneHash, hasDnsRecords, importDnsName, setDnsRecords, setZoneHash } 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>;
+interface DnsActions {
+  readonly claimDnsName: BoundAction<typeof claimDnsName>;
+  readonly getDnsClaimStatus: BoundAction<typeof getDnsClaimStatus>;
+  readonly getDnsImportPlan: BoundAction<typeof getDnsImportPlan>;
+  readonly getDnsRecord: BoundAction<typeof getDnsRecord>;
+  readonly getDnsRecords: BoundAction<typeof getDnsRecords>;
+  readonly getZoneHash: BoundAction<typeof getZoneHash>;
+  readonly hasDnsRecords: BoundAction<typeof hasDnsRecords>;
+  readonly importDnsName: BoundAction<typeof importDnsName>;
+  readonly setDnsRecords: BoundAction<typeof setDnsRecords>;
+  readonly setZoneHash: BoundAction<typeof setZoneHash>;
+}
 //#endregion
-export { DnsActions, makeDnsActions };
+export { DnsActions };
 //# sourceMappingURL=dns.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dns.d.ts","names":[],"sources":["../../src/groups/dns.ts"],"mappings":";;;;cAgBa,iBAAkB,QAAQ,mBAAc;gBAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAc3B,aAAa,kBAAkB"}
+{"version":3,"file":"dns.d.ts","names":[],"sources":["../../src/groups/dns.ts"],"mappings":";;;UAgBiB;WACN,cAAc,mBAAmB;WACjC,mBAAmB,mBAAmB;WACtC,kBAAkB,mBAAmB;WACrC,cAAc,mBAAmB;WACjC,eAAe,mBAAmB;WAClC,aAAa,mBAAmB;WAChC,eAAe,mBAAmB;WAClC,eAAe,mBAAmB;WAClC,eAAe,mBAAmB;WAClC,aAAa,mBAAmB"}