@crediolabs/policy-synth 0.1.11 → 0.1.13

package/dist-cjs/run/schemas.d.ts

@@ -1099,6 +1099,7 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
             topics: string[];
             data?: unknown;
         }[];
+        sourceAccount: string;
         network: "mainnet" | "testnet";
         invocations: unknown[];
         tokenMovements: {
@@ -1123,7 +1124,6 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
             knownContracts: string[];
             thresholdUsed: number;
         };
-        sourceAccount: string;
     } & {
         [k: string]: unknown;
     };
@@ -1164,6 +1164,7 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
             topics: string[];
             data?: unknown;
         }[];
+        sourceAccount: string;
         network: "mainnet" | "testnet";
         invocations: unknown[];
         tokenMovements: {
@@ -1188,7 +1189,6 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
             knownContracts: string[];
             thresholdUsed: number;
         };
-        sourceAccount: string;
     } & {
         [k: string]: unknown;
     };
@@ -1756,6 +1756,7 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             topics: string[];
             data?: unknown;
         }[];
+        sourceAccount: string;
         network: "mainnet" | "testnet";
         invocations: unknown[];
         tokenMovements: {
@@ -1780,7 +1781,6 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             knownContracts: string[];
             thresholdUsed: number;
         };
-        sourceAccount: string;
     } & {
         [k: string]: unknown;
     };
@@ -1821,6 +1821,7 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             topics: string[];
             data?: unknown;
         }[];
+        sourceAccount: string;
         network: "mainnet" | "testnet";
         invocations: unknown[];
         tokenMovements: {
@@ -1845,7 +1846,6 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             knownContracts: string[];
             thresholdUsed: number;
         };
-        sourceAccount: string;
     } & {
         [k: string]: unknown;
     };
