@ensforge/react 0.0.0

package/dist/atoms/capabilities.d.ts

@@ -0,0 +1,531 @@
+import { EnsQueryAtomFactory } from "./query.js";
+//#region src/atoms/capabilities.d.ts
+declare const getNameCapabilitiesAtom: EnsQueryAtomFactory<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>;
+declare const getOperatorApprovalAtom: EnsQueryAtomFactory<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>;
+declare const getRecordPermissionsAtom: EnsQueryAtomFactory<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>;
+declare const getRegistryCapabilitiesAtom: EnsQueryAtomFactory<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>;
+declare const getRegistryRolesAtom: EnsQueryAtomFactory<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>;
+declare const getRequiredAuthorizationAtom: EnsQueryAtomFactory<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>;
+declare const getResolverCapabilitiesAtom: EnsQueryAtomFactory<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>;
+declare const getResolverDelegateApprovalAtom: EnsQueryAtomFactory<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>;
+declare const getResolverRolesAtom: EnsQueryAtomFactory<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>;
+declare const getTokenApprovalAtom: EnsQueryAtomFactory<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>;
+declare const getWrapperPermissionsAtom: EnsQueryAtomFactory<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>;
+declare const getWriteTargetAtom: EnsQueryAtomFactory<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>;
+declare const hasRegistryRolesAtom: EnsQueryAtomFactory<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>;
+declare const hasResolverRolesAtom: EnsQueryAtomFactory<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>;
+//#endregion
+export { getNameCapabilitiesAtom, getOperatorApprovalAtom, getRecordPermissionsAtom, getRegistryCapabilitiesAtom, getRegistryRolesAtom, getRequiredAuthorizationAtom, getResolverCapabilitiesAtom, getResolverDelegateApprovalAtom, getResolverRolesAtom, getTokenApprovalAtom, getWrapperPermissionsAtom, getWriteTargetAtom, hasRegistryRolesAtom, hasResolverRolesAtom };
+//# sourceMappingURL=capabilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","names":[],"sources":["../../src/atoms/capabilities.ts"],"mappings":";;cAEa,yBAAA,6CAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGnC;cACY,yBAAA,6CAAuB;;;;;;;;;4BAGnC;cACY,0BAAA,6CAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGpC;cACY,6BAAA,6CAA2B;;;;;;;;;;;;;;4BAGvC;cACY,sBAAA,6CAAoB;;;;;;;;;;;4BAGhC;cACY,8BAAA,6CAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGxC;cACY,6BAAA,6CAA2B;;;;;;;;;;;;;;;;;;;4BAGvC;cACY,iCAAA,6CAA+B;;;;;;;;;;;4BAG3C;cACY,sBAAA,6CAAoB;;;;;;;;;;;4BAGhC;cACY,sBAAA,6CAAoB;;;;;;;;;;;4BAGhC;cACY,2BAAA,6CAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGrC;cACY,oBAAA,6CAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAG9B;cACY,sBAAA,6CAAoB;;;;;;;;;;;;4BAGhC;cACY,sBAAA,6CAAoB;;;;;;;;;;;;4BAGhC"}

package/dist/atoms/capabilities.js

@@ -0,0 +1,21 @@
+import { makeQueryAtom } from "./query.js";
+
+//#region src/atoms/capabilities.ts
+const getNameCapabilitiesAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getNameCapabilities);
+const getOperatorApprovalAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getOperatorApproval);
+const getRecordPermissionsAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getRecordPermissions);
+const getRegistryCapabilitiesAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getRegistryCapabilities);
+const getRegistryRolesAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getRegistryRoles);
+const getRequiredAuthorizationAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getRequiredAuthorization);
+const getResolverCapabilitiesAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getResolverCapabilities);
+const getResolverDelegateApprovalAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getResolverDelegateApproval);
+const getResolverRolesAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getResolverRoles);
+const getTokenApprovalAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getTokenApproval);
+const getWrapperPermissionsAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getWrapperPermissions);
+const getWriteTargetAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.getWriteTarget);
+const hasRegistryRolesAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.hasRegistryRoles);
+const hasResolverRolesAtom = makeQueryAtom("capabilities", (sdk) => sdk.capabilities.hasResolverRoles);
+
+//#endregion
+export { getNameCapabilitiesAtom, getOperatorApprovalAtom, getRecordPermissionsAtom, getRegistryCapabilitiesAtom, getRegistryRolesAtom, getRequiredAuthorizationAtom, getResolverCapabilitiesAtom, getResolverDelegateApprovalAtom, getResolverRolesAtom, getTokenApprovalAtom, getWrapperPermissionsAtom, getWriteTargetAtom, hasRegistryRolesAtom, hasResolverRolesAtom };
+//# sourceMappingURL=capabilities.js.map

