@techdigger/humanode-agentlink 0.2.0

package/dist/cjs/index.d.ts

@@ -0,0 +1,963 @@
+import { z } from 'zod';
+import { ResourceServerExtension, Price, Network, SchemeNetworkServer } from '@x402/core/types';
+import { PublicClient, TypedDataDomain, Hex } from 'viem';
+import { x402ResourceServer, FacilitatorClient, x402HTTPResourceServer as x402HTTPResourceServer$1, PaywallConfig as PaywallConfig$1, PaywallProvider as PaywallProvider$1 } from '@x402/core/server';
+import { x402HTTPResourceServer, RouteConfig, DynamicPrice, DynamicPayTo, RoutesConfig, PaywallConfig, PaywallProvider } from '@x402/core/http';
+
+declare const AGENTLINK = "agentlink";
+type SignatureScheme = 'eip191' | 'eip1271';
+type SignatureType = 'eip191' | 'eip1271';
+interface SupportedChain {
+    chainId: string;
+    type: SignatureType;
+    signatureScheme?: SignatureScheme;
+}
+interface AgentLinkExtensionInfo {
+    domain: string;
+    uri: string;
+    statement?: string;
+    version: string;
+    nonce: string;
+    issuedAt: string;
+    expirationTime?: string;
+    notBefore?: string;
+    requestId?: string;
+    resources?: string[];
+}
+interface AgentLinkExtensionSchema {
+    $schema: string;
+    type: 'object';
+    properties: {
+        domain: {
+            type: 'string';
+        };
+        address: {
+            type: 'string';
+        };
+        statement?: {
+            type: 'string';
+        };
+        uri: {
+            type: 'string';
+            format: 'uri';
+        };
+        version: {
+            type: 'string';
+        };
+        chainId: {
+            type: 'string';
+        };
+        type: {
+            type: 'string';
+        };
+        nonce: {
+            type: 'string';
+        };
+        issuedAt: {
+            type: 'string';
+            format: 'date-time';
+        };
+        expirationTime?: {
+            type: 'string';
+            format: 'date-time';
+        };
+        notBefore?: {
+            type: 'string';
+            format: 'date-time';
+        };
+        requestId?: {
+            type: 'string';
+        };
+        resources?: {
+            type: 'array';
+            items: {
+                type: 'string';
+                format: 'uri';
+            };
+        };
+        signature: {
+            type: 'string';
+        };
+    };
+    required: string[];
+}
+interface AgentLinkExtension {
+    info: AgentLinkExtensionInfo;
+    supportedChains: SupportedChain[];
+    schema: AgentLinkExtensionSchema;
+    mode?: AgentLinkMode;
+}
+interface AgentLinkUsageContext {
+    platformAccountId?: string;
+    workspaceId?: string;
+}
+interface AgentLinkEntitlement extends AgentLinkUsageContext {
+    endpoint: string;
+    owner: string;
+    generationPtr: bigint;
+}
+declare const AgentLinkPayloadSchema: z.ZodObject<{
+    domain: z.ZodString;
+    address: z.ZodString;
+    statement: z.ZodOptional<z.ZodString>;
+    uri: z.ZodString;
+    version: z.ZodString;
+    chainId: z.ZodString;
+    type: z.ZodEnum<["eip191", "eip1271"]>;
+    nonce: z.ZodString;
+    issuedAt: z.ZodString;
+    expirationTime: z.ZodOptional<z.ZodString>;
+    notBefore: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodOptional<z.ZodString>;
+    resources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    signatureScheme: z.ZodOptional<z.ZodEnum<["eip191", "eip1271"]>>;
+    signature: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uri: string;
+    domain: string;
+    address: string;
+    version: string;
+    chainId: string;
+    type: "eip191" | "eip1271";
+    nonce: string;
+    issuedAt: string;
+    signature: string;
+    statement?: string | undefined;
+    expirationTime?: string | undefined;
+    notBefore?: string | undefined;
+    requestId?: string | undefined;
+    resources?: string[] | undefined;
+    signatureScheme?: "eip191" | "eip1271" | undefined;
+}, {
+    uri: string;
+    domain: string;
+    address: string;
+    version: string;
+    chainId: string;
+    type: "eip191" | "eip1271";
+    nonce: string;
+    issuedAt: string;
+    signature: string;
+    statement?: string | undefined;
+    expirationTime?: string | undefined;
+    notBefore?: string | undefined;
+    requestId?: string | undefined;
+    resources?: string[] | undefined;
+    signatureScheme?: "eip191" | "eip1271" | undefined;
+}>;
+type AgentLinkPayload = z.infer<typeof AgentLinkPayloadSchema>;
+type AgentLinkMode = {
+    type: 'linked-only';
+    reason?: string;
+} | {
+    type: 'free';
+} | {
+    type: 'free-trial';
+    uses?: number;
+} | {
+    type: 'discount';
+    percent: number;
+    uses?: number;
+};
+interface DeclareAgentLinkOptions {
+    domain?: string;
+    resourceUri?: string;
+    statement?: string;
+    version?: string;
+    network?: string | string[];
+    expirationSeconds?: number;
+    mode?: AgentLinkMode;
+}
+interface AgentLinkValidationResult {
+    valid: boolean;
+    error?: string;
+}
+interface AgentLinkValidationOptions {
+    maxAge?: number;
+    checkNonce?: (nonce: string) => boolean | Promise<boolean>;
+}
+interface AgentLinkVerifyResult {
+    valid: boolean;
+    address?: string;
+    error?: string;
+}
+type CompleteAgentLinkInfo = AgentLinkExtensionInfo & {
+    chainId: string;
+    type: SignatureType;
+    signatureScheme?: SignatureScheme;
+};
+
+interface AgentLinkDeclaration extends AgentLinkExtension {
+    _options: DeclareAgentLinkOptions;
+}
+declare function declareAgentLinkExtension(options?: DeclareAgentLinkOptions): Record<string, AgentLinkDeclaration>;
+
+declare const agentlinkResourceServerExtension: ResourceServerExtension;
+
+declare function parseAgentLinkHeader(header: string): AgentLinkPayload;
+
+declare function validateAgentLinkMessage(message: AgentLinkPayload, expectedResourceUri: string, options?: AgentLinkValidationOptions): Promise<AgentLinkValidationResult>;
+
+declare function verifyAgentLinkSignature(payload: AgentLinkPayload, rpcUrl?: string): Promise<AgentLinkVerifyResult>;
+
+declare function buildAgentLinkSchema(): AgentLinkExtensionSchema;
+
+declare function extractEVMChainId(chainId: string): number;
+declare function formatSIWEMessage(info: CompleteAgentLinkInfo, address: string): string;
+/**
+ * Verify an EVM signature using ERC-1271 (smart wallets) with ecrecover fallback (EOA).
+ * Uses viem's publicClient.verifyMessage which handles both automatically.
+ */
+declare function verifyEVMSignature(message: string, address: string, signature: string, chainId: string, rpcUrl?: string): Promise<boolean>;
+
+type BiomapperRegistryNetwork = 'base' | 'base-sepolia';
+interface BiomapperAgentStatus {
+    owner: `0x${string}` | null;
+    generationPtr: bigint;
+    active: boolean;
+}
+declare const BIOMAPPER_AGENT_REGISTRY_ABI$1: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "agent";
+        readonly type: "address";
+    }];
+    readonly name: "agentNonce";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "agent";
+        readonly type: "address";
+    }];
+    readonly name: "getAgentStatus";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "generationPtr";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "active";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "agent";
+        readonly type: "address";
+    }];
+    readonly name: "linkedOwner";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "agent";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "signature";
+        readonly type: "bytes";
+    }];
+    readonly name: "linkAgent";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+interface BiomapperRegistryOptions {
+    client?: PublicClient;
+    contractAddress?: `0x${string}`;
+    rpcUrl?: string;
+    network?: BiomapperRegistryNetwork;
+}
+declare function createBiomapperRegistryVerifier(options?: BiomapperRegistryOptions): {
+    getAgentStatus(address: string, chainId: string): Promise<BiomapperAgentStatus | null>;
+};
+type BiomapperRegistryVerifier = ReturnType<typeof createBiomapperRegistryVerifier>;
+
+type BiomapperBridgeNetwork = 'base' | 'base-sepolia';
+declare const BRIDGED_BIOMAPPER_ADDRESSES: Record<BiomapperBridgeNetwork, `0x${string}`>;
+declare const BIOMAPPER_APP_URLS: Record<BiomapperBridgeNetwork, string>;
+declare const BRIDGED_BIOMAPPER_READ_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly name: "generationsHead";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "generationPtr";
+        readonly type: "uint256";
+    }];
+    readonly name: "lookupBiomappingPtr";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+
+declare const BiomapperNetworkSchema: z.ZodEnum<["base", "base-sepolia"]>;
+type BiomapperQueryNetwork = z.infer<typeof BiomapperNetworkSchema>;
+declare const CHECK_AGENT_STATUS_TOOL_NAME = "check_agent_status";
+declare const GET_CURRENT_GENERATION_TOOL_NAME = "get_current_generation";
+declare const GET_BIOMAPPER_INFO_TOOL_NAME = "get_biomapper_info";
+declare const CHECK_AGENT_STATUS_TOOL_DESCRIPTION = "Check if an agent wallet is linked to a biomapped human and whether the link is currently active. Returns the owner address, current Biomapper generation pointer, and active status.";
+declare const GET_CURRENT_GENERATION_TOOL_DESCRIPTION = "Get the current Biomapper generation pointer from the Bridged Biomapper contract. Generations represent verification periods \u2014 when a generation ends, usage quotas reset.";
+declare const GET_BIOMAPPER_INFO_TOOL_DESCRIPTION = "Get Biomapper network metadata \u2014 contract addresses, app URLs, and supported networks. Useful for discovering where to point registry queries or where users can verify their identity.";
+declare const CheckAgentStatusInputSchema: z.ZodObject<{
+    agentAddress: z.ZodString;
+    network: z.ZodOptional<z.ZodEnum<["base", "base-sepolia"]>>;
+    registryAddress: z.ZodOptional<z.ZodString>;
+    rpcUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    agentAddress: string;
+    network?: "base" | "base-sepolia" | undefined;
+    registryAddress?: string | undefined;
+    rpcUrl?: string | undefined;
+}, {
+    agentAddress: string;
+    network?: "base" | "base-sepolia" | undefined;
+    registryAddress?: string | undefined;
+    rpcUrl?: string | undefined;
+}>;
+declare const GetCurrentGenerationInputSchema: z.ZodObject<{
+    network: z.ZodOptional<z.ZodEnum<["base", "base-sepolia"]>>;
+    rpcUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    network?: "base" | "base-sepolia" | undefined;
+    rpcUrl?: string | undefined;
+}, {
+    network?: "base" | "base-sepolia" | undefined;
+    rpcUrl?: string | undefined;
+}>;
+declare const GetBiomapperInfoInputSchema: z.ZodObject<{
+    network: z.ZodOptional<z.ZodEnum<["base", "base-sepolia"]>>;
+}, "strip", z.ZodTypeAny, {
+    network?: "base" | "base-sepolia" | undefined;
+}, {
+    network?: "base" | "base-sepolia" | undefined;
+}>;
+declare const BiomapperNetworkInfoSchema: z.ZodObject<{
+    network: z.ZodEnum<["base", "base-sepolia"]>;
+    bridgedBiomapper: z.ZodString;
+    biomapperAppUrl: z.ZodString;
+    chainId: z.ZodNumber;
+    caip2: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    network: "base" | "base-sepolia";
+    bridgedBiomapper: string;
+    biomapperAppUrl: string;
+    caip2: string;
+}, {
+    chainId: number;
+    network: "base" | "base-sepolia";
+    bridgedBiomapper: string;
+    biomapperAppUrl: string;
+    caip2: string;
+}>;
+declare const CheckAgentStatusResultSchema: z.ZodObject<{
+    linked: z.ZodBoolean;
+    active: z.ZodBoolean;
+    agentAddress: z.ZodString;
+    owner: z.ZodNullable<z.ZodString>;
+    generationPtr: z.ZodNullable<z.ZodString>;
+    network: z.ZodEnum<["base", "base-sepolia"]>;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    owner: string | null;
+    generationPtr: string | null;
+    message: string;
+    active: boolean;
+    agentAddress: string;
+    network: "base" | "base-sepolia";
+    linked: boolean;
+}, {
+    owner: string | null;
+    generationPtr: string | null;
+    message: string;
+    active: boolean;
+    agentAddress: string;
+    network: "base" | "base-sepolia";
+    linked: boolean;
+}>;
+declare const GetCurrentGenerationResultSchema: z.ZodObject<{
+    generationsHead: z.ZodString;
+    network: z.ZodEnum<["base", "base-sepolia"]>;
+    bridgedBiomapper: z.ZodString;
+    biomapperAppUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    generationsHead: string;
+    network: "base" | "base-sepolia";
+    bridgedBiomapper: string;
+    biomapperAppUrl: string;
+}, {
+    generationsHead: string;
+    network: "base" | "base-sepolia";
+    bridgedBiomapper: string;
+    biomapperAppUrl: string;
+}>;
+declare const GetBiomapperInfoResultSchema: z.ZodObject<{
+    networks: z.ZodArray<z.ZodObject<{
+        network: z.ZodEnum<["base", "base-sepolia"]>;
+        bridgedBiomapper: z.ZodString;
+        biomapperAppUrl: z.ZodString;
+        chainId: z.ZodNumber;
+        caip2: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        chainId: number;
+        network: "base" | "base-sepolia";
+        bridgedBiomapper: string;
+        biomapperAppUrl: string;
+        caip2: string;
+    }, {
+        chainId: number;
+        network: "base" | "base-sepolia";
+        bridgedBiomapper: string;
+        biomapperAppUrl: string;
+        caip2: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    networks: {
+        chainId: number;
+        network: "base" | "base-sepolia";
+        bridgedBiomapper: string;
+        biomapperAppUrl: string;
+        caip2: string;
+    }[];
+}, {
+    networks: {
+        chainId: number;
+        network: "base" | "base-sepolia";
+        bridgedBiomapper: string;
+        biomapperAppUrl: string;
+        caip2: string;
+    }[];
+}>;
+type CheckAgentStatusInput = z.infer<typeof CheckAgentStatusInputSchema>;
+type GetCurrentGenerationInput = z.infer<typeof GetCurrentGenerationInputSchema>;
+type GetBiomapperInfoInput = z.infer<typeof GetBiomapperInfoInputSchema>;
+type BiomapperNetworkInfo = z.infer<typeof BiomapperNetworkInfoSchema>;
+type CheckAgentStatusResult = z.infer<typeof CheckAgentStatusResultSchema>;
+type GetCurrentGenerationResult = z.infer<typeof GetCurrentGenerationResultSchema>;
+type GetBiomapperInfoResult = z.infer<typeof GetBiomapperInfoResultSchema>;
+type BiomapperQueryErrorCode = 'invalid_input' | 'missing_network' | 'missing_registry' | 'query_failed';
+declare class BiomapperQueryError extends Error {
+    readonly code: BiomapperQueryErrorCode;
+    constructor(code: BiomapperQueryErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+interface CreateBiomapperQueryClientOptions {
+    client?: PublicClient;
+    network?: BiomapperQueryNetwork;
+    registryAddress?: `0x${string}`;
+    rpcUrl?: string;
+}
+declare function createBiomapperQueryClient(defaults?: CreateBiomapperQueryClientOptions): {
+    checkAgentStatus(input: CheckAgentStatusInput): Promise<CheckAgentStatusResult>;
+    getCurrentGeneration(input?: GetCurrentGenerationInput): Promise<GetCurrentGenerationResult>;
+    getBiomapperInfo(input?: GetBiomapperInfoInput): Promise<GetBiomapperInfoResult>;
+};
+type BiomapperQueryClient = ReturnType<typeof createBiomapperQueryClient>;
+
+declare const BIOMAPPER_AGENT_REGISTRY_NAME = "BiomapperAgentRegistry";
+declare const BIOMAPPER_AGENT_REGISTRY_VERSION = "1";
+declare const AGENT_LINK_TYPES: {
+    readonly AgentLink: readonly [{
+        readonly name: "agent";
+        readonly type: "address";
+    }, {
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
+interface AgentLinkAuthorization {
+    agent: `0x${string}`;
+    owner: `0x${string}`;
+    registry: `0x${string}`;
+    chainId: number;
+    nonce: bigint;
+    deadline: bigint;
+    signature?: `0x${string}`;
+}
+interface AgentLinkConsentOutput {
+    type: 'biomapper-agent-link';
+    network: BiomapperBridgeNetwork;
+    chainId: number;
+    agent: `0x${string}`;
+    owner: `0x${string}`;
+    registry: `0x${string}`;
+    nonce: string;
+    deadline: string;
+    typedData: {
+        domain: {
+            name: string;
+            version: string;
+            chainId: number;
+            verifyingContract: `0x${string}`;
+        };
+        types: typeof AGENT_LINK_TYPES;
+        primaryType: 'AgentLink';
+        message: {
+            agent: `0x${string}`;
+            owner: `0x${string}`;
+            nonce: string;
+            deadline: string;
+        };
+    };
+    signature: `0x${string}`;
+}
+interface AgentLinkConsentSigner {
+    address: `0x${string}`;
+    signTypedData(input: ReturnType<typeof buildAgentLinkTypedData>): Promise<`0x${string}`>;
+}
+interface CreateAgentLinkConsentOptions {
+    owner: `0x${string}`;
+    registry: `0x${string}`;
+    deadline: bigint;
+    network: BiomapperBridgeNetwork;
+    privateKey?: Hex;
+    signer?: AgentLinkConsentSigner;
+    client?: AgentLinkConsentClient;
+    rpcUrl?: string;
+}
+interface AgentLinkConsentClient {
+    getChainId?(): Promise<number>;
+    readContract(input: {
+        address: `0x${string}`;
+        abi: typeof BIOMAPPER_AGENT_REGISTRY_ABI;
+        functionName: 'agentNonce';
+        args: [`0x${string}`];
+    }): Promise<bigint>;
+}
+declare const BIOMAPPER_AGENT_REGISTRY_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "agent";
+        readonly type: "address";
+    }];
+    readonly name: "agentNonce";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+declare function buildAgentLinkTypedData(input: AgentLinkAuthorization): {
+    domain: TypedDataDomain;
+    types: typeof AGENT_LINK_TYPES;
+    primaryType: 'AgentLink';
+    message: {
+        agent: `0x${string}`;
+        owner: `0x${string}`;
+        nonce: bigint;
+        deadline: bigint;
+    };
+};
+declare function createAgentLinkConsent(options: CreateAgentLinkConsentOptions): Promise<AgentLinkConsentOutput>;
+
+interface AgentLinkStorage {
+    hasUsedNonce(nonce: string): Promise<boolean>;
+    recordNonce(nonce: string): Promise<void>;
+    getUsageCount?(endpoint: string, owner: string, generationPtr: bigint, context?: AgentLinkUsageContext): Promise<number>;
+    incrementUsage?(endpoint: string, owner: string, generationPtr: bigint, context?: AgentLinkUsageContext): Promise<void>;
+}
+declare function buildAgentLinkUsageKey(input: AgentLinkEntitlement): string;
+declare class InMemoryAgentLinkStorage implements AgentLinkStorage {
+    private usage;
+    private nonces;
+    getUsageCount(endpoint: string, owner: string, generationPtr: bigint, context?: AgentLinkUsageContext): Promise<number>;
+    incrementUsage(endpoint: string, owner: string, generationPtr: bigint, context?: AgentLinkUsageContext): Promise<void>;
+    hasUsedNonce(nonce: string): Promise<boolean>;
+    recordNonce(nonce: string): Promise<void>;
+}
+
+interface AgentLinkScopedEvent extends AgentLinkUsageContext {
+    resource: string;
+    endpoint: string;
+}
+type AgentLinkHookEvent = ({
+    type: 'agent_verified';
+    address: string;
+    owner: string;
+    generationPtr: bigint;
+} & AgentLinkScopedEvent) | ({
+    type: 'agent_not_verified';
+    address: string;
+} & AgentLinkScopedEvent) | ({
+    type: 'validation_failed';
+    error?: string;
+} & AgentLinkScopedEvent) | ({
+    type: 'discount_applied';
+    address: string;
+    owner: string;
+    generationPtr: bigint;
+} & AgentLinkScopedEvent) | ({
+    type: 'discount_exhausted';
+    address: string;
+    owner: string;
+    generationPtr: bigint;
+} & AgentLinkScopedEvent) | ({
+    type: 'link.activated';
+    address: string;
+    owner: string;
+    generationPtr: bigint;
+} & AgentLinkScopedEvent) | ({
+    type: 'link.deactivated';
+    address: string;
+    owner: string;
+    generationPtr: bigint;
+    reason: 'inactive';
+} & AgentLinkScopedEvent) | ({
+    type: 'link.unlinked';
+    address: string;
+    previousOwner: string;
+    generationPtr: bigint;
+} & AgentLinkScopedEvent) | ({
+    type: 'relink.required';
+    address: string;
+    owner: string;
+    generationPtr: bigint;
+    reason: 'inactive_owner';
+} & AgentLinkScopedEvent) | ({
+    type: 'usage.threshold_reached';
+    address: string;
+    owner: string;
+    generationPtr: bigint;
+    count: number;
+    threshold: number;
+    mode: Extract<AgentLinkMode['type'], 'free-trial' | 'discount'>;
+} & AgentLinkScopedEvent);
+interface AgentLinkSessionEvent extends AgentLinkUsageContext {
+    type: 'link.created';
+    sessionId: string;
+    network: BiomapperBridgeNetwork;
+    redirectUrl?: string;
+    registry?: `0x${string}`;
+    platformName?: string;
+}
+type AgentLinkEvent = AgentLinkHookEvent | AgentLinkSessionEvent;
+type AgentLinkEventHandler<TEvent extends AgentLinkEvent = AgentLinkEvent> = (event: TEvent) => void | Promise<void>;
+interface AgentLinkEntitlementContext extends AgentLinkUsageContext {
+    endpoint?: string;
+}
+interface ResolveAgentLinkEntitlementInput {
+    request: {
+        adapter: {
+            getHeader(name: string): string | undefined;
+            getUrl(): string;
+        };
+        path: string;
+    };
+    payload: AgentLinkPayload;
+    address: string;
+    status: {
+        owner: `0x${string}` | null;
+        generationPtr: bigint;
+        active: boolean;
+    } | null;
+}
+type AgentLinkEntitlementResolver = (input: ResolveAgentLinkEntitlementInput) => AgentLinkEntitlementContext | void | Promise<AgentLinkEntitlementContext | void>;
+
+interface CreateAgentLinkHooksOptions {
+    registry: BiomapperRegistryVerifier;
+    mode?: AgentLinkMode;
+    /** Required in all modes so replayed nonces are rejected. */
+    storage: AgentLinkStorage;
+    /** Custom RPC URL for EVM signature verification. Uses the chain's default public RPC if omitted. */
+    rpcUrl?: string;
+    onEvent?: (event: AgentLinkHookEvent) => void | Promise<void>;
+    entitlements?: AgentLinkEntitlementContext | AgentLinkEntitlementResolver;
+    usageThresholds?: number[];
+}
+declare function createAgentLinkHooks(options: CreateAgentLinkHooksOptions): {
+    requestHook: (context: {
+        adapter: {
+            getHeader(name: string): string | undefined;
+            getUrl(): string;
+        };
+        path: string;
+    }) => Promise<void | {
+        grantAccess: true;
+    } | {
+        abort: true;
+        reason: string;
+    }>;
+    verifyFailureHook: ((context: {
+        paymentPayload: {
+            resource: {
+                url: string;
+            };
+            payload: Record<string, unknown>;
+        };
+        requirements: {
+            amount: string;
+        };
+        error: Error;
+    }) => Promise<void | {
+        recovered: true;
+        result: {
+            isValid: boolean;
+            payer?: string;
+        };
+    }>) | undefined;
+};
+
+interface AgentLinkSessionBranding {
+    platformName?: string;
+    logoUrl?: string;
+    accentColor?: string;
+    supportUrl?: string;
+}
+interface AgentLinkSession {
+    id: string;
+    createdAt: string;
+    platformAccountId: string;
+    workspaceId?: string;
+    network: BiomapperBridgeNetwork;
+    registry: `0x${string}`;
+    redirectUrl?: string;
+    consent: AgentLinkConsentOutput;
+    branding?: AgentLinkSessionBranding;
+    metadata?: Record<string, string>;
+    expiresAt?: string;
+}
+interface CreateLinkSessionInput {
+    platformAccountId: string;
+    workspaceId?: string;
+    network: BiomapperBridgeNetwork;
+    registry: `0x${string}`;
+    redirectUrl?: string;
+    consent: AgentLinkConsentOutput;
+    branding?: AgentLinkSessionBranding;
+    metadata?: Record<string, string>;
+    expiresAt?: string;
+}
+interface AgentLinkSessionStore {
+    set(session: AgentLinkSession): Promise<void>;
+    get(id: string): Promise<AgentLinkSession | null>;
+}
+interface CreateLinkSessionOptions {
+    id?: string;
+    now?: Date;
+    store?: AgentLinkSessionStore;
+    onEvent?: AgentLinkEventHandler<AgentLinkSessionEvent>;
+    allowedRedirectOrigins?: readonly string[];
+}
+interface LinkSessionValidationOptions {
+    now?: Date;
+    allowedRedirectOrigins?: readonly string[];
+}
+type LinkSessionValidationResult = {
+    valid: true;
+    session: AgentLinkSession;
+} | {
+    valid: false;
+    error: string;
+};
+declare class InMemoryLinkSessionStore implements AgentLinkSessionStore {
+    private sessions;
+    set(session: AgentLinkSession): Promise<void>;
+    get(id: string): Promise<AgentLinkSession | null>;
+}
+declare function validateLinkSession(session: unknown, options?: LinkSessionValidationOptions): LinkSessionValidationResult;
+declare function createLinkSession(input: CreateLinkSessionInput, options?: CreateLinkSessionOptions): Promise<AgentLinkSession>;
+declare function getLinkSession(id: string, options: {
+    store: AgentLinkSessionStore;
+}): Promise<AgentLinkSession | null>;
+declare function encodeLinkSession(session: AgentLinkSession): string;
+declare function decodeLinkSession(value: string): AgentLinkSession;
+declare function buildHostedLinkUrl(baseUrl: string, session: AgentLinkSession): string;
+declare function buildEmbeddedHostedLinkUrl(baseUrl: string, session: AgentLinkSession): string;
+
+interface BiomapperLinkProtectedRoute extends Omit<RouteConfig, 'accepts'> {
+    price: Price | DynamicPrice;
+    payTo: string | DynamicPayTo;
+    network?: Network;
+    scheme?: 'exact';
+    maxTimeoutSeconds?: number;
+    extra?: Record<string, unknown>;
+}
+interface BiomapperLinkSchemeRegistration {
+    network: Network;
+    server: SchemeNetworkServer;
+}
+/** Generic middleware signature compatible with Hono and similar frameworks. */
+type AgentLinkMiddleware<TContext = unknown> = (context: TContext, next: () => Promise<void>) => Promise<Response | void>;
+interface BiomapperLinkCallable {
+    <TContext = unknown>(context: TContext, next: () => Promise<void>): Promise<Response | void>;
+}
+interface BiomapperLinkOptions {
+    /** "base" or "base-sepolia" */
+    network: BiomapperRegistryNetwork;
+    /** Deployed BiomapperAgentRegistry contract address. */
+    registry: `0x${string}`;
+    /** Access mode for linked agents. Defaults to "free". */
+    mode?: AgentLinkMode;
+    /** Storage backend for nonce replay protection and usage tracking. In production, this must be explicit. */
+    storage?: AgentLinkStorage;
+    /** Event handler for hook events (agent_verified, link.activated, etc.) */
+    onEvent?: AgentLinkEventHandler;
+    /** Usage count thresholds that trigger usage.threshold_reached events. */
+    usageThresholds?: number[];
+    /** Custom RPC URL for contract reads and signature verification. */
+    rpcUrl?: string;
+    /** Static or dynamic entitlement resolver for multi-tenant usage scoping. */
+    entitlements?: AgentLinkEntitlementContext | AgentLinkEntitlementResolver;
+    /** Forward hook events to a webhook endpoint. */
+    webhook?: {
+        url: string | string[];
+        secret?: string;
+        headers?: Record<string, string>;
+    };
+    /** Statement shown in the agent's SIWE signing prompt. */
+    statement?: string;
+    /** Domain for the SIWE message. Derived from request URL if omitted. */
+    domain?: string;
+    /** Simplified x402 route config for the ready-to-use middleware path. */
+    protect?: Record<string, BiomapperLinkProtectedRoute>;
+    /** Full x402 routes config for the ready-to-use middleware path. */
+    routes?: RoutesConfig;
+    /** Custom facilitator client(s) for the ready-to-use middleware path. */
+    facilitator?: FacilitatorClient | FacilitatorClient[];
+    /** Override the default x402 facilitator URL for the ready-to-use middleware path. */
+    facilitatorUrl?: string;
+    /** Override automatic exact-EVM scheme registration for the ready-to-use middleware path. */
+    schemes?: BiomapperLinkSchemeRegistration[];
+    /** Built-in paywall config for the ready-to-use middleware path. */
+    paywallConfig?: PaywallConfig;
+    /** Custom paywall provider for the ready-to-use middleware path. */
+    paywall?: PaywallProvider;
+}
+interface BiomapperLinkControlSurface {
+    extension: typeof agentlinkResourceServerExtension;
+    declare(overrides?: Partial<DeclareAgentLinkOptions>): ReturnType<typeof declareAgentLinkExtension>;
+    requestHook: ReturnType<typeof createAgentLinkHooks>['requestHook'];
+    verifyFailureHook: ReturnType<typeof createAgentLinkHooks>['verifyFailureHook'];
+    middleware: AgentLinkMiddleware;
+    initialize(): Promise<void>;
+    resourceServer?: x402ResourceServer;
+    httpServer?: x402HTTPResourceServer;
+}
+/**
+ * One-call setup for Biomapper Link.
+ *
+ * Collapses registry verifier, storage, hooks, extension declaration,
+ * and webhook wiring into a single factory. When `protect` or `routes`
+ * is provided, the returned value is also a ready-to-use middleware.
+ *
+ * @example
+ * ```ts
+ * const link = createBiomapperLink({
+ *   network: "base-sepolia",
+ *   registry: "0xYourRegistry",
+ *   protect: {
+ *     "GET /data": {
+ *       price: "$0.01",
+ *       payTo: "0xYourPayoutAddress",
+ *     },
+ *   },
+ * });
+ *
+ * app.use(link);
+ * ```
+ */
+declare function createBiomapperLink(options: BiomapperLinkOptions): BiomapperLink;
+type BiomapperLink = BiomapperLinkCallable & BiomapperLinkControlSurface;
+
+/** A Next.js App Router route handler: `(request: Request) => Promise<Response>` */
+type NextRouteHandler = (request: Request) => Promise<Response>;
+interface NextPaymentMiddleware {
+    /**
+     * Wraps a Next.js route handler with x402 payment protection.
+     *
+     * @example
+     * ```ts
+     * export const GET = payment.wrap(async (req) => Response.json({ ok: true }))
+     * ```
+     */
+    wrap(handler: NextRouteHandler): NextRouteHandler;
+    initialize(): Promise<void>;
+}
+declare function createNextPaymentHandlerFromHTTPServer(httpServer: x402HTTPResourceServer$1, paywallConfig?: PaywallConfig$1, paywall?: PaywallProvider$1): NextPaymentMiddleware;
+
+type HonoLikeMiddleware<TContext = unknown> = (context: TContext, next: () => Promise<void>) => Promise<Response | void>;
+interface HonoPaymentMiddleware {
+    middleware: HonoLikeMiddleware;
+    initialize(): Promise<void>;
+}
+declare function createHonoPaymentMiddlewareFromHTTPServer(httpServer: x402HTTPResourceServer$1, paywallConfig?: PaywallConfig$1, paywall?: PaywallProvider$1): HonoPaymentMiddleware;
+
+interface AgentLinkWebhookEnvelope<TEvent extends AgentLinkEvent = AgentLinkEvent> {
+    id: string;
+    createdAt: string;
+    type: TEvent['type'];
+    event: TEvent;
+}
+interface AgentLinkWebhookDispatcherOptions {
+    url: string | string[];
+    headers?: Record<string, string>;
+    secret?: string;
+    includeLegacySecretHeader?: boolean;
+    fetchImpl?: typeof fetch;
+}
+interface VerifyAgentLinkWebhookSignatureOptions {
+    secret: string;
+    timestamp: string;
+    signature: string;
+    body: string | Uint8Array | ArrayBuffer | ArrayBufferView;
+    now?: Date;
+    toleranceSeconds?: number;
+}
+interface AgentLinkWebhookSignatureVerificationResult {
+    valid: boolean;
+    error?: string;
+}
+declare function createAgentLinkWebhookEnvelope<TEvent extends AgentLinkEvent>(event: TEvent): AgentLinkWebhookEnvelope<TEvent>;
+declare function verifyAgentLinkWebhookSignature(options: VerifyAgentLinkWebhookSignatureOptions): Promise<AgentLinkWebhookSignatureVerificationResult>;
+declare function dispatchAgentLinkWebhook<TEvent extends AgentLinkEvent>(event: TEvent, options: AgentLinkWebhookDispatcherOptions): Promise<AgentLinkWebhookEnvelope<TEvent>>;
+declare function createAgentLinkWebhookDispatcher(options: AgentLinkWebhookDispatcherOptions): AgentLinkEventHandler;
+
+export { AGENTLINK, AGENT_LINK_TYPES, type AgentLinkAuthorization, type AgentLinkConsentClient, type AgentLinkConsentOutput, type AgentLinkConsentSigner, type AgentLinkEntitlement, type AgentLinkEntitlementContext, type AgentLinkEntitlementResolver, type AgentLinkEvent, type AgentLinkEventHandler, type AgentLinkExtension, type AgentLinkExtensionInfo, type AgentLinkExtensionSchema, type AgentLinkHookEvent, type AgentLinkMiddleware, type AgentLinkMode, type AgentLinkPayload, AgentLinkPayloadSchema, type AgentLinkSession, type AgentLinkSessionBranding, type AgentLinkSessionEvent, type AgentLinkSessionStore, type AgentLinkStorage, type AgentLinkUsageContext, type AgentLinkValidationOptions, type AgentLinkValidationResult, type AgentLinkVerifyResult, type AgentLinkWebhookDispatcherOptions, type AgentLinkWebhookEnvelope, type AgentLinkWebhookSignatureVerificationResult, BIOMAPPER_AGENT_REGISTRY_ABI$1 as BIOMAPPER_AGENT_REGISTRY_ABI, BIOMAPPER_AGENT_REGISTRY_NAME, BIOMAPPER_AGENT_REGISTRY_VERSION, BIOMAPPER_APP_URLS, BRIDGED_BIOMAPPER_ADDRESSES, BRIDGED_BIOMAPPER_READ_ABI, type BiomapperAgentStatus, type BiomapperBridgeNetwork, type BiomapperLink, type BiomapperLinkControlSurface, type BiomapperLinkOptions, type BiomapperLinkProtectedRoute, type BiomapperLinkSchemeRegistration, type BiomapperNetworkInfo, BiomapperNetworkSchema, type BiomapperQueryClient, BiomapperQueryError, type BiomapperQueryErrorCode, type BiomapperQueryNetwork, type BiomapperRegistryNetwork, type BiomapperRegistryOptions, type BiomapperRegistryVerifier, CHECK_AGENT_STATUS_TOOL_DESCRIPTION, CHECK_AGENT_STATUS_TOOL_NAME, type CheckAgentStatusInput, CheckAgentStatusInputSchema, type CheckAgentStatusResult, CheckAgentStatusResultSchema, type CompleteAgentLinkInfo, type CreateAgentLinkConsentOptions, type CreateAgentLinkHooksOptions, type CreateBiomapperQueryClientOptions, type CreateLinkSessionInput, type CreateLinkSessionOptions, type DeclareAgentLinkOptions, GET_BIOMAPPER_INFO_TOOL_DESCRIPTION, GET_BIOMAPPER_INFO_TOOL_NAME, GET_CURRENT_GENERATION_TOOL_DESCRIPTION, GET_CURRENT_GENERATION_TOOL_NAME, type GetBiomapperInfoInput, GetBiomapperInfoInputSchema, type GetBiomapperInfoResult, GetBiomapperInfoResultSchema, type GetCurrentGenerationInput, GetCurrentGenerationInputSchema, type GetCurrentGenerationResult, GetCurrentGenerationResultSchema, type HonoLikeMiddleware, type HonoPaymentMiddleware, InMemoryAgentLinkStorage, InMemoryLinkSessionStore, type LinkSessionValidationOptions, type LinkSessionValidationResult, type NextPaymentMiddleware, type NextRouteHandler, type ResolveAgentLinkEntitlementInput, type SignatureScheme, type SignatureType, type SupportedChain, type VerifyAgentLinkWebhookSignatureOptions, agentlinkResourceServerExtension, buildAgentLinkSchema, buildAgentLinkTypedData, buildAgentLinkUsageKey, buildEmbeddedHostedLinkUrl, buildHostedLinkUrl, createAgentLinkConsent, createAgentLinkHooks, createAgentLinkWebhookDispatcher, createAgentLinkWebhookEnvelope, createBiomapperLink, createBiomapperQueryClient, createBiomapperRegistryVerifier, createHonoPaymentMiddlewareFromHTTPServer, createLinkSession, createNextPaymentHandlerFromHTTPServer, declareAgentLinkExtension, decodeLinkSession, dispatchAgentLinkWebhook, encodeLinkSession, extractEVMChainId, formatSIWEMessage, getLinkSession, parseAgentLinkHeader, validateAgentLinkMessage, validateLinkSession, verifyAgentLinkSignature, verifyAgentLinkWebhookSignature, verifyEVMSignature };