@thurinlabs/identity-kit 1.0.3 → 1.1.0

package/dist/core.d.cts

@@ -0,0 +1,1552 @@
+import * as viem from 'viem';
+import { Hex, TypedDataDomain } from 'viem';
+
+interface Attestation {
+    /** Position in the owner's attestation history. */
+    index: number;
+    /** Lowercase hex fingerprint, no 0x (40 chars for v4 keys, 64 for v6). */
+    fingerprint: string;
+    /** Unix seconds. */
+    createdAt: number;
+    revoked: boolean;
+    /** Unix seconds, or null while active. */
+    revokedAt: number | null;
+    /** Format of the clearsigned message (1 = "I control the Ethereum address: <address>"). */
+    messageVersion: number;
+    /** The clearsigned message stored on-chain (null only if the payload read failed). */
+    pgpSignature: string | null;
+    /** The armored public key stored on-chain (null only if the payload read failed). */
+    pgpPublicKey: string | null;
+    verification: PGPVerification | null;
+}
+interface PGPVerification {
+    verified: boolean;
+    reason?: string;
+}
+interface PGPKeyInfo {
+    fingerprint: string;
+    userIDs: string[];
+    algorithm: string;
+    created: string | null;
+    expires: string | null;
+    notations: Notation[];
+    subkeys: SubkeyInfo[];
+}
+interface SubkeyInfo {
+    algorithm: string;
+    created: string | null;
+    fingerprint: string;
+}
+interface Notation {
+    name: string;
+    value: string;
+}
+interface Proof {
+    provider: string;
+    label: string;
+    url: string;
+    user?: string;
+    instance?: string;
+    repo?: string;
+    gistId?: string;
+    castHash?: string;
+    domain?: string;
+}
+interface ProofResult {
+    provider: string;
+    label: string;
+    url: string;
+    displayUrl: string;
+    href: string | null;
+    secondaryHref: string | null;
+    status: 'verified' | 'unverified' | 'pending' | 'skipped';
+    reason?: string;
+}
+interface EFPGraph {
+    followers: number;
+    following: number;
+    top8: string[];
+    hasEfp: boolean;
+}
+interface ThurinIdentity {
+    address: string | null;
+    ensName: string | null;
+    ensAvatar: string | null;
+    claims: Attestation[];
+    totalClaims: number;
+    activeClaims: number;
+    currentFingerprint: string | null;
+    pgpKeyInfo: PGPKeyInfo | null;
+    proofs: ProofResult[];
+    efp: EFPGraph | null;
+    isLoading: boolean;
+    error: Error | null;
+}
+type Theme = 'thurin' | 'dark' | 'light';
+interface IdentityKitConfig {
+    rpcUrl?: string;
+    neynarApiKey?: string;
+    baseUrl?: string;
+    /** Which PGPRegistry deployment to read: 'mainnet' (default) or 'sepolia'. */
+    network?: 'mainnet' | 'sepolia' | 'local';
+    /** Override the registry address (e.g. a local deploy that landed elsewhere). */
+    registryAddress?: string;
+}
+
+declare const REGISTRY_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "ATTEST_TYPEHASH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "DOMAIN_SEPARATOR";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "EIP712_NAME";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "EIP712_VERSION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MAX_KEY_BYTES";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MAX_RECORD_BYTES";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MAX_SIG_BYTES";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MESSAGE_VERSION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "REATTEST_TYPEHASH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "REVOKE_TYPEHASH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "SET_RECORD_TYPEHASH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "UPDATE_KEY_TYPEHASH";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "VERSION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "addressesFor";
+    readonly inputs: readonly [{
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "addressesForCount";
+    readonly inputs: readonly [{
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "addressesForRange";
+    readonly inputs: readonly [{
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "start";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "count";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "out";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "attest";
+    readonly inputs: readonly [{
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "attestFor";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "attestationCount";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "attestationsOf";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple[]";
+        readonly internalType: "struct PGPRegistry.Attestation[]";
+        readonly components: readonly [{
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "createdAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "revokedAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "messageVersion";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "keyPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "sigPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "attestationsOfRange";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "start";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "count";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "out";
+        readonly type: "tuple[]";
+        readonly internalType: "struct PGPRegistry.Attestation[]";
+        readonly components: readonly [{
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "createdAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "revokedAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "messageVersion";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "keyPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "sigPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "cancelAuthorization";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "current";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "found";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "attestation";
+        readonly type: "tuple";
+        readonly internalType: "struct PGPRegistry.Attestation";
+        readonly components: readonly [{
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "createdAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "revokedAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "messageVersion";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "keyPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "sigPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "fingerprintsForKeyId";
+    readonly inputs: readonly [{
+        readonly name: "keyId";
+        readonly type: "bytes8";
+        readonly internalType: "bytes8";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes[]";
+        readonly internalType: "bytes[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "fingerprintsForKeyIdCount";
+    readonly inputs: readonly [{
+        readonly name: "keyId";
+        readonly type: "bytes8";
+        readonly internalType: "bytes8";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "fingerprintsForKeyIdRange";
+    readonly inputs: readonly [{
+        readonly name: "keyId";
+        readonly type: "bytes8";
+        readonly internalType: "bytes8";
+    }, {
+        readonly name: "start";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "count";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "out";
+        readonly type: "bytes[]";
+        readonly internalType: "bytes[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getAttestation";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct PGPRegistry.Attestation";
+        readonly components: readonly [{
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "createdAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "revokedAt";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "messageVersion";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "keyPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "sigPtr";
+            readonly type: "address";
+            readonly internalType: "address";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getPayload";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "nonces";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "reattest";
+    readonly inputs: readonly [{
+        readonly name: "revokeIndex";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "reattestFor";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "revokeIndex";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "record";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "kind";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "revoke";
+    readonly inputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "revokeFor";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setRecord";
+    readonly inputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "kind";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "value";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "setRecordFor";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "kind";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "value";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "updateKey";
+    readonly inputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "updateKeyFor";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "event";
+    readonly name: "Attested";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+        readonly indexed: false;
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "messageVersion";
+        readonly type: "uint8";
+        readonly indexed: false;
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "keyPtr";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "sigPtr";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "submitter";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "KeyUpdated";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "oldKeyPtr";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newKeyPtr";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "submitter";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "NonceUsed";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "RecordSet";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "kind";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "submitter";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Revoked";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "fingerprintHash";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+        readonly indexed: true;
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "submitter";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "AlreadyRevoked";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "AuthorizationExpired";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "DeploymentFailed";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "DuplicateActiveFingerprint";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "EmptyPublicKey";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "EmptySignature";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "IndexOutOfBounds";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidAuthorization";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidFingerprintLength";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "InvalidPointer";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "PublicKeyTooLarge";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "RecordTooLarge";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "SignatureTooLarge";
+    readonly inputs: readonly [];
+}];
+
+/**
+ * PGPRegistry v2 is deployed with CREATE2, so it has the same address on every
+ * network. (v1 lived at 0xf7a45BC662A78a6fb417ED5f52b3766cbf13EbBb on mainnet and
+ * is no longer read by Thurin.)
+ */
+declare const REGISTRY_ADDRESS: "0x9302E02e2869e129aC8516fE5eFFd51EA3082c09";
+/** Networks the PGPRegistry is deployed on. `mainnet` is the default everywhere. */
+type NetworkName = 'mainnet' | 'sepolia' | 'local';
+interface RegistryDeployment {
+    chainId: number;
+    address: `0x${string}`;
+    /** Block the registry was deployed in (informational; v2 needs no log scans). */
+    deployBlock: bigint;
+    /** Block explorer base URL for address/tx links. Empty when there is none. */
+    explorerUrl: string;
+    /** Keyless public RPC used when no rpcUrl is configured. */
+    defaultRpcUrl: string;
+}
+declare const NETWORKS: Record<NetworkName, RegistryDeployment>;
+declare function isNetworkName(value: unknown): value is NetworkName;
+/**
+ * The registry deployment for a network. `addressOverride` swaps the contract
+ * address (e.g. a local deploy that landed somewhere else).
+ */
+declare function getRegistry(network?: NetworkName, addressOverride?: string): RegistryDeployment;
+/** The viem chain object for a network name. */
+declare function chainFor(network?: NetworkName): {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://sepolia.etherscan.io";
+            readonly apiUrl: "https://api-sepolia.etherscan.io/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 751532;
+        };
+        readonly ensUniversalResolver: {
+            readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+            readonly blockCreated: 8928790;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 11155111;
+    name: "Sepolia";
+    nativeCurrency: {
+        readonly name: "Sepolia Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+} | {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 31337;
+    name: "Foundry";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["http://127.0.0.1:8545"];
+            readonly webSocket: readonly ["ws://127.0.0.1:8545"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+} | {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Etherscan";
+            readonly url: "https://etherscan.io";
+            readonly apiUrl: "https://api.etherscan.io/api";
+        };
+    };
+    blockTime: 12000;
+    contracts: {
+        readonly ensUniversalResolver: {
+            readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+            readonly blockCreated: 23085558;
+        };
+        readonly multicall3: {
+            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            readonly blockCreated: 14353601;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 1;
+    name: "Ethereum";
+    nativeCurrency: {
+        readonly name: "Ether";
+        readonly symbol: "ETH";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://eth.merkle.io"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+};
+
+declare function identifyProof(notation: Notation): Proof | null;
+declare function displayUrl(proof: Proof): string;
+declare function proofHref(proof: Proof): string | null;
+declare function proofSecondaryHref(proof: Proof): string | null;
+declare function verifyProof(proof: Proof, fingerprint: string, neynarApiKey?: string): Promise<PGPVerification>;
+
+declare function parsePgpKey(armoredKey: string): Promise<PGPKeyInfo | null>;
+declare function verifyAttestation({ pgpPublicKey, pgpSignature, fingerprint, ethAddress, }: {
+    pgpPublicKey: string | null;
+    pgpSignature: string | null;
+    fingerprint: string;
+    ethAddress: string;
+}): Promise<PGPVerification>;
+interface StrippedKey {
+    /** Armored public key containing only the non-email user IDs. */
+    armored: string;
+    /** User IDs kept (no `@`). */
+    kept: string[];
+    /** User IDs removed (contained an `@`). */
+    removed: string[];
+}
+/**
+ * Remove every user ID that contains an email address, keeping the rest (and
+ * their self-certifications, so proof notations on a non-email user ID survive).
+ * Returns null when nothing would remain — openpgp needs at least one
+ * self-certified user ID to verify signatures, so such a key must not be
+ * published. The key material and subkeys are untouched; the fingerprint is
+ * unchanged.
+ */
+declare function stripEmailUserIDs(armoredKey: string): Promise<StrippedKey | null>;
+/** True when any user ID on the key contains an email address. */
+declare function hasEmailUserID(armoredKey: string): Promise<boolean>;
+declare function fetchKeyByFingerprint(fingerprint: string): Promise<string | null>;
+declare function fetchKeyByKeyId(keyId: string): Promise<string | null>;
+
+/**
+ * EFP social graph for an address. Followers are counted by EFP for any address,
+ * whether or not it has published a list of its own; following and top-8 exist
+ * only when it has (its "primary list"). An address with followers but no list
+ * — a project account that has never followed anyone — is still on EFP.
+ */
+declare function fetchEFPGraph(address: string): Promise<EFPGraph | null>;
+
+/** Normalize a fingerprint to lowercase hex with no prefix or spaces. Returns null if malformed. */
+declare function normalizeFingerprint(input: string): string | null;
+/** Fingerprint → the raw `bytes` argument the v2 registry takes (0x-prefixed, 20 or 32 bytes). */
+declare function fingerprintToBytes(fingerprint: string): Hex;
+/** Raw `bytes` from the registry → lowercase hex fingerprint without 0x. */
+declare function bytesToFingerprint(bytes: Hex | string): string;
+/** keccak256 of the raw fingerprint bytes — the `fingerprintHash` the registry indexes by. */
+declare function fingerprintHash(fingerprint: string): Hex;
+/**
+ * The long key ID as the `bytes8` the registry indexes by. Per RFC 9580 §5.5.4 it is the
+ * low-order 8 bytes of a v4 (20-byte) fingerprint and the high-order 8 bytes of a v6
+ * (32-byte) fingerprint — the same value `gpg --keyid-format long` prints.
+ */
+declare function keyIdOf(fingerprint: string): Hex;
+/** A 16-hex long key ID (spaces/0x tolerated) → `bytes8`. */
+declare function keyIdToBytes(keyId: string): Hex | null;
+
+/**
+ * EIP-712 authorizations for the registry's relayed writes (`attestFor`, `reattestFor`,
+ * `updateKeyFor`, `revokeFor`, `setRecordFor`). The owner signs one of these typed
+ * structs; anyone can then submit the matching call and pay the gas. Every field is
+ * bound, plus the owner's current `nonce` (read with `nonces(owner)`) and a `deadline`.
+ *
+ * The domain includes the chain id, so an authorization for one network cannot be
+ * replayed on another even though the registry has the same address everywhere.
+ */
+declare const EIP712_NAME = "Thurin PGPRegistry";
+declare const EIP712_VERSION = "2";
+declare function registryDomain(chainId: number, verifyingContract: Hex): TypedDataDomain;
+declare const AUTHORIZATION_TYPES: {
+    readonly Attest: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly Reattest: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "revokeIndex";
+        readonly type: "uint256";
+    }, {
+        readonly name: "fingerprint";
+        readonly type: "bytes";
+    }, {
+        readonly name: "pgpSignature";
+        readonly type: "bytes";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly UpdateKey: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+    }, {
+        readonly name: "pgpPublicKey";
+        readonly type: "bytes";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly Revoke: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly SetRecord: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+    }, {
+        readonly name: "kind";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "value";
+        readonly type: "bytes";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
+type AuthorizationAction = keyof typeof AUTHORIZATION_TYPES;
+interface Common {
+    owner: Hex;
+    nonce: bigint;
+    deadline: bigint;
+}
+type AttestAuthorization = Common & {
+    fingerprint: string;
+    pgpSignature: string;
+    pgpPublicKey: string;
+};
+type ReattestAuthorization = AttestAuthorization & {
+    revokeIndex: bigint;
+};
+type UpdateKeyAuthorization = Common & {
+    index: bigint;
+    pgpPublicKey: string;
+};
+type RevokeAuthorization = Common & {
+    index: bigint;
+};
+type SetRecordAuthorization = Common & {
+    index: bigint;
+    kind: Hex;
+    value: Hex;
+};
+/**
+ * Build the object to pass to viem/wagmi `signTypedData`. `fingerprint` is the hex
+ * fingerprint; `pgpSignature` / `pgpPublicKey` are the armored text exactly as they
+ * will be submitted (they are hashed as UTF-8 bytes).
+ */
+declare function attestTypedData(chainId: number, registry: Hex, a: AttestAuthorization): {
+    domain: TypedDataDomain;
+    types: {
+        Attest: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+        }, {
+            readonly name: "pgpSignature";
+            readonly type: "bytes";
+        }, {
+            readonly name: "pgpPublicKey";
+            readonly type: "bytes";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "Attest";
+    message: {
+        owner: `0x${string}`;
+        fingerprint: `0x${string}`;
+        pgpSignature: `0x${string}`;
+        pgpPublicKey: `0x${string}`;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+declare function reattestTypedData(chainId: number, registry: Hex, a: ReattestAuthorization): {
+    domain: TypedDataDomain;
+    types: {
+        Reattest: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "revokeIndex";
+            readonly type: "uint256";
+        }, {
+            readonly name: "fingerprint";
+            readonly type: "bytes";
+        }, {
+            readonly name: "pgpSignature";
+            readonly type: "bytes";
+        }, {
+            readonly name: "pgpPublicKey";
+            readonly type: "bytes";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "Reattest";
+    message: {
+        revokeIndex: bigint;
+        owner: `0x${string}`;
+        fingerprint: `0x${string}`;
+        pgpSignature: `0x${string}`;
+        pgpPublicKey: `0x${string}`;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+declare function updateKeyTypedData(chainId: number, registry: Hex, a: UpdateKeyAuthorization): {
+    domain: TypedDataDomain;
+    types: {
+        UpdateKey: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "index";
+            readonly type: "uint256";
+        }, {
+            readonly name: "pgpPublicKey";
+            readonly type: "bytes";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "UpdateKey";
+    message: {
+        owner: `0x${string}`;
+        index: bigint;
+        pgpPublicKey: `0x${string}`;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+declare function revokeTypedData(chainId: number, registry: Hex, a: RevokeAuthorization): {
+    domain: TypedDataDomain;
+    types: {
+        Revoke: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "index";
+            readonly type: "uint256";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "Revoke";
+    message: {
+        owner: `0x${string}`;
+        index: bigint;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+declare function setRecordTypedData(chainId: number, registry: Hex, a: SetRecordAuthorization): {
+    domain: TypedDataDomain;
+    types: {
+        SetRecord: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "index";
+            readonly type: "uint256";
+        }, {
+            readonly name: "kind";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "value";
+            readonly type: "bytes";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    primaryType: "SetRecord";
+    message: {
+        owner: `0x${string}`;
+        index: bigint;
+        kind: `0x${string}`;
+        value: `0x${string}`;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+/** The digest the registry recovers the signer from — handy for tests and CLIs. */
+declare function authorizationDigest(typedData: ReturnType<typeof attestTypedData | typeof reattestTypedData | typeof updateKeyTypedData | typeof revokeTypedData | typeof setRecordTypedData>): Hex;
+/** `bytes32 kind` for a record from a human-readable name, e.g. recordKind('thurin.vouch'). */
+declare function recordKind(name: string): Hex;
+
+export { AUTHORIZATION_TYPES, type AttestAuthorization, type Attestation, type AuthorizationAction, type EFPGraph, EIP712_NAME, EIP712_VERSION, type IdentityKitConfig, NETWORKS, type NetworkName, type Notation, type PGPKeyInfo, type PGPVerification, type Proof, type ProofResult, REGISTRY_ABI, REGISTRY_ADDRESS, type ReattestAuthorization, type RegistryDeployment, type RevokeAuthorization, type SetRecordAuthorization, type StrippedKey, type SubkeyInfo, type Theme, type ThurinIdentity, type UpdateKeyAuthorization, attestTypedData, authorizationDigest, bytesToFingerprint, chainFor, displayUrl, fetchEFPGraph, fetchKeyByFingerprint, fetchKeyByKeyId, fingerprintHash, fingerprintToBytes, getRegistry, hasEmailUserID, identifyProof, isNetworkName, keyIdOf, keyIdToBytes, normalizeFingerprint, parsePgpKey, proofHref, proofSecondaryHref, reattestTypedData, recordKind, registryDomain, revokeTypedData, setRecordTypedData, stripEmailUserIDs, updateKeyTypedData, verifyAttestation, verifyProof };