package/dist/atoms/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","names":[],"sources":["../../src/atoms/capabilities.ts"],"sourcesContent":["import { makeQueryAtom } from \"./query.js\";\n\nexport const getNameCapabilitiesAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getNameCapabilities,\n);\nexport const getOperatorApprovalAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getOperatorApproval,\n);\nexport const getRecordPermissionsAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getRecordPermissions,\n);\nexport const getRegistryCapabilitiesAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getRegistryCapabilities,\n);\nexport const getRegistryRolesAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getRegistryRoles,\n);\nexport const getRequiredAuthorizationAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getRequiredAuthorization,\n);\nexport const getResolverCapabilitiesAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getResolverCapabilities,\n);\nexport const getResolverDelegateApprovalAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getResolverDelegateApproval,\n);\nexport const getResolverRolesAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getResolverRoles,\n);\nexport const getTokenApprovalAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getTokenApproval,\n);\nexport const getWrapperPermissionsAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getWrapperPermissions,\n);\nexport const getWriteTargetAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.getWriteTarget,\n);\nexport const hasRegistryRolesAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.hasRegistryRoles,\n);\nexport const hasResolverRolesAtom = makeQueryAtom(\n  \"capabilities\",\n  (sdk) => sdk.capabilities.hasResolverRoles,\n);\n"],"mappings":";;;AAEA,MAAa,0BAA0B,cACrC,iBACC,QAAQ,IAAI,aAAa,mBAC5B;AACA,MAAa,0BAA0B,cACrC,iBACC,QAAQ,IAAI,aAAa,mBAC5B;AACA,MAAa,2BAA2B,cACtC,iBACC,QAAQ,IAAI,aAAa,oBAC5B;AACA,MAAa,8BAA8B,cACzC,iBACC,QAAQ,IAAI,aAAa,uBAC5B;AACA,MAAa,uBAAuB,cAClC,iBACC,QAAQ,IAAI,aAAa,gBAC5B;AACA,MAAa,+BAA+B,cAC1C,iBACC,QAAQ,IAAI,aAAa,wBAC5B;AACA,MAAa,8BAA8B,cACzC,iBACC,QAAQ,IAAI,aAAa,uBAC5B;AACA,MAAa,kCAAkC,cAC7C,iBACC,QAAQ,IAAI,aAAa,2BAC5B;AACA,MAAa,uBAAuB,cAClC,iBACC,QAAQ,IAAI,aAAa,gBAC5B;AACA,MAAa,uBAAuB,cAClC,iBACC,QAAQ,IAAI,aAAa,gBAC5B;AACA,MAAa,4BAA4B,cACvC,iBACC,QAAQ,IAAI,aAAa,qBAC5B;AACA,MAAa,qBAAqB,cAChC,iBACC,QAAQ,IAAI,aAAa,cAC5B;AACA,MAAa,uBAAuB,cAClC,iBACC,QAAQ,IAAI,aAAa,gBAC5B;AACA,MAAa,uBAAuB,cAClC,iBACC,QAAQ,IAAI,aAAa,gBAC5B"}

package/dist/atoms/dns.d.ts

@@ -0,0 +1,75 @@
+import { EnsQueryAtomFactory } from "./query.js";
+import { EnsMutationAtomFactory } from "./mutation.js";
+//#region src/atoms/dns.d.ts
+declare const getDnsClaimStatusAtom: EnsQueryAtomFactory<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>;
+declare const getDnsImportPlanAtom: EnsQueryAtomFactory<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>;
+declare const getDnsRecordAtom: EnsQueryAtomFactory<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>;
+declare const getDnsRecordsAtom: EnsQueryAtomFactory<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>;
+declare const getZoneHashAtom: EnsQueryAtomFactory<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>;
+declare const hasDnsRecordsAtom: EnsQueryAtomFactory<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>;
+declare const createClaimDnsNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ClaimDnsNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createImportDnsNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ImportDnsNameParameters, import("@ensforge/core").ImportDnsNameResult, import("@ensforge/core").WriteError>;
+declare const createSetDnsRecordsMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetDnsRecordsParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetZoneHashMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetZoneHashParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+//#endregion
+export { createClaimDnsNameMutationAtom, createImportDnsNameMutationAtom, createSetDnsRecordsMutationAtom, createSetZoneHashMutationAtom, getDnsClaimStatusAtom, getDnsImportPlanAtom, getDnsRecordAtom, getDnsRecordsAtom, getZoneHashAtom, hasDnsRecordsAtom };
+//# sourceMappingURL=dns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dns.d.ts","names":[],"sources":["../../src/atoms/dns.ts"],"mappings":";;;cAGa,uBAAA,6CAAqB;;;;;;;;;;;;;;4BAA2D;cAChF,sBAAA,6CAAoB;;;;;;;;;;;;;;;;;;;;4BAA0D;cAC9E,kBAAA,6CAAgB;;;;;;4BAAsD;cACtE,mBAAA,6CAAiB;;;;;;;;;;4BAAuD;cACxE,iBAAA,6CAAe;;;;4BAAqD;cACpE,mBAAA,6CAAiB;;;;;4BAAuD;cAExE,gCAAA,gDAA8B,iDAAA,8CAAA;cAI9B,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,iCAAA,gDAA+B,kDAAA,8CAAA;cAI/B,+BAAA,gDAA6B,gDAAA,8CAAA"}

