npm - @ensforge/core - Versions diffs - 0.0.0 - Mend

@ensforge/core 0.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1033) hide show

package/dist/actions/capabilities/types.d.ts ADDED Viewed

@@ -0,0 +1,790 @@
+import { BlockParameters } from "../../action/block.js";
+import { EthereumAddress } from "../../schemas/identity.js";
+import { GetNameStateError } from "../name/get-name-state/types.js";
+import { Schema } from "effect";
+//#region src/actions/capabilities/types.d.ts
+type CapabilityError = GetNameStateError;
+type NameCapabilityParameters = {
+  readonly name: string;
+} & BlockParameters;
+type AccountCapabilityParameters = NameCapabilityParameters & {
+  readonly account: EthereumAddress;
+};
+declare const RegistryCapabilities: Schema.Struct<{
+  readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly kind: Schema.Literals<readonly ["registry", "name-wrapper", "permissioned-registry", "wrapper-registry"]>;
+  readonly owned: Schema.Boolean;
+  readonly permissioned: Schema.Boolean;
+  readonly temporal: Schema.Boolean;
+  readonly tokenized: Schema.Boolean;
+  readonly wrapped: Schema.Boolean;
+  readonly setOwner: Schema.Boolean;
+  readonly setResolver: Schema.Boolean;
+  readonly createSubname: Schema.Boolean;
+  readonly transfer: Schema.Boolean;
+  readonly setExpiry: Schema.Boolean;
+}>;
+type RegistryCapabilities = typeof RegistryCapabilities.Type;
+declare const ResolverProfiles: Schema.Struct<{
+  readonly address: Schema.Boolean;
+  readonly text: Schema.Boolean;
+  readonly contentHash: Schema.Boolean;
+  readonly abi: Schema.Boolean;
+  readonly pubkey: Schema.Boolean;
+  readonly interface: Schema.Boolean;
+  readonly name: Schema.Boolean;
+  readonly data: Schema.Boolean;
+  readonly dnsRecord: Schema.Boolean;
+  readonly dnsZone: Schema.Boolean;
+}>;
+type ResolverProfiles = typeof ResolverProfiles.Type;
+declare const ResolverCapabilities: Schema.Struct<{
+  readonly address: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly node: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "Namehash">;
+  readonly inherited: Schema.Boolean;
+  readonly extended: Schema.Boolean;
+  readonly permissioned: Schema.Boolean;
+  readonly authorization: Schema.Literals<readonly ["none", "owner-delegate", "role", "unknown"]>;
+  readonly profiles: Schema.Struct<{
+    readonly address: Schema.Boolean;
+    readonly text: Schema.Boolean;
+    readonly contentHash: Schema.Boolean;
+    readonly abi: Schema.Boolean;
+    readonly pubkey: Schema.Boolean;
+    readonly interface: Schema.Boolean;
+    readonly name: Schema.Boolean;
+    readonly data: Schema.Boolean;
+    readonly dnsRecord: Schema.Boolean;
+    readonly dnsZone: Schema.Boolean;
+  }>;
+}>;
+type ResolverCapabilities = typeof ResolverCapabilities.Type;
+declare const RegistryRolesResult: Schema.Union<readonly [Schema.Struct<{
+  readonly supported: Schema.Literal<false>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly reason: Schema.Literals<readonly ["ROLE_BASED_PERMISSIONS_UNSUPPORTED", "RESOLVER_NOT_FOUND"]>;
+}>, Schema.Struct<{
+  readonly supported: Schema.Literal<true>;
+  readonly protocol: Schema.Literal<"v2">;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resource: Schema.BigInt;
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly roles: Schema.BigInt;
+}>]>;
+type RegistryRolesResult = typeof RegistryRolesResult.Type;
+declare const HasRegistryRolesResult: Schema.Union<readonly [Schema.Struct<{
+  readonly supported: Schema.Literal<false>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly reason: Schema.Literals<readonly ["ROLE_BASED_PERMISSIONS_UNSUPPORTED", "RESOLVER_NOT_FOUND"]>;
+}>, Schema.Struct<{
+  readonly supported: Schema.Literal<true>;
+  readonly protocol: Schema.Literal<"v2">;
+  readonly registry: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resource: Schema.BigInt;
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly roles: Schema.BigInt;
+  readonly authorized: Schema.Boolean;
+}>]>;
+type HasRegistryRolesResult = typeof HasRegistryRolesResult.Type;
+declare const ResolverRolesResult: Schema.Union<readonly [Schema.Struct<{
+  readonly supported: Schema.Literal<false>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly reason: Schema.Literals<readonly ["ROLE_BASED_PERMISSIONS_UNSUPPORTED", "RESOLVER_NOT_FOUND"]>;
+}>, Schema.Struct<{
+  readonly supported: Schema.Literal<true>;
+  readonly protocol: Schema.Literal<"v2">;
+  readonly resolver: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resource: Schema.BigInt;
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly roles: Schema.BigInt;
+}>]>;
+type ResolverRolesResult = typeof ResolverRolesResult.Type;
+declare const HasResolverRolesResult: Schema.Union<readonly [Schema.Struct<{
+  readonly supported: Schema.Literal<false>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly reason: Schema.Literals<readonly ["ROLE_BASED_PERMISSIONS_UNSUPPORTED", "RESOLVER_NOT_FOUND"]>;
+}>, Schema.Struct<{
+  readonly supported: Schema.Literal<true>;
+  readonly protocol: Schema.Literal<"v2">;
+  readonly resolver: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resource: Schema.BigInt;
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly roles: Schema.BigInt;
+  readonly authorized: Schema.Boolean;
+}>]>;
+type HasResolverRolesResult = typeof HasResolverRolesResult.Type;
+declare const RecordOperation: Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"address">;
+  readonly coinType: Schema.BigInt;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"text">;
+  readonly key: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"contentHash">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"pubkey">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"abi">;
+  readonly contentType: Schema.optional<Schema.BigInt>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"interface">;
+  readonly interfaceId: Schema.optional<Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "InterfaceId">>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"name">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"data">;
+  readonly key: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"alias">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"dnsRecord">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"dnsZone">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"clear">;
+}>]>;
+type RecordOperation = typeof RecordOperation.Type;
+declare const RegistryOperation: Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"setOwner">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"setTtl">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"setResolver">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"createSubname">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"transfer">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"setExpiry">;
+}>]>;
+type RegistryOperation = typeof RegistryOperation.Type;
+declare const WriteOperation: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"address">;
+  readonly coinType: Schema.BigInt;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"text">;
+  readonly key: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"contentHash">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"pubkey">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"abi">;
+  readonly contentType: Schema.optional<Schema.BigInt>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"interface">;
+  readonly interfaceId: Schema.optional<Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "InterfaceId">>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"name">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"data">;
+  readonly key: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"alias">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"dnsRecord">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"dnsZone">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"clear">;
+}>]>, Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"setOwner">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"setTtl">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"setResolver">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"createSubname">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"transfer">;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"setExpiry">;
+}>]>]>;
+type WriteOperation = typeof WriteOperation.Type;
+declare const OperatorApprovalTarget: Schema.Struct<{
+  readonly kind: Schema.Literals<readonly ["registry", "registrar", "wrapper", "resolver"]>;
+  readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly supported: Schema.Boolean;
+  readonly approved: Schema.Boolean;
+}>;
+type OperatorApprovalTarget = typeof OperatorApprovalTarget.Type;
+declare const OperatorApprovalResult: Schema.Struct<{
+  readonly owner: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly operator: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly targets: Schema.$Array<Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["registry", "registrar", "wrapper", "resolver"]>;
+    readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly supported: Schema.Boolean;
+    readonly approved: Schema.Boolean;
+  }>>;
+}>;
+type OperatorApprovalResult = typeof OperatorApprovalResult.Type;
+declare const TokenApprovalResult: Schema.Union<readonly [Schema.Struct<{
+  readonly supported: Schema.Literal<false>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly reason: Schema.Literals<readonly ["PER_TOKEN_APPROVAL_UNSUPPORTED", "NAME_NOT_TOKENIZED"]>;
+}>, Schema.Struct<{
+  readonly supported: Schema.Literal<true>;
+  readonly protocol: Schema.Literal<"v1">;
+  readonly kind: Schema.Literals<readonly ["registrar", "name-wrapper"]>;
+  readonly contract: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly tokenId: Schema.BigInt;
+  readonly approved: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+}>]>;
+type TokenApprovalResult = typeof TokenApprovalResult.Type;
+declare const ResolverDelegateApprovalResult: Schema.Union<readonly [Schema.Struct<{
+  readonly supported: Schema.Literal<false>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly reason: Schema.Literals<readonly ["RESOLVER_NOT_FOUND", "DELEGATE_APPROVAL_UNSUPPORTED"]>;
+}>, Schema.Struct<{
+  readonly supported: Schema.Literal<true>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly resolver: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly owner: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly delegate: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly approved: Schema.Boolean;
+}>]>;
+type ResolverDelegateApprovalResult = typeof ResolverDelegateApprovalResult.Type;
+declare const WrapperPermissionsResult: Schema.Union<readonly [Schema.Struct<{
+  readonly supported: Schema.Literal<false>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly reason: Schema.Literal<"NAME_NOT_WRAPPED">;
+}>, Schema.Struct<{
+  readonly supported: Schema.Literal<true>;
+  readonly protocol: Schema.Literal<"v1">;
+  readonly wrapper: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly owner: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly tokenId: Schema.BigInt;
+  readonly fuses: Schema.Number;
+  readonly expiry: Schema.BigInt;
+  readonly approved: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly operatorApproved: Schema.Boolean;
+  readonly canModify: Schema.Boolean;
+  readonly canExtendSubnames: Schema.Boolean;
+  readonly canUnwrap: Schema.Boolean;
+  readonly canTransfer: Schema.Boolean;
+  readonly canSetResolver: Schema.Boolean;
+  readonly canSetTtl: Schema.Boolean;
+  readonly canCreateSubname: Schema.Boolean;
+  readonly canApprove: Schema.Boolean;
+}>, Schema.Struct<{
+  readonly supported: Schema.Literal<true>;
+  readonly protocol: Schema.Literal<"v2">;
+  readonly wrapper: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly resource: Schema.BigInt;
+  readonly roles: Schema.BigInt;
+  readonly operatorApproved: Schema.Boolean;
+}>]>;
+type WrapperPermissionsResult = typeof WrapperPermissionsResult.Type;
+declare const AuthorizationRequirement: Schema.Union<readonly [Schema.Struct<{
+  readonly kind: Schema.Literal<"none">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"owner">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"operator-approval">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"token-approval">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"resolver-delegate">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"registry-role">;
+  readonly roles: Schema.BigInt;
+  readonly resource: Schema.BigInt;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"resolver-role">;
+  readonly roles: Schema.BigInt;
+  readonly resource: Schema.BigInt;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"wrapper-permission">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"unsupported">;
+}>]>;
+type AuthorizationRequirement = typeof AuthorizationRequirement.Type;
+declare const AuthorizationSource: Schema.Literals<readonly ["owner", "operator-approval", "token-approval", "resolver-delegate", "registry-role", "resolver-role", "wrapper-permission"]>;
+type AuthorizationSource = typeof AuthorizationSource.Type;
+declare const AuthorizationDecision: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Literal<"authorized">;
+  readonly source: Schema.Literals<readonly ["owner", "operator-approval", "token-approval", "resolver-delegate", "registry-role", "resolver-role", "wrapper-permission"]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"unauthorized">;
+  readonly requirement: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"none">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"owner">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"operator-approval">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"token-approval">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"resolver-delegate">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"registry-role">;
+    readonly roles: Schema.BigInt;
+    readonly resource: Schema.BigInt;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"resolver-role">;
+    readonly roles: Schema.BigInt;
+    readonly resource: Schema.BigInt;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"wrapper-permission">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"unsupported">;
+  }>]>;
+}>, Schema.Struct<{
+  readonly status: Schema.Literal<"unknown">;
+  readonly reason: Schema.Literal<"CUSTOM_RESOLVER">;
+}>]>;
+type AuthorizationDecision = typeof AuthorizationDecision.Type;
+declare const RecordPermission: Schema.Struct<{
+  readonly record: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"address">;
+    readonly coinType: Schema.BigInt;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly key: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"contentHash">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"pubkey">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"abi">;
+    readonly contentType: Schema.optional<Schema.BigInt>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"interface">;
+    readonly interfaceId: Schema.optional<Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "InterfaceId">>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"name">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"data">;
+    readonly key: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"alias">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"dnsRecord">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"dnsZone">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"clear">;
+  }>]>;
+  readonly supported: Schema.Boolean;
+  readonly authorization: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"authorized">;
+    readonly source: Schema.Literals<readonly ["owner", "operator-approval", "token-approval", "resolver-delegate", "registry-role", "resolver-role", "wrapper-permission"]>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"unauthorized">;
+    readonly requirement: Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"owner">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"operator-approval">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"token-approval">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"resolver-delegate">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"registry-role">;
+      readonly roles: Schema.BigInt;
+      readonly resource: Schema.BigInt;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"resolver-role">;
+      readonly roles: Schema.BigInt;
+      readonly resource: Schema.BigInt;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"wrapper-permission">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"unsupported">;
+    }>]>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"unknown">;
+    readonly reason: Schema.Literal<"CUSTOM_RESOLVER">;
+  }>]>;
+  readonly requiredRole: Schema.BigInt;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+}>;
+type RecordPermission = typeof RecordPermission.Type;
+declare const RecordPermissionsResult: Schema.Struct<{
+  readonly resolver: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+  readonly inherited: Schema.Boolean;
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly records: Schema.$Array<Schema.Struct<{
+    readonly record: Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"address">;
+      readonly coinType: Schema.BigInt;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"text">;
+      readonly key: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"contentHash">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"pubkey">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"abi">;
+      readonly contentType: Schema.optional<Schema.BigInt>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"interface">;
+      readonly interfaceId: Schema.optional<Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "InterfaceId">>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"name">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"data">;
+      readonly key: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"alias">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"dnsRecord">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"dnsZone">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"clear">;
+    }>]>;
+    readonly supported: Schema.Boolean;
+    readonly authorization: Schema.Union<readonly [Schema.Struct<{
+      readonly status: Schema.Literal<"authorized">;
+      readonly source: Schema.Literals<readonly ["owner", "operator-approval", "token-approval", "resolver-delegate", "registry-role", "resolver-role", "wrapper-permission"]>;
+    }>, Schema.Struct<{
+      readonly status: Schema.Literal<"unauthorized">;
+      readonly requirement: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"none">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"owner">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"operator-approval">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"token-approval">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"resolver-delegate">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"registry-role">;
+        readonly roles: Schema.BigInt;
+        readonly resource: Schema.BigInt;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"resolver-role">;
+        readonly roles: Schema.BigInt;
+        readonly resource: Schema.BigInt;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"wrapper-permission">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"unsupported">;
+      }>]>;
+    }>, Schema.Struct<{
+      readonly status: Schema.Literal<"unknown">;
+      readonly reason: Schema.Literal<"CUSTOM_RESOLVER">;
+    }>]>;
+    readonly requiredRole: Schema.BigInt;
+    readonly resource: Schema.NullOr<Schema.BigInt>;
+  }>>;
+}>;
+type RecordPermissionsResult = typeof RecordPermissionsResult.Type;
+declare const WriteTarget: Schema.Union<readonly [Schema.Struct<{
+  readonly available: Schema.Literal<false>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly reason: Schema.Literals<readonly ["NAME_NOT_REGISTERED", "RESOLVER_NOT_FOUND", "OPERATION_UNSUPPORTED"]>;
+}>, Schema.Struct<{
+  readonly available: Schema.Literal<true>;
+  readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+  readonly kind: Schema.Literals<readonly ["registry", "registrar", "name-wrapper", "wrapper-registry", "resolver"]>;
+  readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly operation: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"address">;
+    readonly coinType: Schema.BigInt;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly key: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"contentHash">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"pubkey">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"abi">;
+    readonly contentType: Schema.optional<Schema.BigInt>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"interface">;
+    readonly interfaceId: Schema.optional<Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "InterfaceId">>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"name">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"data">;
+    readonly key: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"alias">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"dnsRecord">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"dnsZone">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"clear">;
+  }>]>, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"setOwner">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"setTtl">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"setResolver">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"createSubname">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"transfer">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"setExpiry">;
+  }>]>]>;
+  readonly node: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "Namehash">;
+  readonly tokenId: Schema.NullOr<Schema.BigInt>;
+  readonly resource: Schema.NullOr<Schema.BigInt>;
+  readonly inheritedResolver: Schema.Boolean;
+}>]>;
+type WriteTarget = typeof WriteTarget.Type;
+declare const RequiredAuthorizationResult: Schema.Struct<{
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly operation: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"address">;
+    readonly coinType: Schema.BigInt;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly key: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"contentHash">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"pubkey">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"abi">;
+    readonly contentType: Schema.optional<Schema.BigInt>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"interface">;
+    readonly interfaceId: Schema.optional<Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "InterfaceId">>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"name">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"data">;
+    readonly key: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"alias">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"dnsRecord">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"dnsZone">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"clear">;
+  }>]>, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"setOwner">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"setTtl">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"setResolver">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"createSubname">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"transfer">;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"setExpiry">;
+  }>]>]>;
+  readonly target: Schema.Union<readonly [Schema.Struct<{
+    readonly available: Schema.Literal<false>;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly reason: Schema.Literals<readonly ["NAME_NOT_REGISTERED", "RESOLVER_NOT_FOUND", "OPERATION_UNSUPPORTED"]>;
+  }>, Schema.Struct<{
+    readonly available: Schema.Literal<true>;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly kind: Schema.Literals<readonly ["registry", "registrar", "name-wrapper", "wrapper-registry", "resolver"]>;
+    readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly operation: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"address">;
+      readonly coinType: Schema.BigInt;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"text">;
+      readonly key: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"contentHash">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"pubkey">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"abi">;
+      readonly contentType: Schema.optional<Schema.BigInt>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"interface">;
+      readonly interfaceId: Schema.optional<Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "InterfaceId">>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"name">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"data">;
+      readonly key: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"alias">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"dnsRecord">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"dnsZone">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"clear">;
+    }>]>, Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"setOwner">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"setTtl">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"setResolver">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"createSubname">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"transfer">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"setExpiry">;
+    }>]>]>;
+    readonly node: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "Namehash">;
+    readonly tokenId: Schema.NullOr<Schema.BigInt>;
+    readonly resource: Schema.NullOr<Schema.BigInt>;
+    readonly inheritedResolver: Schema.Boolean;
+  }>]>;
+  readonly authorization: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"authorized">;
+    readonly source: Schema.Literals<readonly ["owner", "operator-approval", "token-approval", "resolver-delegate", "registry-role", "resolver-role", "wrapper-permission"]>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"unauthorized">;
+    readonly requirement: Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"owner">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"operator-approval">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"token-approval">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"resolver-delegate">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"registry-role">;
+      readonly roles: Schema.BigInt;
+      readonly resource: Schema.BigInt;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"resolver-role">;
+      readonly roles: Schema.BigInt;
+      readonly resource: Schema.BigInt;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"wrapper-permission">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"unsupported">;
+    }>]>;
+  }>, Schema.Struct<{
+    readonly status: Schema.Literal<"unknown">;
+    readonly reason: Schema.Literal<"CUSTOM_RESOLVER">;
+  }>]>;
+  readonly blockers: Schema.$Array<Schema.Literals<readonly ["NAME_NOT_REGISTERED", "RESOLVER_NOT_FOUND", "OPERATION_UNSUPPORTED", "WRAPPER_FUSE", "TRANSFER_ROLE"]>>;
+}>;
+type RequiredAuthorizationResult = typeof RequiredAuthorizationResult.Type;
+declare const NameCapabilities: Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "NormalizedName">;
+  readonly account: Schema.declare<`0x${string}`, `0x${string}`>;
+  readonly registry: Schema.Struct<{
+    readonly address: Schema.declare<`0x${string}`, `0x${string}`>;
+    readonly protocol: Schema.Literals<readonly ["v1", "v2"]>;
+    readonly kind: Schema.Literals<readonly ["registry", "name-wrapper", "permissioned-registry", "wrapper-registry"]>;
+    readonly owned: Schema.Boolean;
+    readonly permissioned: Schema.Boolean;
+    readonly temporal: Schema.Boolean;
+    readonly tokenized: Schema.Boolean;
+    readonly wrapped: Schema.Boolean;
+    readonly setOwner: Schema.Boolean;
+    readonly setResolver: Schema.Boolean;
+    readonly createSubname: Schema.Boolean;
+    readonly transfer: Schema.Boolean;
+    readonly setExpiry: Schema.Boolean;
+  }>;
+  readonly resolver: Schema.Struct<{
+    readonly address: Schema.NullOr<Schema.declare<`0x${string}`, `0x${string}`>>;
+    readonly node: Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "Namehash">;
+    readonly inherited: Schema.Boolean;
+    readonly extended: Schema.Boolean;
+    readonly permissioned: Schema.Boolean;
+    readonly authorization: Schema.Literals<readonly ["none", "owner-delegate", "role", "unknown"]>;
+    readonly profiles: Schema.Struct<{
+      readonly address: Schema.Boolean;
+      readonly text: Schema.Boolean;
+      readonly contentHash: Schema.Boolean;
+      readonly abi: Schema.Boolean;
+      readonly pubkey: Schema.Boolean;
+      readonly interface: Schema.Boolean;
+      readonly name: Schema.Boolean;
+      readonly data: Schema.Boolean;
+      readonly dnsRecord: Schema.Boolean;
+      readonly dnsZone: Schema.Boolean;
+    }>;
+  }>;
+  readonly records: Schema.$Array<Schema.Struct<{
+    readonly record: Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"address">;
+      readonly coinType: Schema.BigInt;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"text">;
+      readonly key: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"contentHash">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"pubkey">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"abi">;
+      readonly contentType: Schema.optional<Schema.BigInt>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"interface">;
+      readonly interfaceId: Schema.optional<Schema.brand<Schema.TemplateLiteral<readonly ["0x", Schema.String]>, "InterfaceId">>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"name">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"data">;
+      readonly key: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"alias">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"dnsRecord">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"dnsZone">;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"clear">;
+    }>]>;
+    readonly supported: Schema.Boolean;
+    readonly authorization: Schema.Union<readonly [Schema.Struct<{
+      readonly status: Schema.Literal<"authorized">;
+      readonly source: Schema.Literals<readonly ["owner", "operator-approval", "token-approval", "resolver-delegate", "registry-role", "resolver-role", "wrapper-permission"]>;
+    }>, Schema.Struct<{
+      readonly status: Schema.Literal<"unauthorized">;
+      readonly requirement: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"none">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"owner">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"operator-approval">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"token-approval">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"resolver-delegate">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"registry-role">;
+        readonly roles: Schema.BigInt;
+        readonly resource: Schema.BigInt;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"resolver-role">;
+        readonly roles: Schema.BigInt;
+        readonly resource: Schema.BigInt;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"wrapper-permission">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"unsupported">;
+      }>]>;
+    }>, Schema.Struct<{
+      readonly status: Schema.Literal<"unknown">;
+      readonly reason: Schema.Literal<"CUSTOM_RESOLVER">;
+    }>]>;
+    readonly requiredRole: Schema.BigInt;
+    readonly resource: Schema.NullOr<Schema.BigInt>;
+  }>>;
+  readonly ownership: Schema.Struct<{
+    readonly setOwner: Schema.Boolean;
+    readonly setResolver: Schema.Boolean;
+    readonly createSubname: Schema.Boolean;
+    readonly transfer: Schema.Boolean;
+    readonly setExpiry: Schema.Boolean;
+  }>;
+}>;
+type NameCapabilities = typeof NameCapabilities.Type;
+//#endregion
+export { AccountCapabilityParameters, AuthorizationDecision, AuthorizationRequirement, AuthorizationSource, CapabilityError, HasRegistryRolesResult, HasResolverRolesResult, NameCapabilities, NameCapabilityParameters, OperatorApprovalResult, OperatorApprovalTarget, RecordOperation, RecordPermission, RecordPermissionsResult, RegistryCapabilities, RegistryOperation, RegistryRolesResult, RequiredAuthorizationResult, ResolverCapabilities, ResolverDelegateApprovalResult, ResolverProfiles, ResolverRolesResult, TokenApprovalResult, WrapperPermissionsResult, WriteOperation, WriteTarget };
+//# sourceMappingURL=types.d.ts.map