@@ -1878,6 +1878,1502 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
     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`/`or`/`not`; the lazy + annotation pattern keeps the recursion
+ *  type-safe. */
+export declare const PredicateNodeSchema: z.ZodType<unknown>;
+/** Oracle price fixture - mirror of the entry type in `SimulateOptions` /
+ *  `VerifyOptions`. Discriminated by presence of `error` vs `price`. */
+export declare const OraclePriceFixtureSchema: z.ZodUnion<[z.ZodObject<{
+    price: z.ZodString;
+    timestampSeconds: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    price: string;
+    timestampSeconds: number;
+}, {
+    price: string;
+    timestampSeconds: number;
+}>, z.ZodObject<{
+    error: z.ZodEnum<["stale", "missing", "deviation", "paused", "decimals", "fingerprint"]>;
+}, "strip", z.ZodTypeAny, {
+    error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
+}, {
+    error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
+}>]>;
+export declare const SimulatePolicyInputSchema: z.ZodObject<{
+    predicate: z.ZodNullable<z.ZodType<unknown, z.ZodTypeDef, unknown>>;
+    permitTx: 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, {
+            amount: string;
+            token: string;
+            from: string;
+            to: string;
+        }, {
+            amount: string;
+            token: string;
+            from: string;
+            to: 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, {
+            amount: string;
+            token: string;
+            from: string;
+            to: string;
+        }, {
+            amount: string;
+            token: string;
+            from: string;
+            to: 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, {
+            amount: string;
+            token: string;
+            from: string;
+            to: string;
+        }, {
+            amount: string;
+            token: string;
+            from: string;
+            to: 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">>;
+    validUntilLedger: z.ZodOptional<z.ZodNumber>;
+    oraclePricesByAsset: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        price: z.ZodString;
+        timestampSeconds: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        price: string;
+        timestampSeconds: number;
+    }, {
+        price: string;
+        timestampSeconds: number;
+    }>, z.ZodObject<{
+        error: z.ZodEnum<["stale", "missing", "deviation", "paused", "decimals", "fingerprint"]>;
+    }, "strip", z.ZodTypeAny, {
+        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
+    }, {
+        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
+    }>]>>>;
+}, "strip", z.ZodTypeAny, {
+    permitTx: {
+        signers: string[];
+        events: {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }[];
+        sourceAccount: string;
+        network: "mainnet" | "testnet";
+        invocations: unknown[];
+        tokenMovements: {
+            amount: string;
+            token: string;
+            from: string;
+            to: 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;
+    oraclePricesByAsset?: Record<string, {
+        price: string;
+        timestampSeconds: number;
+    } | {
+        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
+    }> | undefined;
+}, {
+    permitTx: {
+        signers: string[];
+        events: {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }[];
+        sourceAccount: string;
+        network: "mainnet" | "testnet";
+        invocations: unknown[];
+        tokenMovements: {
+            amount: string;
+            token: string;
+            from: string;
+            to: 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;
+    oraclePricesByAsset?: Record<string, {
+        price: string;
+        timestampSeconds: number;
+    } | {
+        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
+    }> | undefined;
+}>;
+export type SimulatePolicyInput = z.infer<typeof SimulatePolicyInputSchema>;
+export declare const VerifyPolicyInputSchema: z.ZodObject<{
+    predicate: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+    permitTx: 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, {
+            amount: string;
+            token: string;
+            from: string;
+            to: string;
+        }, {
+            amount: string;
+            token: string;
+            from: string;
+            to: 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, {
+            amount: string;
+            token: string;
+            from: string;
+            to: string;
+        }, {
+            amount: string;
+            token: string;
+            from: string;
+            to: 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, {
+            amount: string;
+            token: string;
+            from: string;
+            to: string;
+        }, {
+            amount: string;
+            token: string;
+            from: string;
+            to: 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">>;
+    validUntilLedger: z.ZodOptional<z.ZodNumber>;
+    oraclePricesByAsset: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        price: z.ZodString;
+        timestampSeconds: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        price: string;
+        timestampSeconds: number;
+    }, {
+        price: string;
+        timestampSeconds: number;
+    }>, z.ZodObject<{
+        error: z.ZodEnum<["stale", "missing", "deviation", "paused", "decimals", "fingerprint"]>;
+    }, "strip", z.ZodTypeAny, {
+        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
+    }, {
+        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
+    }>]>>>;
+}, "strip", z.ZodTypeAny, {
+    permitTx: {
+        signers: string[];
+        events: {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }[];
+        sourceAccount: string;
+        network: "mainnet" | "testnet";
+        invocations: unknown[];
+        tokenMovements: {
+            amount: string;
+            token: string;
+            from: string;
+            to: 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;
+    oraclePricesByAsset?: Record<string, {
+        price: string;
+        timestampSeconds: number;
+    } | {
+        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
+    }> | undefined;
+}, {
+    permitTx: {
+        signers: string[];
+        events: {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }[];
+        sourceAccount: string;
+        network: "mainnet" | "testnet";
+        invocations: unknown[];
+        tokenMovements: {
+            amount: string;
+            token: string;
+            from: string;
+            to: 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;
+    oraclePricesByAsset?: Record<string, {
+        price: string;
+        timestampSeconds: number;
+    } | {
+        error: "stale" | "missing" | "deviation" | "paused" | "decimals" | "fingerprint";
+    }> | undefined;
+}>;
+export type VerifyPolicyInput = z.infer<typeof VerifyPolicyInputSchema>;
+/** Pinned interpreter address (testnet). Mirrors DEPLOYMENTS.md:156-157.
+ *  Single source for the MCP layer; do not embed elsewhere. */
+export declare const PINNED_INTERPRETER_TESTNET_ADDRESS = "CDR4NLV22STCXFGZPNKDQTEANWLF7LZ6AJLY6B7CLJXKHDZGYJWIOKGP";
+/** Pinned interpreter wasm sha256 (hex). Mirrors DEPLOYMENTS.md:156-157. */
+export declare const PINNED_INTERPRETER_WASM_SHA256 = "6e6c13d93e197aa380303a42cd120f5ddb080dd36ef2a343ee1dbd04ca52a443";
+/** The grammar version the interpreter enforces (matches SELF_VERSION in
+ *  packages/policy-interpreter/src/version.rs). */
+export declare const PINNED_INTERPRETER_GRAMMAR_VERSION = 1;
+/** Default Soroban RPC for the install / revoke / info tools. The recorder
+ *  keeps its own copy in record/rpc.ts because it hands back a fetcher rather
+ *  than a Server; the two are deliberately different surfaces, so this is
+ *  pinned beside the addresses it is used with rather than shared. */
+export declare const TESTNET_RPC_URL = "https://soroban-testnet.stellar.org";
+/** Soroban `valid_until` window (ledgers) added to the latest ledger when
+ *  building the auth entry. ~25 minutes at 5s/ledger. */
+export declare const DEFAULT_AUTH_VALID_UNTIL_LEDGERS = 300;
+/** Stellar network passphrases. Pinned here so the XDR envelope uses the
+ *  matching passphrase when the wallet signs (a mismatch yields invalid
+ *  hashes). */
+export declare const NETWORK_PASSPHRASES: Record<Network, string>;
+export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
+    /** 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;
+    /** The proposed rule draft. Mirrors the core `ContextRuleDraft` shape. */
+    rule: 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, {
+            contract: string;
+            kind: "call_contract";
+        }, {
+            contract: string;
+            kind: "call_contract";
+        }>, 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: 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<"oz_builtin">;
+            primitive: z.ZodObject<{
+                primitive: z.ZodEnum<["spending_limit", "simple_threshold", "weighted_threshold"]>;
+                params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, "strip", z.ZodTypeAny, {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            }, {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            }>;
+            instanceAddress: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        }, {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        }>]>, "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, {
+            contract: string;
+            kind: "call_contract";
+        }, {
+            contract: string;
+            kind: "call_contract";
+        }>, 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: 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<"oz_builtin">;
+            primitive: z.ZodObject<{
+                primitive: z.ZodEnum<["spending_limit", "simple_threshold", "weighted_threshold"]>;
+                params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, "strip", z.ZodTypeAny, {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            }, {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            }>;
+            instanceAddress: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        }, {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        }>]>, "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, {
+            contract: string;
+            kind: "call_contract";
+        }, {
+            contract: string;
+            kind: "call_contract";
+        }>, 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: 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<"oz_builtin">;
+            primitive: z.ZodObject<{
+                primitive: z.ZodEnum<["spending_limit", "simple_threshold", "weighted_threshold"]>;
+                params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, "strip", z.ZodTypeAny, {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            }, {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            }>;
+            instanceAddress: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        }, {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        }>]>, "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, {
+            contract: string;
+            kind: "call_contract";
+        }, {
+            contract: string;
+            kind: "call_contract";
+        }>, 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: 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<"oz_builtin">;
+            primitive: z.ZodObject<{
+                primitive: z.ZodEnum<["spending_limit", "simple_threshold", "weighted_threshold"]>;
+                params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, "strip", z.ZodTypeAny, {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            }, {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            }>;
+            instanceAddress: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        }, {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        }>]>, "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, {
+            contract: string;
+            kind: "call_contract";
+        }, {
+            contract: string;
+            kind: "call_contract";
+        }>, 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: 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<"oz_builtin">;
+            primitive: z.ZodObject<{
+                primitive: z.ZodEnum<["spending_limit", "simple_threshold", "weighted_threshold"]>;
+                params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, "strip", z.ZodTypeAny, {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            }, {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            }>;
+            instanceAddress: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        }, {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        }>]>, "many">;
+    }, z.ZodTypeAny, "passthrough">>;
+    /** Per-rule install nonce; 1 for a fresh install. */
+    installNonce: z.ZodNumber;
+    /** Optional RPC URL override. Defaults to the public testnet endpoint
+     *  (`TESTNET_RPC_URL`); 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 `TESTNET_RPC_URL` 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 testnet interpreter. Default-deny: a caller
+     *  that controls the interpreter can permit everything. */
+    allowUnpinnedInterpreter: z.ZodOptional<z.ZodBoolean>;
+    /** Base fee in stroops; defaults to BASE_FEE (100). */
+    baseFee: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    installNonce: number;
+    smartAccount: string;
+    sourceAccount: string;
+    rule: {
+        contextRuleType: {
+            kind: "default";
+        } | {
+            contract: string;
+            kind: "call_contract";
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        validUntilLedger: number | null;
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        policies: ({
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        } | {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        })[];
+        name: string;
+    } & {
+        [k: string]: unknown;
+    };
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    allowUnpinnedInterpreter?: boolean | undefined;
+    baseFee?: number | undefined;
+}, {
+    installNonce: number;
+    smartAccount: string;
+    sourceAccount: string;
+    rule: {
+        contextRuleType: {
+            kind: "default";
+        } | {
+            contract: string;
+            kind: "call_contract";
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        validUntilLedger: number | null;
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        policies: ({
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        } | {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        })[];
+        name: string;
+    } & {
+        [k: string]: unknown;
+    };
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    allowUnpinnedInterpreter?: boolean | undefined;
+    baseFee?: number | undefined;
+}>, {
+    installNonce: number;
+    smartAccount: string;
+    sourceAccount: string;
+    rule: {
+        contextRuleType: {
+            kind: "default";
+        } | {
+            contract: string;
+            kind: "call_contract";
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        validUntilLedger: number | null;
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        policies: ({
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        } | {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        })[];
+        name: string;
+    } & {
+        [k: string]: unknown;
+    };
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    allowUnpinnedInterpreter?: boolean | undefined;
+    baseFee?: number | undefined;
+}, {
+    installNonce: number;
+    smartAccount: string;
+    sourceAccount: string;
+    rule: {
+        contextRuleType: {
+            kind: "default";
+        } | {
+            contract: string;
+            kind: "call_contract";
+        } | {
+            kind: "create_contract";
+            wasmHash: string;
+        };
+        validUntilLedger: number | null;
+        signers: ({
+            address: string;
+            kind: "delegated";
+        } | {
+            kind: "external";
+            verifier: string;
+            keyBytes: string;
+        })[];
+        policies: ({
+            kind: "interpreter";
+            interpreterAddress: string;
+            predicateBlobBase64: string;
+        } | {
+            instanceAddress: string;
+            primitive: {
+                primitive: "spending_limit" | "simple_threshold" | "weighted_threshold";
+                params: Record<string, unknown>;
+            };
+            kind: "oz_builtin";
+        })[];
+        name: string;
+    } & {
+        [k: string]: unknown;
+    };
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    allowUnpinnedInterpreter?: boolean | undefined;
+    baseFee?: number | undefined;
+}>;
+export type InstallPolicyInput = z.infer<typeof InstallPolicyInputSchema>;
+export declare const RevokePolicyInputSchema: z.ZodEffects<z.ZodObject<{
+    /** The smart account contract address (C...). */
+    smartAccount: z.ZodString;
+    /** The wallet that will sign the removal. The ACCOUNT decides whether it
+     *  accepts that signer; this schema does not assert a rule it cannot
+     *  verify, since the account's source is not in this repo. Proven on
+     *  testnet: the account's deployer can revoke. */
+    sourceAccount: z.ZodString;
+    /** The rule id to remove from the smart account + interpreter. */
+    ruleId: z.ZodNumber;
+    /** Optional RPC URL override; same pin as install. */
+    rpcUrl: z.ZodOptional<z.ZodString>;
+    /** Opt-in to using a non-pinned RPC URL. Same semantics as install. */
+    allowUnpinnedRpcUrl: 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;
+    ruleId: number;
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    baseFee?: number | undefined;
+}, {
+    smartAccount: string;
+    sourceAccount: string;
+    ruleId: number;
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    baseFee?: number | undefined;
+}>, {
+    smartAccount: string;
+    sourceAccount: string;
+    ruleId: number;
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    baseFee?: number | undefined;
+}, {
+    smartAccount: string;
+    sourceAccount: string;
+    ruleId: number;
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    baseFee?: number | undefined;
+}>;
+export type RevokePolicyInput = z.infer<typeof RevokePolicyInputSchema>;
+export declare const GetInterpreterInfoInputSchema: z.ZodObject<{
+    /** Network to query. The pin differs per network; defaults to testnet. */
+    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+    /** When true, perform an optional live `grammar_version()` RPC call to
+     *  verify the deployed contract matches the pin. */
+    verifyLive: z.ZodOptional<z.ZodBoolean>;
+    /** Optional RPC URL override. */
+    rpcUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    network?: "mainnet" | "testnet" | undefined;
+    rpcUrl?: string | undefined;
+    verifyLive?: boolean | undefined;
+}, {
+    network?: "mainnet" | "testnet" | undefined;
+    rpcUrl?: string | undefined;
+    verifyLive?: boolean | undefined;
+}>;
+export type GetInterpreterInfoInput = z.infer<typeof GetInterpreterInfoInputSchema>;
 export declare const ToolErrorSchema: z.ZodObject<{
     code: z.ZodString;
     message: z.ZodString;