package/dist/atoms/dns.js

@@ -0,0 +1,18 @@
+import { makeMutationAtom } from "./mutation.js";
+import { makeQueryAtom } from "./query.js";
+
+//#region src/atoms/dns.ts
+const getDnsClaimStatusAtom = makeQueryAtom("dns", (sdk) => sdk.dns.getDnsClaimStatus);
+const getDnsImportPlanAtom = makeQueryAtom("dns", (sdk) => sdk.dns.getDnsImportPlan);
+const getDnsRecordAtom = makeQueryAtom("dns", (sdk) => sdk.dns.getDnsRecord);
+const getDnsRecordsAtom = makeQueryAtom("dns", (sdk) => sdk.dns.getDnsRecords);
+const getZoneHashAtom = makeQueryAtom("dns", (sdk) => sdk.dns.getZoneHash);
+const hasDnsRecordsAtom = makeQueryAtom("dns", (sdk) => sdk.dns.hasDnsRecords);
+const createClaimDnsNameMutationAtom = makeMutationAtom("dns", (sdk) => sdk.dns.claimDnsName);
+const createImportDnsNameMutationAtom = makeMutationAtom("dns", (sdk) => sdk.dns.importDnsName);
+const createSetDnsRecordsMutationAtom = makeMutationAtom("dns", (sdk) => sdk.dns.setDnsRecords);
+const createSetZoneHashMutationAtom = makeMutationAtom("dns", (sdk) => sdk.dns.setZoneHash);
+
+//#endregion
+export { createClaimDnsNameMutationAtom, createImportDnsNameMutationAtom, createSetDnsRecordsMutationAtom, createSetZoneHashMutationAtom, getDnsClaimStatusAtom, getDnsImportPlanAtom, getDnsRecordAtom, getDnsRecordsAtom, getZoneHashAtom, hasDnsRecordsAtom };
+//# sourceMappingURL=dns.js.map

package/dist/atoms/dns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns.js","names":[],"sources":["../../src/atoms/dns.ts"],"sourcesContent":["import { makeMutationAtom } from \"./mutation.js\";\nimport { makeQueryAtom } from \"./query.js\";\n\nexport const getDnsClaimStatusAtom = makeQueryAtom(\"dns\", (sdk) => sdk.dns.getDnsClaimStatus);\nexport const getDnsImportPlanAtom = makeQueryAtom(\"dns\", (sdk) => sdk.dns.getDnsImportPlan);\nexport const getDnsRecordAtom = makeQueryAtom(\"dns\", (sdk) => sdk.dns.getDnsRecord);\nexport const getDnsRecordsAtom = makeQueryAtom(\"dns\", (sdk) => sdk.dns.getDnsRecords);\nexport const getZoneHashAtom = makeQueryAtom(\"dns\", (sdk) => sdk.dns.getZoneHash);\nexport const hasDnsRecordsAtom = makeQueryAtom(\"dns\", (sdk) => sdk.dns.hasDnsRecords);\n\nexport const createClaimDnsNameMutationAtom = makeMutationAtom(\n  \"dns\",\n  (sdk) => sdk.dns.claimDnsName,\n);\nexport const createImportDnsNameMutationAtom = makeMutationAtom(\n  \"dns\",\n  (sdk) => sdk.dns.importDnsName,\n);\nexport const createSetDnsRecordsMutationAtom = makeMutationAtom(\n  \"dns\",\n  (sdk) => sdk.dns.setDnsRecords,\n);\nexport const createSetZoneHashMutationAtom = makeMutationAtom(\"dns\", (sdk) => sdk.dns.setZoneHash);\n"],"mappings":";;;;AAGA,MAAa,wBAAwB,cAAc,QAAQ,QAAQ,IAAI,IAAI,iBAAiB;AAC5F,MAAa,uBAAuB,cAAc,QAAQ,QAAQ,IAAI,IAAI,gBAAgB;AAC1F,MAAa,mBAAmB,cAAc,QAAQ,QAAQ,IAAI,IAAI,YAAY;AAClF,MAAa,oBAAoB,cAAc,QAAQ,QAAQ,IAAI,IAAI,aAAa;AACpF,MAAa,kBAAkB,cAAc,QAAQ,QAAQ,IAAI,IAAI,WAAW;AAChF,MAAa,oBAAoB,cAAc,QAAQ,QAAQ,IAAI,IAAI,aAAa;AAEpF,MAAa,iCAAiC,iBAC5C,QACC,QAAQ,IAAI,IAAI,YACnB;AACA,MAAa,kCAAkC,iBAC7C,QACC,QAAQ,IAAI,IAAI,aACnB;AACA,MAAa,kCAAkC,iBAC7C,QACC,QAAQ,IAAI,IAAI,aACnB;AACA,MAAa,gCAAgC,iBAAiB,QAAQ,QAAQ,IAAI,IAAI,WAAW"}