@crediolabs/policy-builder-mcp 0.2.0 → 0.3.0

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

@@ -0,0 +1,869 @@
+import { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, NetworkSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema } from '@crediolabs/policy-synth/run';
+import { z } from 'zod';
+export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, NetworkSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, };
+/** Flat ZodRawShape used for the MCP SDK tool registration. The body
+ *  re-validates against `RecordTransactionInputSchema` so the mutual-exclusion
+ *  rule still fires (the SDK does not invoke `.refine()` at registration time). */
+export declare const RecordTransactionToolShape: {
+    readonly hash: z.ZodOptional<z.ZodString>;
+    readonly xdr: z.ZodOptional<z.ZodString>;
+    readonly network: z.ZodEnum<["mainnet", "testnet"]>;
+    readonly confidenceOverride: z.ZodOptional<z.ZodNumber>;
+};
+/** Flat ZodRawShape used for MCP tool registration. Every field is optional
+ *  so the JSON-Schema the SDK exposes to clients stays permissive; the body
+ *  re-validates against the strict schema. */
+export declare const SynthesizePolicyToolShape: {
+    readonly source: z.ZodOptional<z.ZodLiteral<"recording">>;
+    readonly 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">;
+        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">>>;
+    readonly network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+    readonly 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;
+    }>>;
+    readonly confidenceOverride: z.ZodOptional<z.ZodObject<{
+        threshold: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        threshold: number;
+    }, {
+        threshold: number;
+    }>>;
+    readonly interpreter: z.ZodOptional<z.ZodObject<{
+        smartAccountAddress: z.ZodString;
+        installNonce: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        smartAccountAddress: string;
+        installNonce?: number | undefined;
+    }, {
+        smartAccountAddress: string;
+        installNonce?: number | undefined;
+    }>>;
+    readonly explain: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const SimulatePolicyToolShape: {
+    readonly predicate: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+    readonly 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, {
+            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">>;
+    readonly validUntilLedger: z.ZodOptional<z.ZodNumber>;
+};
+export declare const VerifyPolicyToolShape: {
+    readonly predicate: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+    readonly 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, {
+            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">>;
+    readonly validUntilLedger: z.ZodOptional<z.ZodNumber>;
+};
+export type { GetInterpreterInfoInput, InstallPolicyInput, RevokePolicyInput, SimulatePolicyInput, VerifyPolicyInput, } from '@crediolabs/policy-synth/run';
+/** Flat ZodRawShape for `install_policy`. `rule` is typed as `z.unknown()`
+ *  at the tool boundary because the rule schema is a discriminated union
+ *  the SDK does not accept at registration; the body re-validates
+ *  against `InstallPolicyInputSchema`. `encodedPredicate` /
+ *  `predicateHash` live INSIDE `rule.policies[].predicateBlobBase64`
+ *  (the policy already carries the encoded predicate); the run-layer
+ *  extracts them from there. */
+export declare const InstallPolicyToolShape: {
+    readonly rule: z.ZodOptional<z.ZodUnknown>;
+    readonly installNonce: z.ZodOptional<z.ZodNumber>;
+    readonly interpreterAddress: z.ZodOptional<z.ZodString>;
+    readonly smartAccount: z.ZodOptional<z.ZodString>;
+    readonly sourceAccount: z.ZodOptional<z.ZodString>;
+    readonly rpcUrl: z.ZodOptional<z.ZodString>;
+    readonly baseFee: z.ZodOptional<z.ZodNumber>;
+};
+/** Flat ZodRawShape for `revoke_policy`. */
+export declare const RevokePolicyToolShape: {
+    readonly ruleId: z.ZodOptional<z.ZodNumber>;
+    readonly interpreterAddress: z.ZodOptional<z.ZodString>;
+    readonly smartAccount: z.ZodOptional<z.ZodString>;
+    readonly sourceAccount: z.ZodOptional<z.ZodString>;
+    readonly rpcUrl: z.ZodOptional<z.ZodString>;
+    readonly baseFee: z.ZodOptional<z.ZodNumber>;
+};
+/** Flat ZodRawShape for `get_interpreter_info`. `verifyLive` triggers an
+ *  optional RPC `grammar_version()` call so the caller can verify the
+ *  deployed contract matches the pin. */
+export declare const GetInterpreterInfoToolShape: {
+    readonly network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+    readonly verifyLive: z.ZodOptional<z.ZodBoolean>;
+    readonly rpcUrl: z.ZodOptional<z.ZodString>;
+};