@crediolabs/policy-synth 0.5.6 → 1.1.0

package/dist/run/schemas.d.ts

@@ -409,9 +409,9 @@ export declare const InterpreterOptionsSchema: z.ZodObject<{
     smartAccountAddress: string;
     installNonce?: number | undefined;
 }>;
-export declare const SynthesizePolicyInputSchema: z.ZodObject<{
+export declare const SynthesizePolicyInputSchema: z.ZodEffects<z.ZodObject<{
     source: z.ZodLiteral<"recording">;
-    recordedTx: z.ZodObject<{
+    recordedTx: z.ZodOptional<z.ZodObject<{
         network: z.ZodEnum<["mainnet", "testnet"]>;
         signers: z.ZodArray<z.ZodString, "many">;
         invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
@@ -669,7 +669,8 @@ export declare const SynthesizePolicyInputSchema: z.ZodObject<{
             thresholdUsed: number;
         }>;
         sourceAccount: z.ZodString;
-    }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    transactionHash: z.ZodOptional<z.ZodString>;
     network: z.ZodEnum<["mainnet", "testnet"]>;
     userResponses: z.ZodOptional<z.ZodObject<{
         validUntilLedger: z.ZodOptional<z.ZodNumber>;
@@ -705,41 +706,6 @@ export declare const SynthesizePolicyInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     network: "mainnet" | "testnet";
     source: "recording";
-    recordedTx: {
-        signers: string[];
-        events: {
-            contract: string;
-            topics: string[];
-            data?: unknown;
-        }[];
-        sourceAccount: string;
-        network: "mainnet" | "testnet";
-        invocations: unknown[];
-        tokenMovements: {
-            from: string;
-            to: string;
-            amount: string;
-            token: string;
-        }[];
-        authEntries: unknown[];
-        ledgerSequence: number;
-        fetchedAt: number;
-        parseConfidence: {
-            opaqueScVals: {
-                type: string;
-                path: string;
-            }[];
-            unknownContracts: {
-                contract: string;
-                reason: "no-abi" | "version-mismatch" | "opaque-result";
-            }[];
-            overall: number;
-            knownContracts: string[];
-            thresholdUsed: number;
-        };
-    } & {
-        [k: string]: unknown;
-    };
     interpreter?: {
         smartAccountAddress: string;
         installNonce?: number | undefined;
@@ -752,30 +718,67 @@ export declare const SynthesizePolicyInputSchema: z.ZodObject<{
     confidenceOverride?: {
         threshold: number;
     } | undefined;
-    explain?: boolean | undefined;
-}, {
-    network: "mainnet" | "testnet";
-    source: "recording";
-    recordedTx: {
-        signers: string[];
-        events: {
-            contract: string;
-            topics: string[];
-            data?: unknown;
-        }[];
-        sourceAccount: string;
-        network: "mainnet" | "testnet";
-        invocations: unknown[];
-        tokenMovements: {
+    recordedTx?: z.objectOutputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
             from: string;
             to: string;
             amount: string;
             token: string;
-        }[];
-        authEntries: unknown[];
-        ledgerSequence: number;
-        fetchedAt: number;
-        parseConfidence: {
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
             opaqueScVals: {
                 type: string;
                 path: string;
@@ -787,10 +790,26 @@ export declare const SynthesizePolicyInputSchema: z.ZodObject<{
             overall: number;
             knownContracts: string[];
             thresholdUsed: number;
-        };
-    } & {
-        [k: string]: unknown;
-    };
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    transactionHash?: string | undefined;
+    explain?: boolean | undefined;
+}, {
+    network: "mainnet" | "testnet";
+    source: "recording";
     interpreter?: {
         smartAccountAddress: string;
         installNonce?: number | undefined;
@@ -803,20 +822,7 @@ export declare const SynthesizePolicyInputSchema: z.ZodObject<{
     confidenceOverride?: {
         threshold: number;
     } | undefined;
-    explain?: boolean | undefined;
-}>;
-export type SynthesizePolicyInput = z.infer<typeof SynthesizePolicyInputSchema>;
-/** PredicateLeaf mirrors the core `PredicateLeaf` union. Every variant
- *  is a `kind` discriminator; literals carry their primitive value inline.
- *  `literal_vec.elements` is recursive (a vec may contain literals that
- *  themselves nest) so the leaf schema is lazily self-referential. */
-export declare const PredicateLeafSchema: z.ZodType<unknown>;
-/** PredicateNode mirrors the core `PredicateNode` union. Recursive through
- *  `and`; the lazy + annotation pattern keeps the recursion type-safe. */
-export declare const PredicateNodeSchema: z.ZodType<unknown>;
-export declare const SimulatePolicyInputSchema: z.ZodObject<{
-    predicate: z.ZodType<unknown, z.ZodTypeDef, unknown>;
-    permitTx: z.ZodObject<{
+    recordedTx?: z.objectInputType<{
         network: z.ZodEnum<["mainnet", "testnet"]>;
         signers: z.ZodArray<z.ZodString, "many">;
         invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
@@ -902,7 +908,25 @@ export declare const SimulatePolicyInputSchema: z.ZodObject<{
             thresholdUsed: number;
         }>;
         sourceAccount: z.ZodString;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    transactionHash?: string | undefined;
+    explain?: boolean | undefined;
+}>, {
+    network: "mainnet" | "testnet";
+    source: "recording";
+    interpreter?: {
+        smartAccountAddress: string;
+        installNonce?: number | undefined;
+    } | undefined;
+    userResponses?: {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    } | undefined;
+    confidenceOverride?: {
+        threshold: number;
+    } | undefined;
+    recordedTx?: z.objectOutputType<{
         network: z.ZodEnum<["mainnet", "testnet"]>;
         signers: z.ZodArray<z.ZodString, "many">;
         invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
@@ -988,7 +1012,25 @@ export declare const SimulatePolicyInputSchema: z.ZodObject<{
             thresholdUsed: number;
         }>;
         sourceAccount: z.ZodString;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    transactionHash?: string | undefined;
+    explain?: boolean | undefined;
+}, {
+    network: "mainnet" | "testnet";
+    source: "recording";
+    interpreter?: {
+        smartAccountAddress: string;
+        installNonce?: number | undefined;
+    } | undefined;
+    userResponses?: {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    } | undefined;
+    confidenceOverride?: {
+        threshold: number;
+    } | undefined;
+    recordedTx?: z.objectInputType<{
         network: z.ZodEnum<["mainnet", "testnet"]>;
         signers: z.ZodArray<z.ZodString, "many">;
         invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
@@ -1074,89 +1116,28 @@ export declare const SimulatePolicyInputSchema: z.ZodObject<{
             thresholdUsed: number;
         }>;
         sourceAccount: z.ZodString;
-    }, z.ZodTypeAny, "passthrough">>;
-    validUntilLedger: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    permitTx: {
-        signers: string[];
-        events: {
-            contract: string;
-            topics: string[];
-            data?: unknown;
-        }[];
-        sourceAccount: string;
-        network: "mainnet" | "testnet";
-        invocations: unknown[];
-        tokenMovements: {
-            from: string;
-            to: string;
-            amount: string;
-            token: string;
-        }[];
-        authEntries: unknown[];
-        ledgerSequence: number;
-        fetchedAt: number;
-        parseConfidence: {
-            opaqueScVals: {
-                type: string;
-                path: string;
-            }[];
-            unknownContracts: {
-                contract: string;
-                reason: "no-abi" | "version-mismatch" | "opaque-result";
-            }[];
-            overall: number;
-            knownContracts: string[];
-            thresholdUsed: number;
-        };
-    } & {
-        [k: string]: unknown;
-    };
-    validUntilLedger?: number | undefined;
-    predicate?: unknown;
-}, {
-    permitTx: {
-        signers: string[];
-        events: {
-            contract: string;
-            topics: string[];
-            data?: unknown;
-        }[];
-        sourceAccount: string;
-        network: "mainnet" | "testnet";
-        invocations: unknown[];
-        tokenMovements: {
-            from: string;
-            to: string;
-            amount: string;
-            token: string;
-        }[];
-        authEntries: unknown[];
-        ledgerSequence: number;
-        fetchedAt: number;
-        parseConfidence: {
-            opaqueScVals: {
-                type: string;
-                path: string;
-            }[];
-            unknownContracts: {
-                contract: string;
-                reason: "no-abi" | "version-mismatch" | "opaque-result";
-            }[];
-            overall: number;
-            knownContracts: string[];
-            thresholdUsed: number;
-        };
-    } & {
-        [k: string]: unknown;
-    };
-    validUntilLedger?: number | undefined;
-    predicate?: unknown;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    transactionHash?: string | undefined;
+    explain?: boolean | undefined;
 }>;
-export type SimulatePolicyInput = z.infer<typeof SimulatePolicyInputSchema>;
-export declare const VerifyPolicyInputSchema: z.ZodObject<{
-    predicate: z.ZodType<unknown, z.ZodTypeDef, unknown>;
-    permitTx: z.ZodObject<{
+export type SynthesizePolicyInput = z.infer<typeof SynthesizePolicyInputSchema>;
+/** PredicateLeaf mirrors the core `PredicateLeaf` union. Every variant
+ *  is a `kind` discriminator; literals carry their primitive value inline.
+ *  `literal_vec.elements` is recursive (a vec may contain literals that
+ *  themselves nest) so the leaf schema is lazily self-referential. */
+export declare const PredicateLeafSchema: z.ZodType<unknown>;
+/** PredicateNode mirrors the core `PredicateNode` union. Recursive through
+ *  `and`; the lazy + annotation pattern keeps the recursion type-safe. */
+export declare const PredicateNodeSchema: z.ZodType<unknown>;
+export declare const SimulatePolicyInputSchema: z.ZodEffects<z.ZodObject<{
+    predicate: z.ZodOptional<z.ZodType<unknown, z.ZodTypeDef, unknown>>;
+    /** The canonical encoding `declare_policy` and `synthesize_policy` both
+     *  return. A DECLARED policy has no recording behind it, so re-synthesizing
+     *  from a hash would check a different predicate than the one declared -
+     *  and the tree is the shape callers mistype. One opaque string is the
+     *  handle that path was missing. */
+    encodedPredicate: z.ZodOptional<z.ZodString>;
+    permitTx: z.ZodOptional<z.ZodObject<{
         network: z.ZodEnum<["mainnet", "testnet"]>;
         signers: z.ZodArray<z.ZodString, "many">;
         invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
@@ -1414,29 +1395,983 @@ export declare const VerifyPolicyInputSchema: z.ZodObject<{
             thresholdUsed: number;
         }>;
         sourceAccount: z.ZodString;
-    }, z.ZodTypeAny, "passthrough">>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    transactionHash: z.ZodOptional<z.ZodString>;
+    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+    /** Needed only with `transactionHash`: lowering a recording to an interpreter
+     *  predicate is scoped to the account it will be installed on, and the
+     *  self-call gate is defined against it. */
+    smartAccount: z.ZodOptional<z.ZodString>;
+    userResponses: z.ZodOptional<z.ZodObject<{
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    }, {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    }>>;
     validUntilLedger: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    permitTx: {
-        signers: string[];
-        events: {
-            contract: string;
-            topics: string[];
-            data?: unknown;
-        }[];
-        sourceAccount: string;
-        network: "mainnet" | "testnet";
-        invocations: unknown[];
-        tokenMovements: {
+    validUntilLedger?: number | undefined;
+    encodedPredicate?: string | undefined;
+    userResponses?: {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    } | undefined;
+    predicate?: unknown;
+    smartAccount?: string | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    transactionHash?: string | undefined;
+    permitTx?: z.objectOutputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
             from: string;
             to: string;
             amount: string;
             token: string;
-        }[];
-        authEntries: unknown[];
-        ledgerSequence: number;
-        fetchedAt: number;
-        parseConfidence: {
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    validUntilLedger?: number | undefined;
+    encodedPredicate?: string | undefined;
+    userResponses?: {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    } | undefined;
+    predicate?: unknown;
+    smartAccount?: string | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    transactionHash?: string | undefined;
+    permitTx?: z.objectInputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>, {
+    validUntilLedger?: number | undefined;
+    encodedPredicate?: string | undefined;
+    userResponses?: {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    } | undefined;
+    predicate?: unknown;
+    smartAccount?: string | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    transactionHash?: string | undefined;
+    permitTx?: z.objectOutputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    validUntilLedger?: number | undefined;
+    encodedPredicate?: string | undefined;
+    userResponses?: {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    } | undefined;
+    predicate?: unknown;
+    smartAccount?: string | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    transactionHash?: string | undefined;
+    permitTx?: z.objectInputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>;
+export type SimulatePolicyInput = z.infer<typeof SimulatePolicyInputSchema>;
+export declare const VerifyPolicyInputSchema: z.ZodEffects<z.ZodObject<{
+    predicate: z.ZodOptional<z.ZodType<unknown, z.ZodTypeDef, unknown>>;
+    /** The canonical encoding `declare_policy` and `synthesize_policy` both
+     *  return. A DECLARED policy has no recording behind it, so re-synthesizing
+     *  from a hash would check a different predicate than the one declared -
+     *  and the tree is the shape callers mistype. One opaque string is the
+     *  handle that path was missing. */
+    encodedPredicate: z.ZodOptional<z.ZodString>;
+    permitTx: z.ZodOptional<z.ZodObject<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>>;
+    transactionHash: z.ZodOptional<z.ZodString>;
+    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+    /** Needed only with `transactionHash`: lowering a recording to an interpreter
+     *  predicate is scoped to the account it will be installed on, and the
+     *  self-call gate is defined against it. */
+    smartAccount: z.ZodOptional<z.ZodString>;
+    userResponses: z.ZodOptional<z.ZodObject<{
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    }, {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    }>>;
+    validUntilLedger: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    validUntilLedger?: number | undefined;
+    encodedPredicate?: string | undefined;
+    userResponses?: {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    } | undefined;
+    predicate?: unknown;
+    smartAccount?: string | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    transactionHash?: string | undefined;
+    permitTx?: z.objectOutputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    validUntilLedger?: number | undefined;
+    encodedPredicate?: string | undefined;
+    userResponses?: {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    } | undefined;
+    predicate?: unknown;
+    smartAccount?: string | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    transactionHash?: string | undefined;
+    permitTx?: z.objectInputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>, {
+    validUntilLedger?: number | undefined;
+    encodedPredicate?: string | undefined;
+    userResponses?: {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    } | undefined;
+    predicate?: unknown;
+    smartAccount?: string | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    transactionHash?: string | undefined;
+    permitTx?: z.objectOutputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
             opaqueScVals: {
                 type: string;
                 path: string;
@@ -1448,33 +2383,94 @@ export declare const VerifyPolicyInputSchema: z.ZodObject<{
             overall: number;
             knownContracts: string[];
             thresholdUsed: number;
-        };
-    } & {
-        [k: string]: unknown;
-    };
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
     validUntilLedger?: number | undefined;
+    encodedPredicate?: string | undefined;
+    userResponses?: {
+        limitAmount?: string | undefined;
+        validUntilLedger?: number | undefined;
+        swapRecipientAllowlist?: string[] | undefined;
+    } | undefined;
     predicate?: unknown;
-}, {
-    permitTx: {
-        signers: string[];
-        events: {
-            contract: string;
-            topics: string[];
-            data?: unknown;
-        }[];
-        sourceAccount: string;
-        network: "mainnet" | "testnet";
-        invocations: unknown[];
-        tokenMovements: {
+    smartAccount?: string | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    transactionHash?: string | undefined;
+    permitTx?: z.objectInputType<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        signers: z.ZodArray<z.ZodString, "many">;
+        invocations: z.ZodArray<z.ZodType<unknown, z.ZodTypeDef, unknown>, "many">;
+        tokenMovements: z.ZodArray<z.ZodObject<{
+            token: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            amount: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
             from: string;
             to: string;
             amount: string;
             token: string;
-        }[];
-        authEntries: unknown[];
-        ledgerSequence: number;
-        fetchedAt: number;
-        parseConfidence: {
+        }, {
+            from: string;
+            to: string;
+            amount: string;
+            token: string;
+        }>, "many">;
+        events: z.ZodArray<z.ZodObject<{
+            contract: z.ZodString;
+            topics: z.ZodArray<z.ZodString, "many">;
+            data: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+        }, "strip", z.ZodTypeAny, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }, {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }>, "many">;
+        authEntries: z.ZodArray<z.ZodUnknown, "many">;
+        ledgerSequence: z.ZodNumber;
+        fetchedAt: z.ZodNumber;
+        parseConfidence: z.ZodObject<{
+            overall: z.ZodNumber;
+            knownContracts: z.ZodArray<z.ZodString, "many">;
+            unknownContracts: z.ZodArray<z.ZodObject<{
+                contract: z.ZodString;
+                reason: z.ZodEnum<["no-abi", "version-mismatch", "opaque-result"]>;
+            }, "strip", z.ZodTypeAny, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }, {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }>, "many">;
+            opaqueScVals: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: string;
+                path: string;
+            }, {
+                type: string;
+                path: string;
+            }>, "many">;
+            thresholdUsed: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
             opaqueScVals: {
                 type: string;
                 path: string;
@@ -1486,12 +2482,21 @@ export declare const VerifyPolicyInputSchema: z.ZodObject<{
             overall: number;
             knownContracts: string[];
             thresholdUsed: number;
-        };
-    } & {
-        [k: string]: unknown;
-    };
-    validUntilLedger?: number | undefined;
-    predicate?: unknown;
+        }, {
+            opaqueScVals: {
+                type: string;
+                path: string;
+            }[];
+            unknownContracts: {
+                contract: string;
+                reason: "no-abi" | "version-mismatch" | "opaque-result";
+            }[];
+            overall: number;
+            knownContracts: string[];
+            thresholdUsed: number;
+        }>;
+        sourceAccount: z.ZodString;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
 }>;
 export type VerifyPolicyInput = z.infer<typeof VerifyPolicyInputSchema>;
 /** A rule ALREADY on the account, as the caller observed it. Supplying these
@@ -1634,6 +2639,10 @@ export declare const RPC_URL_BY_NETWORK: Record<Network, string>;
  *  these to a user must say so rather than implying we vouch for the code.
  *  Provenance detail in `docs/audit/README.md` finding 7. */
 export type OzBuiltinPolicy = 'spending_limit' | 'simple_threshold' | 'weighted_threshold';
+/** The upstream tag the deployed policy instances were built from. Exported so
+ *  `scripts/upstream-drift-check.ts` can compare it against the latest upstream
+ *  release; a tag recorded only in prose cannot be checked by anything. */
+export declare const PINNED_OZ_STELLAR_CONTRACTS_TAG = "v0.7.2";
 /** Instance addresses per network. Exported so consumers import the pin
  *  instead of copying a literal - a copied address is how a testnet id ends up
  *  being queried against mainnet, which returns `Error(Storage, MissingValue)`
@@ -1739,7 +2748,7 @@ export declare const DeclarePolicyInputSchema: z.ZodObject<{
     } | undefined;
 }>;
 export type DeclarePolicyInput = z.infer<typeof DeclarePolicyInputSchema>;
-export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
+export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
     /** Rules already on the account. Supplying them turns on the cross-rule
      *  authority scan, which reports every existing rule a signer of this
      *  install could name INSTEAD - including an unpoliced one, against which
@@ -1782,42 +2791,644 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             address: string;
             kind: "delegated";
         }>, z.ZodObject<{
-            kind: z.ZodLiteral<"external">;
-            verifier: z.ZodString;
-            keyBytes: z.ZodString;
+            kind: z.ZodLiteral<"external">;
+            verifier: z.ZodString;
+            keyBytes: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }>]>, "many">;
+        policyAddresses: z.ZodArray<z.ZodString, "many">;
+        predicate: z.ZodOptional<z.ZodType<unknown, z.ZodTypeDef, unknown>>;
+    }, "strip", z.ZodTypeAny, {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }, {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }>, "many">>;
+    /** The smart account contract address (C...) that will receive the rule. */
+    smartAccount: z.ZodString;
+    /** The signer that authorises the install (G... wallet). Used only for
+     *  sequence number + auth nonce simulation; never persisted, never signed. */
+    sourceAccount: z.ZodString;
+    /** Target network for the install. Selects which interpreter pin and
+     *  which RPC URL are valid by default. Defaults to `testnet` so the
+     *  pre-mainnet callers keep working: they were always pointing at
+     *  the testnet pin, so defaulting testnet here is the conservative
+     *  continuation, NOT a silent fall-through that bypasses the gate.
+     *  A caller that targets mainnet MUST set this to `mainnet` (the
+     *  pin and RPC pin do not move by themselves). */
+    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+    /** The proposed rule draft. Mirrors the core `ContextRuleDraft` shape.
+     *
+     *  Optional because of `fromHash` below. An agent cannot reliably retype the
+     *  `contextRule` that `synthesize_policy` returned - it is nested, and the
+     *  observed failures were exactly that: `validUntilLedger` sent as a string,
+     *  `signers` as "", `policies` as an object instead of an array. Supplying
+     *  `fromHash` instead lets the server rebuild the same rule it just
+     *  produced, rather than asking the caller to transcribe it. */
+    rule: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"default">;
+        }, "strip", z.ZodTypeAny, {
+            kind: "default";
+        }, {
+            kind: "default";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"call_contract">;
+            contract: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "call_contract";
+            contract: string;
+        }, {
+            kind: "call_contract";
+            contract: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"create_contract">;
+            wasmHash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "create_contract";
+            wasmHash: string;
+        }, {
+            kind: "create_contract";
+            wasmHash: string;
+        }>]>;
+        name: z.ZodString;
+        validUntilLedger: z.ZodNullable<z.ZodNumber>;
+        signers: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"delegated">;
+            address: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            kind: "delegated";
+        }, {
+            address: string;
+            kind: "delegated";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            verifier: z.ZodString;
+            keyBytes: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }>]>, "many">;
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"interpreter">;
+            interpreterAddress: z.ZodString;
+            predicateBlobBase64: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }>]>, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"default">;
+        }, "strip", z.ZodTypeAny, {
+            kind: "default";
+        }, {
+            kind: "default";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"call_contract">;
+            contract: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "call_contract";
+            contract: string;
+        }, {
+            kind: "call_contract";
+            contract: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"create_contract">;
+            wasmHash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "create_contract";
+            wasmHash: string;
+        }, {
+            kind: "create_contract";
+            wasmHash: string;
+        }>]>;
+        name: z.ZodString;
+        validUntilLedger: z.ZodNullable<z.ZodNumber>;
+        signers: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"delegated">;
+            address: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            kind: "delegated";
+        }, {
+            address: string;
+            kind: "delegated";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            verifier: z.ZodString;
+            keyBytes: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }>]>, "many">;
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"interpreter">;
+            interpreterAddress: z.ZodString;
+            predicateBlobBase64: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }>]>, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"default">;
+        }, "strip", z.ZodTypeAny, {
+            kind: "default";
+        }, {
+            kind: "default";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"call_contract">;
+            contract: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "call_contract";
+            contract: string;
+        }, {
+            kind: "call_contract";
+            contract: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"create_contract">;
+            wasmHash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "create_contract";
+            wasmHash: string;
+        }, {
+            kind: "create_contract";
+            wasmHash: string;
+        }>]>;
+        name: z.ZodString;
+        validUntilLedger: z.ZodNullable<z.ZodNumber>;
+        signers: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"delegated">;
+            address: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            kind: "delegated";
+        }, {
+            address: string;
+            kind: "delegated";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            verifier: z.ZodString;
+            keyBytes: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }>]>, "many">;
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"interpreter">;
+            interpreterAddress: z.ZodString;
+            predicateBlobBase64: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }>]>, "many">;
+    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+        contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"default">;
+        }, "strip", z.ZodTypeAny, {
+            kind: "default";
+        }, {
+            kind: "default";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"call_contract">;
+            contract: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "call_contract";
+            contract: string;
+        }, {
+            kind: "call_contract";
+            contract: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"create_contract">;
+            wasmHash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "create_contract";
+            wasmHash: string;
+        }, {
+            kind: "create_contract";
+            wasmHash: string;
+        }>]>;
+        name: z.ZodString;
+        validUntilLedger: z.ZodNullable<z.ZodNumber>;
+        signers: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"delegated">;
+            address: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            kind: "delegated";
+        }, {
+            address: string;
+            kind: "delegated";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            verifier: z.ZodString;
+            keyBytes: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }>]>, "many">;
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"interpreter">;
+            interpreterAddress: z.ZodString;
+            predicateBlobBase64: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }>]>, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"default">;
+        }, "strip", z.ZodTypeAny, {
+            kind: "default";
+        }, {
+            kind: "default";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"call_contract">;
+            contract: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "call_contract";
+            contract: string;
+        }, {
+            kind: "call_contract";
+            contract: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"create_contract">;
+            wasmHash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "create_contract";
+            wasmHash: string;
+        }, {
+            kind: "create_contract";
+            wasmHash: string;
+        }>]>;
+        name: z.ZodString;
+        validUntilLedger: z.ZodNullable<z.ZodNumber>;
+        signers: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"delegated">;
+            address: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            kind: "delegated";
+        }, {
+            address: string;
+            kind: "delegated";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            verifier: z.ZodString;
+            keyBytes: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }, {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        }>]>, "many">;
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"interpreter">;
+            interpreterAddress: z.ZodString;
+            predicateBlobBase64: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            kind: "external";
-            verifier: string;
-            keyBytes: string;
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
         }, {
-            kind: "external";
-            verifier: string;
-            keyBytes: string;
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
         }>]>, "many">;
