zklicensing 0.1.0-beta.2 → 0.1.0-beta.21

package/build/agentActions.d.ts

@@ -0,0 +1,841 @@
+/**
+ * agentActions.ts — `zklicensing/agent/actions`
+ *
+ * Lets an AI agent carry out actions with a key its owner gave it
+ * (PERMITS_PLAN.md §16.4): buy, renew and refund licenses, and accept
+ * permit grants. Every action starts from a `PreparedAction`
+ * (`zklicensing/agent` prepare*), then:
+ *
+ *  - the owner's optional policy is checked (caps per action and per day,
+ *    allowed actions, targets and networks) — none by default;
+ *  - consent the action needs (a consumer's withdrawal waiver, permit
+ *    conditions) must come from a **standing consent** the owner signed
+ *    for this agent, and a vendor may require the human's own consent
+ *    ('human-only'), in which case the agent gets the approval link instead;
+ *  - the agent's wallet signs and pays; the result carries a confirmation
+ *    that records who gave consent and under which authorisation.
+ *
+ * Loads o1js (identity derivation) on first use.
+ */
+import { type AgentActionRecord } from './agentRecord.js';
+import { type Network, type PreparedAction, type ConsentKind } from './agent.js';
+import type { AuthorityDetails, PermitWallet } from './permitsClient.js';
+/**
+ * Error codes raised here before anything reaches the keeper, on top of the
+ * keeper's own codes (see /openapi.json). None is retryable as is.
+ *  - POLICY_DENIED: the owner's policy doesn't allow the action.
+ *  - CONSENT_HUMAN_ONLY: the vendor wants the human's own consent; hand them
+ *    the approval link in the message.
+ *  - CONSENT_REQUIRED: no standing consent covers what the action needs.
+ */
+export declare const AGENT_ACTION_ERROR_CODES: readonly ["POLICY_DENIED", "CONSENT_HUMAN_ONLY", "CONSENT_REQUIRED"];
+/** Any wallet with the PermitWallet interface (browser adapter, minaSignerWallet). */
+export type AgentWallet = PermitWallet;
+/** Every action an agent can take here, for the owner's `allowedActions`. */
+export type AgentActionName = PreparedAction['action'] | 'apply-permit' | 'withdraw-application' | 'surrender-permit' | 'accept-authority-terms' | 'create-registry' | 'deploy-registry' | 'redeploy-registry' | 'decide-application' | 'sign-request' | 'execute-request' | 'request-change' | 'accept-vendor-terms' | 'update-vendor-details' | 'register-app' | 'set-prices' | 'update-listing' | 'redeploy-app';
+export type AgentPolicy = {
+    allowedActions?: AgentActionName[];
+    /** Cap per action, MINA (the amount leaving the agent's wallet). */
+    maxPerActionMina?: number;
+    /** Cap per UTC day across actions, MINA. */
+    maxPerDayMina?: number;
+    /** zkApp or registry addresses the agent may act on. */
+    allowedTargets?: string[];
+    networks?: Network[];
+};
+/** Spend record for the per-day cap. Pass `load`/`save` to persist it. */
+export declare class SpendLedger {
+    private readonly store?;
+    private entries;
+    constructor(store?: {
+        load(): Array<{
+            at: number;
+            nano: string;
+        }>;
+        save(e: Array<{
+            at: number;
+            nano: string;
+        }>): void;
+    } | undefined);
+    spentOnDay(now?: number): bigint;
+    record(nano: bigint, now?: number): void;
+}
+/** Throws POLICY_DENIED when the owner's policy doesn't allow this action. */
+export declare function checkPolicy(policy: AgentPolicy | undefined, prepared: PreparedAction, target: string, ledger?: SpendLedger, now?: number): void;
+/**
+ * The policy check for any action. `target` is the zkApp or registry acted
+ * on (none for a registry not yet deployed); `amountNano` what leaves the
+ * wallet besides transaction fees.
+ */
+export declare function checkActionPolicy(policy: AgentPolicy | undefined, a: {
+    action: AgentActionName;
+    network: Network;
+    target?: string;
+    amountNano?: bigint;
+}, ledger?: SpendLedger, now?: number): void;
+export type StandingConsent = {
+    version: 1;
+    owner: string;
+    agent: string;
+    kinds: ConsentKind[];
+    network: Network;
+    issuedAt: string;
+    expiresAt: string | null;
+    /** The exact text the owner signed. */
+    statement: string;
+    signature: {
+        field: string;
+        scalar: string;
+    };
+};
+export declare function standingConsentStatement(f: {
+    owner: string;
+    agent: string;
+    kinds: ConsentKind[];
+    network: Network;
+    issuedAt: string;
+    expiresAt: string | null;
+}): string;
+/** How long a standing consent lasts unless the owner chooses otherwise. */
+export declare const DEFAULT_CONSENT_DAYS = 90;
+/**
+ * The owner signs a standing consent for an agent with their own wallet.
+ * It expires after DEFAULT_CONSENT_DAYS unless `expiresAt` is given; pass
+ * `expiresAt: null` for a consent that lasts until revoked.
+ */
+export declare function grantStandingConsent(owner: AgentWallet, f: {
+    agent: string;
+    kinds: ConsentKind[];
+    network: Network;
+    expiresAt?: string | null;
+}): Promise<StandingConsent>;
+/** Checks a standing consent's text and signature (mina-signer, as for wallet text signatures). */
+export declare function verifyStandingConsent(c: StandingConsent, now?: number): Promise<{
+    ok: boolean;
+    reason: string | null;
+}>;
+/** SHA-256 (hex) of a consent's statement: how a consent is referred to and revoked. */
+export declare function consentId(c: StandingConsent): Promise<string>;
+/** The text an owner signs to revoke a standing consent. */
+export declare function standingConsentRevocationStatement(f: {
+    owner: string;
+    statementSha256: string;
+    network: Network;
+    revokedAt: string;
+}): string;
+/** The owner revokes a standing consent at the keeper, signing with their own wallet. */
+export declare function revokeStandingConsent(owner: AgentWallet, consent: StandingConsent, opts: {
+    keeperUrl: string;
+    fetcher?: typeof fetch;
+}): Promise<{
+    revokedAt: string;
+}>;
+/** Whether the owner has revoked a consent (asks the keeper). */
+export declare function isStandingConsentRevoked(consent: StandingConsent, opts: {
+    keeperUrl: string;
+    fetcher?: typeof fetch;
+}): Promise<boolean>;
+export type ConsentRecord = {
+    givenBy: 'none';
+} | {
+    givenBy: 'agent';
+    agent: string;
+    owner: string;
+    kinds: ConsentKind[];
+    statementSha256: string;
+    issuedAt: string;
+};
+/**
+ * Consent the prepared action needs, from the standing consent. Refuses
+ * when the vendor requires the human's own consent, returning the approval
+ * link in the error so the agent can hand it to the human.
+ */
+export declare function consentFor(prepared: PreparedAction, agentAddress: string, consent?: StandingConsent, keeper?: {
+    keeperUrl: string;
+    fetcher?: typeof fetch;
+}): Promise<ConsentRecord>;
+export type ActOptions = {
+    keeperUrl: string;
+    wallet: AgentWallet;
+    policy?: AgentPolicy;
+    ledger?: SpendLedger;
+    consent?: StandingConsent;
+    fetcher?: typeof fetch;
+};
+/**
+ * Buys a license. The license belongs to a key derived from `passphrase`
+ * (generated if omitted) — keep the returned passphrase and license file:
+ * they are the license.
+ */
+export declare function buyLicense(prepared: PreparedAction, opts: ActOptions & {
+    buyerCountry: string;
+    buyerZip?: string;
+    passphrase?: string;
+}): Promise<{
+    proofFile: {
+        licenseHash: string;
+        expirySlot: number;
+        zkAppAddress: string;
+        network: Network;
+        txHash: string;
+        tier: string;
+        verificationKeyHash: string;
+        purchaseSlot: number;
+        purchaseAmount: string;
+        escrowless: boolean;
+        generation: number;
+        pending: boolean;
+    };
+    confirmation: {
+        action: string;
+        summary: string;
+        amounts: {
+            total: string;
+            toRecipient: string;
+            toPlatform: string;
+            recipient: string;
+        };
+        consent: ConsentRecord;
+        at: string;
+    };
+    receipt?: import("./receipt.js").PurchaseReceipt | undefined;
+    passphrase: string;
+    actionRecord?: AgentActionRecord | undefined;
+    txHash: string;
+    warnings: string[];
+}>;
+/** Renews a license; always needs the withdrawal waiver (renewals take effect immediately). */
+export declare function renewLicense(prepared: PreparedAction, opts: ActOptions): Promise<{
+    confirmation: {
+        action: string;
+        summary: string;
+        amounts: {
+            total: string;
+            toRecipient: string;
+            toPlatform: string;
+            recipient: string;
+        };
+        consent: ConsentRecord;
+        at: string;
+    };
+    receipt?: import("./receipt.js").PurchaseReceipt | undefined;
+    newExpirySlot: number;
+    actionRecord?: AgentActionRecord | undefined;
+    txHash: string;
+    warnings: string[];
+}>;
+/** Refunds a license inside its 14-day window, to the wallet that bought it. */
+export declare function refundLicense(prepared: PreparedAction, opts: ActOptions): Promise<{
+    confirmation: {
+        action: string;
+        summary: string;
+        amounts: {
+            total: string;
+            toRecipient: string;
+            toPlatform: string;
+            recipient: string;
+        };
+        consent: ConsentRecord;
+        at: string;
+    };
+    creditNote?: import("./receipt.js").PurchaseReceipt | undefined;
+    actionRecord?: AgentActionRecord | undefined;
+    txHash: string;
+    warnings: string[];
+}>;
+/**
+ * Accepts a permit grant as its holder (the agent's wallet must be the
+ * holder key) and pays with `payer` (default the same wallet).
+ */
+export declare function acceptPermitGrant(prepared: PreparedAction, opts: ActOptions & {
+    payer?: AgentWallet;
+}): Promise<{
+    confirmation: {
+        action: string;
+        summary: string;
+        amounts: {
+            total: string;
+            toRecipient: string;
+            toPlatform: string;
+            recipient: string;
+        };
+        consent: ConsentRecord;
+        docHash: {} | null;
+        at: string;
+    };
+    warnings?: string[] | undefined;
+    actionRecord?: AgentActionRecord | undefined;
+    receipt?: import("./receipt.js").PurchaseReceipt | undefined;
+    txHash: string;
+    subject: string;
+    fee: string;
+    toAuthority: string;
+    toPlatform: string;
+}>;
+/** Public Mina nodes used to broadcast when no URL is given (as onChainRoot's defaults). */
+export declare const DEFAULT_SEND_GRAPHQL_URLS: Record<Network, string>;
+/**
+ * A `send` for `minaSignerWallet` that posts the signed zkApp command to a
+ * Mina node's GraphQL `sendZkapp` — no o1js needed.
+ */
+export declare function graphqlSender(network: Network, opts?: {
+    url?: string;
+    fetcher?: typeof fetch;
+}): (zkappCommand: unknown) => Promise<string>;
+export type PermitAgentOptions = Omit<ActOptions, 'consent'> & {
+    network: Network;
+    consent?: StandingConsent;
+    /** How long a permit fee payment is retried while the keeper is busy (default 3 minutes). */
+    payRetryMs?: number;
+};
+/**
+ * Every permits flow for an agent key, with the owner's policy checked
+ * first: as an operator (apply, withdraw, surrender, prove access) and as an
+ * authority key-set member (create and deploy a registry, decide
+ * applications, sign and execute requests, request changes). Signing a
+ * request is one key's approval; the registry's threshold still applies.
+ */
+export declare function createPermitAgent(opts: PermitAgentOptions): Promise<{
+    client: {
+        network: import("./permitsClient.js").Network;
+        signIn: () => Promise<string>;
+        listRegistries: () => Promise<{
+            registries: any[];
+        }>;
+        getRegistry: (address: string) => Promise<{
+            registry: any;
+            chain?: any;
+        }>;
+        registryLineage: (address: string) => Promise<string>;
+        getPermit: (registry: string, subject: string) => Promise<{
+            permit: import("./permitRegistryRebuild.js").PermitRecord | null;
+            status: import("./permitRegistryRebuild.js").PermitStatusName;
+            slot: number;
+            root: string;
+            witness: {
+                isLefts: boolean[];
+                siblings: string[];
+            };
+            registry?: string;
+            generation?: number;
+            frozen?: boolean;
+        }>;
+        getDeployment: (registry: string) => Promise<{
+            registry: string;
+            network: string;
+            generation: number;
+            status: string;
+            current: string;
+            generations: Array<{
+                generation: number;
+                address: string;
+                status: string;
+                retiredAt?: string;
+            }>;
+            currentVerificationKeyHash: string;
+            chain: {
+                verificationKeyHash: string | null;
+                current: boolean;
+                retired: boolean;
+                hasPermits: boolean;
+                hasOpenApplications: boolean;
+            } | null;
+            redeploy: {
+                startedAt: string;
+                draining?: boolean;
+                openApplications?: number;
+                lastDeadline?: number | null;
+                successor?: any;
+                request?: import("./permitsClient.js").RequestView | null;
+                retireRequest?: import("./permitsClient.js").RequestView | null;
+                byPlatform?: boolean;
+            } | null;
+        }>;
+        verifyPermit: (registry: string, subject: string, scope?: bigint | string) => Promise<{
+            valid: boolean;
+            status: import("./permitRegistryRebuild.js").PermitStatusName;
+            scopeOk: boolean;
+            slot: number;
+            root: string;
+            permit: any;
+        }>;
+        getRequest: (id: string, asSelf?: boolean) => Promise<{
+            request: import("./permitsClient.js").RequestView;
+        }>;
+        acceptAuthorityTerms(f: AuthorityDetails & {
+            termsVersion: string;
+            termsHash: string;
+            agentConsent?: unknown;
+        }): Promise<{
+            authority: any;
+        }>;
+        authorityStranded: () => Promise<{
+            registries: Array<{
+                registry: string;
+                name: string | null;
+                successor: string | null;
+                retireTxHash: string;
+                strandedAt: string;
+                count: number;
+                totalNano: string;
+                applications: Array<{
+                    id: string;
+                    holderKey: string;
+                    payer: string | null;
+                    feeNano: string;
+                    deadline: number | null;
+                    contactEmail: string;
+                }>;
+            }>;
+            count: number;
+            totalNano: string;
+        }>;
+        authorityFeeStatement: (month: string) => Promise<any>;
+        getLicenseReceipts: (zkAppAddress: string, licenseHash: string) => Promise<import("./receipt.js").PurchaseReceipt[]>;
+        getReceipt: (txHash: string) => Promise<import("./receipt.js").PurchaseReceipt>;
+        getHolderOverview: () => Promise<{
+            network: string;
+            slot: number;
+            applications: Array<{
+                id: string;
+                registry: string;
+                registryName: string;
+                status: string;
+                createdAt: string;
+                requestedScope: string;
+                terms: any | null;
+                escrow: any | null;
+                settlement: any | null;
+            }>;
+            permits: Array<import("./permitRegistryRebuild.js").PermitRecord & {
+                registry: string;
+                registryName: string;
+                generation: number;
+                frozen: boolean;
+                effectiveStatus: import("./permitRegistryRebuild.js").PermitStatusName;
+            }>;
+            offers: Array<{
+                id: string;
+                registry: string;
+                registryName: string;
+                newLeaf: import("./permitRegistryRebuild.js").PermitRecord;
+                fee: string;
+                createdAt: string;
+            }>;
+        }>;
+        getAuthority: () => Promise<{
+            authority: any;
+            currentTerms: {
+                version: string;
+                hash: string;
+            };
+        }>;
+        listMyRegistries: () => Promise<{
+            registries: any[];
+        }>;
+        listRequests: (registry: string, status?: string) => Promise<{
+            requests: import("./permitsClient.js").RequestView[];
+        }>;
+        createRegistry: (draft: {
+            name: string;
+            website: string;
+            jurisdiction?: string;
+            description?: string;
+            keys: string[];
+            threshold: number;
+            scopes: Array<{
+                bit: number;
+                label: string;
+            }>;
+            policy?: {
+                gracePeriod?: number;
+                maxTerm?: number;
+                singleKeySuspend?: boolean;
+                holderSigRequired?: boolean;
+            };
+            grantFeeMina: string;
+            renewalFeeMina?: string;
+            payout?: string;
+            processingFeeMina?: string;
+            decisionWindow?: number;
+        }) => Promise<{
+            registry: any;
+            request: import("./permitsClient.js").RequestView;
+        }>;
+        updateRegistryListing: (registry: string, edit: {
+            name?: string;
+            description?: string;
+            jurisdiction?: string;
+            scopeLabels?: string[];
+        }) => Promise<{
+            registry: any;
+            staged: boolean;
+        }>;
+        setApplicationsOpen: (registry: string, open: boolean) => Promise<{
+            registry: any;
+        }>;
+        withdrawRegistryEdit: (registry: string) => Promise<{
+            registry: any;
+        }>;
+        getRegistryStats: (registry: string) => Promise<import("./permitsClient.js").RegistryStats>;
+        getRegistryTransactions: (registry: string, period?: {
+            from?: string;
+            to?: string;
+        }) => Promise<{
+            registry: string;
+            network: string;
+            transactions: import("./permitsClient.js").RegistryTransaction[];
+        }>;
+        signRequest(requestId: string, slot?: number): Promise<{
+            request: import("./permitsClient.js").RequestView;
+        }>;
+        redeployRegistry: (registry: string) => Promise<{
+            successor: any;
+            retireRequest: import("./permitsClient.js").RequestView | null;
+            retiredByPlatform?: boolean;
+            request: import("./permitsClient.js").RequestView;
+        } | {
+            draining: true;
+            openApplications: number;
+            lastDeadline: number | null;
+        }>;
+        cancelRedeploy: (registry: string) => Promise<{
+            registry: any;
+        }>;
+        deployRegistry(requestId: string): Promise<{
+            registry: string;
+            txHash: string;
+        }>;
+        listApplications: (registry: string, status?: string) => Promise<{
+            applications: any[];
+            paymentPaused?: boolean;
+        }>;
+        approveApplication: (id: string) => Promise<{
+            application: any;
+            request?: import("./permitsClient.js").RequestView;
+        }>;
+        rejectApplication: (id: string, reason?: string, reasonCode?: string) => Promise<{
+            application: any;
+            request?: import("./permitsClient.js").RequestView;
+        }>;
+        requestRenewal: (registry: string, subject: string, change: {
+            expirySlot: number | "none";
+            scope?: string;
+            validFrom?: number;
+            docHash?: string;
+        }) => Promise<{
+            request: import("./permitsClient.js").RequestView;
+        }>;
+        requestStatus: (registry: string, subject: string, action: "suspend" | "reinstate" | "revoke", reasonCode?: string) => Promise<{
+            request: import("./permitsClient.js").RequestView;
+        }>;
+        requestFees: (registry: string, grantFeeMina: string, renewalFeeMina?: string, applications?: {
+            processingFeeMina?: string;
+            decisionWindow?: number;
+        }) => Promise<{
+            request: import("./permitsClient.js").RequestView;
+        }>;
+        requestRotation: (registry: string, keys: string[], threshold: number) => Promise<{
+            request: import("./permitsClient.js").RequestView;
+        }>;
+        executeRequest(requestId: string): Promise<{
+            txHash: string;
+        }>;
+        apply(registry: string, a: {
+            scope?: string;
+            requestedScope?: string;
+            expirySlot?: number | "none";
+            validFrom?: number;
+            docHash?: string;
+            details?: Record<string, unknown>;
+            docLinks?: string[];
+            contactEmail?: string;
+            holderKey?: string;
+            salt?: string;
+            subject?: string;
+            pay?: boolean;
+            payer?: PermitWallet;
+        }): Promise<{
+            application: any;
+            apply: any;
+            txHash?: string;
+            fee?: string;
+            processingFee?: string;
+            deadline?: number;
+            paymentPaused?: {
+                reason: string;
+                forkActivationSlot: number | null;
+            };
+        }>;
+        getApplication: (id: string) => Promise<{
+            application: any;
+            request: import("./permitsClient.js").RequestView | null;
+            slot: number | null;
+            apply: {
+                application: import("./permitRegistryRebuild.js").ApplicationRecord;
+                fee: string;
+                processingFee: string;
+                decisionWindow: number;
+                message: string[];
+                paymentPaused?: {
+                    reason: "upgrade" | "redeploy";
+                    forkActivationSlot: number | null;
+                };
+            } | null;
+            withdrawMessage?: string[];
+            reclaimable?: boolean | null;
+        }>;
+        fileApplication(id: string, payer?: PermitWallet): Promise<{
+            txHash: string;
+            fee: string;
+            processingFee: string;
+            deadline: number;
+        }>;
+        withdrawApplication(id: string): Promise<{
+            application: any;
+        } | {
+            receipt?: import("./receipt.js").PurchaseReceipt | undefined;
+            application: any;
+            txHash: string;
+            kept: string;
+            refunded: string;
+        }>;
+        reclaimApplication(id: string, sender?: PermitWallet): Promise<{
+            txHash: string;
+            refunded: string;
+            payer: string;
+        }>;
+        acceptGrant(requestId: string, payer?: PermitWallet): Promise<{
+            receipt?: import("./receipt.js").PurchaseReceipt | undefined;
+            txHash: string;
+            subject: string;
+            fee: string;
+            toAuthority: string;
+            toPlatform: string;
+        }>;
+        proposeRegistryPayout: (registry: string, payout: string) => Promise<{
+            request: import("./permitsClient.js").RequestView;
+        }>;
+        cancelRegistryPayout: (registry: string) => Promise<{
+            request: import("./permitsClient.js").RequestView;
+        }>;
+        applyRegistryPayout(registry: string): Promise<{
+            txHash: string;
+            payout: string;
+        }>;
+        signRotationAsNewKey(requestId: string, newSlot?: number): Promise<{
+            request: import("./permitsClient.js").RequestView;
+        }>;
+        rekeyPermit(registry: string, subject: string, newWallet: PermitWallet, payer?: PermitWallet): Promise<{
+            txHash: string;
+            subject: string;
+            salt: string;
+        }>;
+        moveAuthorityAccount(newWallet: PermitWallet): Promise<{
+            moved: {
+                from: string;
+                to: string;
+            };
+        }>;
+        surrender(registry: string, subject: string): Promise<{
+            txHash: string;
+        }>;
+    };
+    address: string;
+    /**
+     * Applies for a permit (`subject`: renew or change this key's permit) and
+     * pays the fee into escrow from this key: a spend under the owner's
+     * policy (the full fee; on a rejection or withdrawal only the processing
+     * fee is kept, with no decision by the deadline nothing).
+     */
+    apply(registry: string, a: {
+        scope?: string;
+        requestedScope?: string;
+        expirySlot?: number | "none";
+        validFrom?: number;
+        docHash?: string;
+        details?: Record<string, unknown>;
+        docLinks?: string[];
+        contactEmail?: string;
+        subject?: string;
+    }): Promise<{
+        txHash: string;
+        fee: string;
+        processingFee: string;
+        deadline: number;
+        application: any;
+        apply: any;
+        paymentPaused?: {
+            reason: string;
+            forkActivationSlot: number | null;
+        };
+    }>;
+    /**
+     * Pays an application this key made that is still unpaid (submitted):
+     * for one whose payment `apply` couldn't complete. A spend under the
+     * owner's policy, as `apply`.
+     */
+    payApplication(id: string): Promise<{
+        txHash: string;
+        fee: string;
+        processingFee: string;
+        deadline: number;
+        application: any;
+    }>;
+    /** Withdraws an application (paid: the processing fee is kept, the rest refunded). */
+    withdrawApplication(id: string): Promise<{
+        application: any;
+    } | {
+        receipt?: import("./receipt.js").PurchaseReceipt | undefined;
+        application: any;
+        txHash: string;
+        kept: string;
+        refunded: string;
+    }>;
+    /** After the decision deadline: returns the whole fee to the payer. */
+    reclaimApplication(id: string): Promise<{
+        txHash: string;
+        refunded: string;
+        payer: string;
+    }>;
+    surrender(registry: string, subject: string): Promise<{
+        txHash: string;
+    }>;
+    /**
+     * Proves this key holds an active permit covering `requiredScope`,
+     * without revealing which permit (zero-knowledge holder proof). Give the
+     * verifier the proof. The challenge is bound to the verifier: `verifier`
+     * is the identity this agent is actually talking to (the service's URL,
+     * not a name it claims) and `nonce` the number it handed out, so two
+     * services cannot link the agent by agreeing on one challenge. The
+     * permit's secret is re-derived with this key (findHolderSecret).
+     */
+    proveAccess(a: {
+        registry: string;
+        subject: string;
+        requiredScope?: bigint;
+        verifier: string;
+        nonce: bigint | string;
+    }): Promise<{
+        registry: string;
+        root: string;
+        slot: number;
+        verifier: string;
+        nonce: string;
+        context: string;
+        requiredScope: string;
+        proof: unknown;
+        nullifier: string;
+    }>;
+    /**
+     * Accepts the Authority Terms with the agent key, for its owner. Needs a
+     * standing consent covering 'authority-terms'; the keeper records the
+     * acceptance as given by this agent under that authorisation.
+     */
+    acceptAuthorityTerms(f: AuthorityDetails & {
+        termsVersion: string;
+        termsHash: string;
+    }): Promise<{
+        authority: any;
+    }>;
+    listApplications(registry: string, status?: string): Promise<{
+        applications: any[];
+        paymentPaused?: boolean;
+    }>;
+    listRequests(registry: string, status?: string): Promise<{
+        requests: import("./permitsClient.js").RequestView[];
+    }>;
+    createRegistry(draft: Parameters<(draft: {
+        name: string;
+        website: string;
+        jurisdiction?: string;
+        description?: string;
+        keys: string[];
+        threshold: number;
+        scopes: Array<{
+            bit: number;
+            label: string;
+        }>;
+        policy?: {
+            gracePeriod?: number;
+            maxTerm?: number;
+            singleKeySuspend?: boolean;
+            holderSigRequired?: boolean;
+        };
+        grantFeeMina: string;
+        renewalFeeMina?: string;
+        payout?: string;
+        processingFeeMina?: string;
+        decisionWindow?: number;
+    }) => Promise<{
+        registry: any;
+        request: import("./permitsClient.js").RequestView;
+    }>>[0]): Promise<{
+        registry: any;
+        request: import("./permitsClient.js").RequestView;
+    }>;
+    deployRegistry(requestId: string): Promise<{
+        registry: string;
+        txHash: string;
+    }>;
+    /**
+     * Starts a redeploy to the current release: two requests for the keys,
+     * retire (sign, then execute_request) and the new registry (sign, then
+     * deployRegistry; after a pending hard fork). Every permit carries over to it.
+     */
+    redeployRegistry(registry: string): Promise<{
+        successor: any;
+        retireRequest: import("./permitsClient.js").RequestView | null;
+        retiredByPlatform?: boolean;
+        request: import("./permitsClient.js").RequestView;
+    } | {
+        draining: true;
+        openApplications: number;
+        lastDeadline: number | null;
+    }>;
+    /** Approves exactly what was applied for, or rejects (the processing fee is kept): a request for the authority keys to sign (an unpaid one whose payment waits for a Mina upgrade may be decided before payment; the request follows once paid). */
+    decideApplication(id: string, d: {
+        decision: "approve";
+    } | {
+        decision: "reject";
+        reason?: string;
+        reasonCode?: string;
+    }): Promise<{
+        application: any;
+        request?: import("./permitsClient.js").RequestView;
+    }>;
+    signRequest(requestId: string): Promise<{
+        request: import("./permitsClient.js").RequestView;
+    }>;
+    /** Proves and pays for a fully signed non-grant request (grants are paid by the holder). */
+    executeRequest(requestId: string): Promise<{
+        txHash: string;
+    }>;
+    requestChange(registry: string, c: {
+        kind: "renewal";
+        subject: string;
+        expirySlot: number | "none";
+        scope?: string;
+        validFrom?: number;
+        docHash?: string;
+    } | {
+        kind: "status";
+        subject: string;
+        action: "suspend" | "reinstate" | "revoke";
+        reasonCode?: string;
+    } | {
+        kind: "fees";
+        grantFeeMina: string;
+        renewalFeeMina?: string;
+    } | {
+        kind: "rotation";
+        keys: string[];
+        threshold: number;
+    }): Promise<{
+        request: import("./permitsClient.js").RequestView;
+    }>;
+}>;
+export type PermitAgent = Awaited<ReturnType<typeof createPermitAgent>>;
+export { signActionRecord, verifyActionRecord, actionRecordStatement, policyHash, canonicalJson, ACTION_RECORD_LIMITS, type AgentActionRecord } from './agentRecord.js';
+export { createVendorAgent, vendorAcceptanceMessage, billingHash, REGISTRATION_FEE_MINA, type VendorAgent, type VendorListing, type VendorLegalInput, type VendorTerms } from './agentVendor.js';
+//# sourceMappingURL=agentActions.d.ts.map