-        policyAddresses: z.ZodArray<z.ZodString, "many">;
-        predicate: z.ZodOptional<z.ZodType<unknown, z.ZodTypeDef, unknown>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    /** Build the rule here instead of receiving it: record this transaction,
+     *  synthesize against `smartAccount`, and install the result. The
+     *  agent-friendly counterpart to `rule`, and the same handle
+     *  `synthesize_policy` accepts. */
+    fromHash: z.ZodOptional<z.ZodObject<{
+        transactionHash: z.ZodString;
+        /** The keys this rule governs. Synthesis cannot choose them: it reads a
+         *  transaction, and which keys a rule binds is the caller's security
+         *  decision, not an inference from one recording. Naming a key here
+         *  attaches it as a delegated signer. A rule with no signer is refused
+         *  on chain, so this is required in practice; the `rule` form remains
+         *  the way to attach an external (verifier + key bytes) signer. */
+        signers: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        userResponses: z.ZodOptional<z.ZodObject<{
+            validUntilLedger: z.ZodOptional<z.ZodNumber>;
+            limitAmount: z.ZodOptional<z.ZodString>;
+            swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            limitAmount?: string | undefined;
+            validUntilLedger?: number | undefined;
+            swapRecipientAllowlist?: string[] | undefined;
+        }, {
+            limitAmount?: string | undefined;
+            validUntilLedger?: number | undefined;
+            swapRecipientAllowlist?: string[] | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
-        signers: ({
-            address: string;
-            kind: "delegated";
-        } | {
-            kind: "external";
-            verifier: string;
-            keyBytes: string;
-        })[];
-        id: number;
-        policyAddresses: string[];
-        contextType: {
-            kind: "default";
-        } | {
-            kind: "call_contract";
-            contract: string;
-        } | {
-            kind: "create_contract";
-            wasmHash: string;
-        };
-        predicate?: unknown;
+        transactionHash: string;
+        signers?: string[] | undefined;
+        userResponses?: {
+            limitAmount?: string | undefined;
+            validUntilLedger?: number | undefined;
+            swapRecipientAllowlist?: string[] | undefined;
+        } | undefined;
+    }, {
+        transactionHash: string;
+        signers?: string[] | undefined;
+        userResponses?: {
+            limitAmount?: string | undefined;
+            validUntilLedger?: number | undefined;
+            swapRecipientAllowlist?: string[] | undefined;
+        } | undefined;
+    }>>;
+    /** Install a predicate the caller ALREADY holds - the base64 string
+     *  `declare_policy` returns.
+     *
+     *  Without this there is no route from `declare_policy` to here:
+     *  `fromHash` re-synthesizes from a recording and would discard the
+     *  declared predicate, and `rule` means hand-building a draft that the
+     *  tool boundary types as `unknown`, so the caller is guessing. An agent
+     *  asked to do that invented a requirement to deploy a signer contract,
+     *  which is not a thing - a delegated signer is a plain account address.
+     *
+     *  The context rule type is taken FROM the predicate: if it pins a
+     *  contract, the rule is scoped to that contract. One source of truth, so
+     *  the rule's scope cannot drift from what the predicate actually checks. */
+    fromPredicate: z.ZodOptional<z.ZodObject<{
+        encodedPredicate: z.ZodString;
+        /** The keys this rule governs, as plain Stellar account addresses. */
+        signers: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+        name: z.ZodOptional<z.ZodString>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        signers: string[];
+        encodedPredicate: string;
+        validUntilLedger?: number | undefined;
+        name?: string | undefined;
+    }, {
+        signers: string[];
+        encodedPredicate: string;
+        validUntilLedger?: number | undefined;
+        name?: string | undefined;
+    }>>;
+    /** Per-rule install nonce. Defaults to 1, which is the only correct value
+     *  here: this tool builds `add_context_rule`, the account assigns a NEW
+     *  rule id, and the interpreter has no stored nonce for a rule that does
+     *  not exist yet. Required, it was undiscoverable - an agent has no way to
+     *  read it, and asking cost a round trip on a value the server already
+     *  knows. Supply it only to re-install over an existing rule, where the
+     *  interpreter wants `stored_nonce + 1`. */
+    installNonce: z.ZodOptional<z.ZodNumber>;
+    /** Optional RPC URL override. Defaults to the pinned RPC for the
+     *  selected `network` (testnet by default, mainnet when
+     *  `network: 'mainnet'`); the override is refused unless
+     *  `allowUnpinnedRpcUrl: true`, because the auth nonce and
+     *  rootInvocation in the response come from whichever RPC answered. */
+    rpcUrl: z.ZodOptional<z.ZodString>;
+    /** Opt-in to using a non-pinned RPC URL. Without this flag the tool
+     *  refuses any `rpcUrl` other than the pinned RPC for the selected
+     *  network because the caller's auth-digest binds to whatever the
+     *  RPC returned. */
+    allowUnpinnedRpcUrl: z.ZodOptional<z.ZodBoolean>;
+    /** Attach an OpenZeppelin `spending_limit` beside the predicate, giving the
+     *  rule a ROLLING TOTAL as well as a per-call bound. Both must permit,
+     *  because policies on one rule compose as all-of.
+     *
+     *  This is the only way to express "N per day": the interpreter is handed
+     *  one call and keeps no state, so a predicate cannot add up spending
+     *  across calls. Composes with all three ways of naming the rule.
+     *
+     *  The primitive meters the third argument of a call named exactly
+     *  `transfer` and requires a `call_contract` rule scope, so the rule must
+     *  be pinned to the token whose transfers it meters. */
+    spendingLimit: z.ZodOptional<z.ZodObject<{
+        /** Rolling total in the token's smallest unit. */
+        amount: z.ZodString;
+        /** Window length in LEDGERS. Stellar closes one in roughly five
+         *  seconds, so a period in seconds is an approximation of this. */
+        periodLedgers: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        amount: string;
+        periodLedgers: number;
     }, {
+        amount: string;
+        periodLedgers: number;
+    }>>;
+    /** Opt-in to installing a rule that bounds no amount, when the recording
+     *  behind `fromHash` showed a spend.
+     *
+     *  Default-deny, because the failure is silent and reads as success: such
+     *  a rule installs cleanly, verifies cleanly - a missing constraint
+     *  generates no deny case to fail - and caps nothing. That combination
+     *  reached the chain once already. A rule with no spend to bound is
+     *  unaffected; only the case the synthesizer explicitly flagged is
+     *  refused. */
+    allowUnboundedAmount: z.ZodOptional<z.ZodBoolean>;
+    /** Opt-in to pointing the rule's interpreter policy at any address
+     *  other than the pinned interpreter for the selected network.
+     *  Default-deny: a caller that controls the interpreter can permit
+     *  everything. Selecting `network: 'mainnet'` is NOT an opt-in -
+     *  the mainnet pin is its own deny-by-default anchor. */
+    allowUnpinnedInterpreter: z.ZodOptional<z.ZodBoolean>;
+    /** Base fee in stroops; defaults to BASE_FEE (100). */
+    baseFee: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    smartAccount: string;
+    sourceAccount: string;
+    installNonce?: number | undefined;
+    spendingLimit?: {
+        amount: string;
+        periodLedgers: number;
+    } | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    existingRules?: {
         signers: ({
             address: string;
             kind: "delegated";
@@ -1838,22 +3449,8 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             wasmHash: string;
         };
         predicate?: unknown;
-    }>, "many">>;
-    /** The smart account contract address (C...) that will receive the rule. */
-    smartAccount: z.ZodString;
-    /** The signer that authorises the install (G... wallet). Used only for
-     *  sequence number + auth nonce simulation; never persisted, never signed. */
-    sourceAccount: z.ZodString;
-    /** Target network for the install. Selects which interpreter pin and
-     *  which RPC URL are valid by default. Defaults to `testnet` so the
-     *  pre-mainnet callers keep working: they were always pointing at
-     *  the testnet pin, so defaulting testnet here is the conservative
-     *  continuation, NOT a silent fall-through that bypasses the gate.
-     *  A caller that targets mainnet MUST set this to `mainnet` (the
-     *  pin and RPC pin do not move by themselves). */
-    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
-    /** The proposed rule draft. Mirrors the core `ContextRuleDraft` shape. */
-    rule: z.ZodEffects<z.ZodObject<{
+    }[] | undefined;
+    rule?: z.objectOutputType<{
         contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
             kind: z.ZodLiteral<"default">;
         }, "strip", z.ZodTypeAny, {
@@ -1903,7 +3500,11 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             verifier: string;
             keyBytes: string;
         }>]>, "many">;
-        policies: z.ZodArray<z.ZodObject<{
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
             kind: z.ZodLiteral<"interpreter">;
             interpreterAddress: z.ZodString;
             predicateBlobBase64: z.ZodString;
@@ -1915,8 +3516,76 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "interpreter";
             interpreterAddress: string;
             predicateBlobBase64: string;
-        }>, "many">;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }>]>, "many">;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    fromHash?: {
+        transactionHash: string;
+        signers?: string[] | undefined;
+        userResponses?: {
+            limitAmount?: string | undefined;
+            validUntilLedger?: number | undefined;
+            swapRecipientAllowlist?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    fromPredicate?: {
+        signers: string[];
+        encodedPredicate: string;
+        validUntilLedger?: number | undefined;
+        name?: string | undefined;
+    } | undefined;
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    allowUnboundedAmount?: boolean | undefined;
+    allowUnpinnedInterpreter?: boolean | undefined;
+    baseFee?: number | undefined;
+}, {
+    smartAccount: string;
+    sourceAccount: string;
+    installNonce?: number | undefined;
+    spendingLimit?: {
+        amount: string;
+        periodLedgers: number;
+    } | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    existingRules?: {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }[] | undefined;
+    rule?: z.objectInputType<{
         contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
             kind: z.ZodLiteral<"default">;
         }, "strip", z.ZodTypeAny, {
@@ -1966,7 +3635,11 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             verifier: string;
             keyBytes: string;
         }>]>, "many">;
-        policies: z.ZodArray<z.ZodObject<{
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
             kind: z.ZodLiteral<"interpreter">;
             interpreterAddress: z.ZodString;
             predicateBlobBase64: z.ZodString;
@@ -1978,8 +3651,76 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "interpreter";
             interpreterAddress: string;
             predicateBlobBase64: string;
-        }>, "many">;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }>]>, "many">;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    fromHash?: {
+        transactionHash: string;
+        signers?: string[] | undefined;
+        userResponses?: {
+            limitAmount?: string | undefined;
+            validUntilLedger?: number | undefined;
+            swapRecipientAllowlist?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    fromPredicate?: {
+        signers: string[];
+        encodedPredicate: string;
+        validUntilLedger?: number | undefined;
+        name?: string | undefined;
+    } | undefined;
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    allowUnboundedAmount?: boolean | undefined;
+    allowUnpinnedInterpreter?: boolean | undefined;
+    baseFee?: number | undefined;
+}>, {
+    smartAccount: string;
+    sourceAccount: string;
+    installNonce?: number | undefined;
+    spendingLimit?: {
+        amount: string;
+        periodLedgers: number;
+    } | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    existingRules?: {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }[] | undefined;
+    rule?: z.objectOutputType<{
         contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
             kind: z.ZodLiteral<"default">;
         }, "strip", z.ZodTypeAny, {
@@ -2029,7 +3770,11 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             verifier: string;
             keyBytes: string;
         }>]>, "many">;
-        policies: z.ZodArray<z.ZodObject<{
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
             kind: z.ZodLiteral<"interpreter">;
             interpreterAddress: z.ZodString;
             predicateBlobBase64: z.ZodString;
@@ -2041,8 +3786,76 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "interpreter";
             interpreterAddress: string;
             predicateBlobBase64: string;
-        }>, "many">;
-    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }>]>, "many">;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    fromHash?: {
+        transactionHash: string;
+        signers?: string[] | undefined;
+        userResponses?: {
+            limitAmount?: string | undefined;
+            validUntilLedger?: number | undefined;
+            swapRecipientAllowlist?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    fromPredicate?: {
+        signers: string[];
+        encodedPredicate: string;
+        validUntilLedger?: number | undefined;
+        name?: string | undefined;
+    } | undefined;
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    allowUnboundedAmount?: boolean | undefined;
+    allowUnpinnedInterpreter?: boolean | undefined;
+    baseFee?: number | undefined;
+}, {
+    smartAccount: string;
+    sourceAccount: string;
+    installNonce?: number | undefined;
+    spendingLimit?: {
+        amount: string;
+        periodLedgers: number;
+    } | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    existingRules?: {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }[] | undefined;
+    rule?: z.objectInputType<{
         contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
             kind: z.ZodLiteral<"default">;
         }, "strip", z.ZodTypeAny, {
@@ -2092,7 +3905,11 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             verifier: string;
             keyBytes: string;
         }>]>, "many">;
-        policies: z.ZodArray<z.ZodObject<{
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
             kind: z.ZodLiteral<"interpreter">;
             interpreterAddress: z.ZodString;
             predicateBlobBase64: z.ZodString;
@@ -2104,8 +3921,76 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "interpreter";
             interpreterAddress: string;
             predicateBlobBase64: string;
-        }>, "many">;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }>]>, "many">;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    fromHash?: {
+        transactionHash: string;
+        signers?: string[] | undefined;
+        userResponses?: {
+            limitAmount?: string | undefined;
+            validUntilLedger?: number | undefined;
+            swapRecipientAllowlist?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    fromPredicate?: {
+        signers: string[];
+        encodedPredicate: string;
+        validUntilLedger?: number | undefined;
+        name?: string | undefined;
+    } | undefined;
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    allowUnboundedAmount?: boolean | undefined;
+    allowUnpinnedInterpreter?: boolean | undefined;
+    baseFee?: number | undefined;
+}>, {
+    smartAccount: string;
+    sourceAccount: string;
+    installNonce?: number | undefined;
+    spendingLimit?: {
+        amount: string;
+        periodLedgers: number;
+    } | undefined;
+    network?: "mainnet" | "testnet" | undefined;
+    existingRules?: {
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        id: number;
+        policyAddresses: string[];
+        contextType: {
+            kind: "default";
+        } | {
+            kind: "call_contract";
+            contract: string;
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        predicate?: unknown;
+    }[] | undefined;
+    rule?: z.objectOutputType<{
         contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
             kind: z.ZodLiteral<"default">;
         }, "strip", z.ZodTypeAny, {
@@ -2155,7 +4040,11 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             verifier: string;
             keyBytes: string;
         }>]>, "many">;
-        policies: z.ZodArray<z.ZodObject<{
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
             kind: z.ZodLiteral<"interpreter">;
             interpreterAddress: z.ZodString;
             predicateBlobBase64: z.ZodString;
@@ -2167,120 +4056,52 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
             kind: "interpreter";
             interpreterAddress: string;
             predicateBlobBase64: string;
-        }>, "many">;
-    }, z.ZodTypeAny, "passthrough">>;
-    /** Per-rule install nonce; 1 for a fresh install. */
-    installNonce: z.ZodNumber;
-    /** Optional RPC URL override. Defaults to the pinned RPC for the
-     *  selected `network` (testnet by default, mainnet when
-     *  `network: 'mainnet'`); the override is refused unless
-     *  `allowUnpinnedRpcUrl: true`, because the auth nonce and
-     *  rootInvocation in the response come from whichever RPC answered. */
-    rpcUrl: z.ZodOptional<z.ZodString>;
-    /** Opt-in to using a non-pinned RPC URL. Without this flag the tool
-     *  refuses any `rpcUrl` other than the pinned RPC for the selected
-     *  network because the caller's auth-digest binds to whatever the
-     *  RPC returned. */
-    allowUnpinnedRpcUrl: z.ZodOptional<z.ZodBoolean>;
-    /** Opt-in to pointing the rule's interpreter policy at any address
-     *  other than the pinned interpreter for the selected network.
-     *  Default-deny: a caller that controls the interpreter can permit
-     *  everything. Selecting `network: 'mainnet'` is NOT an opt-in -
-     *  the mainnet pin is its own deny-by-default anchor. */
-    allowUnpinnedInterpreter: z.ZodOptional<z.ZodBoolean>;
-    /** Base fee in stroops; defaults to BASE_FEE (100). */
-    baseFee: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    smartAccount: string;
-    sourceAccount: string;
-    installNonce: number;
-    rule: {
-        signers: ({
-            address: string;
-            kind: "delegated";
-        } | {
-            kind: "external";
-            verifier: string;
-            keyBytes: string;
-        })[];
-        validUntilLedger: number | null;
-        contextRuleType: {
-            kind: "default";
-        } | {
-            kind: "call_contract";
-            contract: string;
-        } | {
-            kind: "create_contract";
-            wasmHash: string;
-        };
-        policies: {
-            kind: "interpreter";
-            interpreterAddress: string;
-            predicateBlobBase64: string;
-        }[];
-        name: string;
-    } & {
-        [k: string]: unknown;
-    };
-    network?: "mainnet" | "testnet" | undefined;
-    existingRules?: {
-        signers: ({
-            address: string;
-            kind: "delegated";
-        } | {
-            kind: "external";
-            verifier: string;
-            keyBytes: string;
-        })[];
-        id: number;
-        policyAddresses: string[];
-        contextType: {
-            kind: "default";
-        } | {
-            kind: "call_contract";
-            contract: string;
-        } | {
-            kind: "create_contract";
-            wasmHash: string;
-        };
-        predicate?: unknown;
-    }[] | undefined;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }>]>, "many">;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    fromHash?: {
+        transactionHash: string;
+        signers?: string[] | undefined;
+        userResponses?: {
+            limitAmount?: string | undefined;
+            validUntilLedger?: number | undefined;
+            swapRecipientAllowlist?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    fromPredicate?: {
+        signers: string[];
+        encodedPredicate: string;
+        validUntilLedger?: number | undefined;
+        name?: string | undefined;
+    } | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
+    allowUnboundedAmount?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
     baseFee?: number | undefined;
 }, {
     smartAccount: string;
     sourceAccount: string;
-    installNonce: number;
-    rule: {
-        signers: ({
-            address: string;
-            kind: "delegated";
-        } | {
-            kind: "external";
-            verifier: string;
-            keyBytes: string;
-        })[];
-        validUntilLedger: number | null;
-        contextRuleType: {
-            kind: "default";
-        } | {
-            kind: "call_contract";
-            contract: string;
-        } | {
-            kind: "create_contract";
-            wasmHash: string;
-        };
-        policies: {
-            kind: "interpreter";
-            interpreterAddress: string;
-            predicateBlobBase64: string;
-        }[];
-        name: string;
-    } & {
-        [k: string]: unknown;
-    };
+    installNonce?: number | undefined;
+    spendingLimit?: {
+        amount: string;
+        periodLedgers: number;
+    } | undefined;
     network?: "mainnet" | "testnet" | undefined;
     existingRules?: {
         signers: ({
@@ -2304,126 +4125,108 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
         };
         predicate?: unknown;
     }[] | undefined;
-    rpcUrl?: string | undefined;
-    allowUnpinnedRpcUrl?: boolean | undefined;
-    allowUnpinnedInterpreter?: boolean | undefined;
-    baseFee?: number | undefined;
-}>, {
-    smartAccount: string;
-    sourceAccount: string;
-    installNonce: number;
-    rule: {
-        signers: ({
-            address: string;
-            kind: "delegated";
-        } | {
-            kind: "external";
-            verifier: string;
-            keyBytes: string;
-        })[];
-        validUntilLedger: number | null;
-        contextRuleType: {
+    rule?: z.objectInputType<{
+        contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"default">;
+        }, "strip", z.ZodTypeAny, {
             kind: "default";
-        } | {
+        }, {
+            kind: "default";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"call_contract">;
+            contract: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
             kind: "call_contract";
             contract: string;
-        } | {
+        }, {
+            kind: "call_contract";
+            contract: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"create_contract">;
+            wasmHash: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
             kind: "create_contract";
             wasmHash: string;
-        };
-        policies: {
-            kind: "interpreter";
-            interpreterAddress: string;
-            predicateBlobBase64: string;
-        }[];
-        name: string;
-    } & {
-        [k: string]: unknown;
-    };
-    network?: "mainnet" | "testnet" | undefined;
-    existingRules?: {
-        signers: ({
+        }, {
+            kind: "create_contract";
+            wasmHash: string;
+        }>]>;
+        name: z.ZodString;
+        validUntilLedger: z.ZodNullable<z.ZodNumber>;
+        signers: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"delegated">;
+            address: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
             address: string;
             kind: "delegated";
-        } | {
+        }, {
+            address: string;
+            kind: "delegated";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            verifier: z.ZodString;
+            keyBytes: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
             kind: "external";
             verifier: string;
             keyBytes: string;
-        })[];
-        id: number;
-        policyAddresses: string[];
-        contextType: {
-            kind: "default";
-        } | {
-            kind: "call_contract";
-            contract: string;
-        } | {
-            kind: "create_contract";
-            wasmHash: string;
-        };
-        predicate?: unknown;
-    }[] | undefined;
-    rpcUrl?: string | undefined;
-    allowUnpinnedRpcUrl?: boolean | undefined;
-    allowUnpinnedInterpreter?: boolean | undefined;
-    baseFee?: number | undefined;
-}, {
-    smartAccount: string;
-    sourceAccount: string;
-    installNonce: number;
-    rule: {
-        signers: ({
-            address: string;
-            kind: "delegated";
-        } | {
+        }, {
             kind: "external";
             verifier: string;
             keyBytes: string;
-        })[];
-        validUntilLedger: number | null;
-        contextRuleType: {
-            kind: "default";
-        } | {
-            kind: "call_contract";
-            contract: string;
-        } | {
-            kind: "create_contract";
-            wasmHash: string;
-        };
-        policies: {
+        }>]>, "many">;
+        /** Policies on one rule compose as ALL-OF, so an interpreter predicate and
+         *  an OpenZeppelin built-in can sit together and both must permit. That
+         *  pairing is what expresses a rolling total: the predicate bounds each
+         *  call, the built-in bounds the sum across calls. */
+        policies: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"interpreter">;
+            interpreterAddress: z.ZodString;
+            predicateBlobBase64: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
             kind: "interpreter";
             interpreterAddress: string;
             predicateBlobBase64: string;
-        }[];
-        name: string;
-    } & {
-        [k: string]: unknown;
-    };
-    network?: "mainnet" | "testnet" | undefined;
-    existingRules?: {
-        signers: ({
-            address: string;
-            kind: "delegated";
-        } | {
-            kind: "external";
-            verifier: string;
-            keyBytes: string;
-        })[];
-        id: number;
-        policyAddresses: string[];
-        contextType: {
-            kind: "default";
-        } | {
-            kind: "call_contract";
-            contract: string;
-        } | {
-            kind: "create_contract";
-            wasmHash: string;
-        };
-        predicate?: unknown;
-    }[] | undefined;
+        }, {
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"spending_limit">;
+            policyAddress: z.ZodString;
+            /** LEDGERS, not seconds. */
+            periodLedgers: z.ZodNumber;
+            spendingLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }, {
+            kind: "spending_limit";
+            spendingLimit: string;
+            periodLedgers: number;
+            policyAddress: string;
+        }>]>, "many">;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    fromHash?: {
+        transactionHash: string;
+        signers?: string[] | undefined;
+        userResponses?: {
+            limitAmount?: string | undefined;
+            validUntilLedger?: number | undefined;
+            swapRecipientAllowlist?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+    fromPredicate?: {
+        signers: string[];
+        encodedPredicate: string;
+        validUntilLedger?: number | undefined;
+        name?: string | undefined;
+    } | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
+    allowUnboundedAmount?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
     baseFee?: number | undefined;
 }>;