@crediolabs/policy-synth 0.1.3 → 0.1.5

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

@@ -0,0 +1,2003 @@
+import { z } from 'zod';
+export declare const NetworkSchema: z.ZodEnum<["mainnet", "testnet"]>;
+export type Network = z.infer<typeof NetworkSchema>;
+/** ScVal subset - normalised subset the synth consumes. Mirrors
+ *  `ScVal` in packages/policy-synth/src/types.ts. */
+export declare const ScValSchema: z.ZodType<unknown>;
+/** ContractInvocation mirrors the core. Annotated with an explicit
+ *  `z.ZodType<unknown>` (like ScValSchema above) so the self-referential
+ *  `subInvocations` field does not trip TS's circular type inference. */
+export declare const ContractInvocationSchema: z.ZodType<unknown>;
+export declare const TokenMovementSchema: 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;
+}>;
+export declare const OnChainEventSchema: 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;
+}>;
+export declare const ParseConfidenceSchema: 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;
+}>;
+/** RecordedTransaction mirrors the core RecordedTransaction. The output shape
+ *  is referenced by name in the tool result structured content; we deliberately
+ *  type it loosely (`z.unknown()`) on the success path so the core remains the
+ *  single source of truth for the wire payload. */
+export declare const RecordedTransactionSchema: 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">>;
+/** MandateSpec mirrors the core MandateSpec. The deterministic Mandate
+ *  front-end needs no parseConfidence; the tool adapter injects the full
+ *  confidence after synthesis so the orchestrator can compare. */
+export declare const MandateSpecSchema: z.ZodObject<{
+    chain: z.ZodLiteral<"stellar">;
+    contract: z.ZodString;
+    method: z.ZodOptional<z.ZodString>;
+    spendingLimit: z.ZodOptional<z.ZodObject<{
+        token: z.ZodString;
+        limit: z.ZodString;
+        windowSeconds: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        token: string;
+        limit: string;
+        windowSeconds: number;
+    }, {
+        token: string;
+        limit: string;
+        windowSeconds: number;
+    }>>;
+    approvalThreshold: z.ZodOptional<z.ZodNumber>;
+    recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    expiry: z.ZodOptional<z.ZodObject<{
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        validUntilLedger?: number | undefined;
+        validUntilUnixSeconds?: number | undefined;
+    }, {
+        validUntilLedger?: number | undefined;
+        validUntilUnixSeconds?: number | undefined;
+    }>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    chain: z.ZodLiteral<"stellar">;
+    contract: z.ZodString;
+    method: z.ZodOptional<z.ZodString>;
+    spendingLimit: z.ZodOptional<z.ZodObject<{
+        token: z.ZodString;
+        limit: z.ZodString;
+        windowSeconds: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        token: string;
+        limit: string;
+        windowSeconds: number;
+    }, {
+        token: string;
+        limit: string;
+        windowSeconds: number;
+    }>>;
+    approvalThreshold: z.ZodOptional<z.ZodNumber>;
+    recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    expiry: z.ZodOptional<z.ZodObject<{
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        validUntilLedger?: number | undefined;
+        validUntilUnixSeconds?: number | undefined;
+    }, {
+        validUntilLedger?: number | undefined;
+        validUntilUnixSeconds?: number | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    chain: z.ZodLiteral<"stellar">;
+    contract: z.ZodString;
+    method: z.ZodOptional<z.ZodString>;
+    spendingLimit: z.ZodOptional<z.ZodObject<{
+        token: z.ZodString;
+        limit: z.ZodString;
+        windowSeconds: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        token: string;
+        limit: string;
+        windowSeconds: number;
+    }, {
+        token: string;
+        limit: string;
+        windowSeconds: number;
+    }>>;
+    approvalThreshold: z.ZodOptional<z.ZodNumber>;
+    recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    expiry: z.ZodOptional<z.ZodObject<{
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        validUntilLedger?: number | undefined;
+        validUntilUnixSeconds?: number | undefined;
+    }, {
+        validUntilLedger?: number | undefined;
+        validUntilUnixSeconds?: number | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">>;
+/** ComposeUserResponses mirrors the core. */
+export declare const ComposeUserResponsesSchema: z.ZodObject<{
+    windowSeconds: z.ZodOptional<z.ZodNumber>;
+    validUntilLedger: z.ZodOptional<z.ZodNumber>;
+    limitAmount: z.ZodOptional<z.ZodString>;
+    invocationLimit: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    windowSeconds: z.ZodOptional<z.ZodNumber>;
+    validUntilLedger: z.ZodOptional<z.ZodNumber>;
+    limitAmount: z.ZodOptional<z.ZodString>;
+    invocationLimit: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    windowSeconds: z.ZodOptional<z.ZodNumber>;
+    validUntilLedger: z.ZodOptional<z.ZodNumber>;
+    limitAmount: z.ZodOptional<z.ZodString>;
+    invocationLimit: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+/** OzAdapterConfig - the per-network OZ built-in instance addresses. */
+export declare const OzAdapterConfigSchema: z.ZodObject<{
+    network: z.ZodEnum<["mainnet", "testnet"]>;
+    instances: z.ZodObject<{
+        spending_limit: z.ZodString;
+        simple_threshold: z.ZodString;
+        weighted_threshold: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        spending_limit: string;
+        simple_threshold: string;
+        weighted_threshold: string;
+    }, {
+        spending_limit: string;
+        simple_threshold: string;
+        weighted_threshold: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    network: "mainnet" | "testnet";
+    instances: {
+        spending_limit: string;
+        simple_threshold: string;
+        weighted_threshold: string;
+    };
+}, {
+    network: "mainnet" | "testnet";
+    instances: {
+        spending_limit: string;
+        simple_threshold: string;
+        weighted_threshold: string;
+    };
+}>;
+export declare const RecordTransactionInputSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    hash: z.ZodOptional<z.ZodString>;
+    xdr: z.ZodOptional<z.ZodString>;
+    network: z.ZodEnum<["mainnet", "testnet"]>;
+    confidenceOverride: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    network: "mainnet" | "testnet";
+    hash?: string | undefined;
+    xdr?: string | undefined;
+    confidenceOverride?: number | undefined;
+}, {
+    network: "mainnet" | "testnet";
+    hash?: string | undefined;
+    xdr?: string | undefined;
+    confidenceOverride?: number | undefined;
+}>, {
+    network: "mainnet" | "testnet";
+    hash?: string | undefined;
+    xdr?: string | undefined;
+    confidenceOverride?: number | undefined;
+}, {
+    network: "mainnet" | "testnet";
+    hash?: string | undefined;
+    xdr?: string | undefined;
+    confidenceOverride?: number | undefined;
+}>, {
+    network: "mainnet" | "testnet";
+    hash?: string | undefined;
+    xdr?: string | undefined;
+    confidenceOverride?: number | undefined;
+}, {
+    network: "mainnet" | "testnet";
+    hash?: string | undefined;
+    xdr?: string | undefined;
+    confidenceOverride?: number | undefined;
+}>;
+export type RecordTransactionInput = z.infer<typeof RecordTransactionInputSchema>;
+export declare const SynthesizePolicyMandateInputSchema: z.ZodObject<{
+    source: z.ZodLiteral<"mandate">;
+    mandate: z.ZodObject<{
+        chain: z.ZodLiteral<"stellar">;
+        contract: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        spendingLimit: z.ZodOptional<z.ZodObject<{
+            token: z.ZodString;
+            limit: z.ZodString;
+            windowSeconds: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }>>;
+        approvalThreshold: z.ZodOptional<z.ZodNumber>;
+        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        expiry: z.ZodOptional<z.ZodObject<{
+            validUntilLedger: z.ZodOptional<z.ZodNumber>;
+            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        chain: z.ZodLiteral<"stellar">;
+        contract: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        spendingLimit: z.ZodOptional<z.ZodObject<{
+            token: z.ZodString;
+            limit: z.ZodString;
+            windowSeconds: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }>>;
+        approvalThreshold: z.ZodOptional<z.ZodNumber>;
+        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        expiry: z.ZodOptional<z.ZodObject<{
+            validUntilLedger: z.ZodOptional<z.ZodNumber>;
+            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        chain: z.ZodLiteral<"stellar">;
+        contract: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        spendingLimit: z.ZodOptional<z.ZodObject<{
+            token: z.ZodString;
+            limit: z.ZodString;
+            windowSeconds: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }>>;
+        approvalThreshold: z.ZodOptional<z.ZodNumber>;
+        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        expiry: z.ZodOptional<z.ZodObject<{
+            validUntilLedger: z.ZodOptional<z.ZodNumber>;
+            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }>>;
+    }, z.ZodTypeAny, "passthrough">>;
+    ozConfig: z.ZodOptional<z.ZodObject<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        instances: z.ZodObject<{
+            spending_limit: z.ZodString;
+            simple_threshold: z.ZodString;
+            weighted_threshold: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        }, {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    }, {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    source: "mandate";
+    mandate: {
+        contract: string;
+        chain: "stellar";
+        expiry?: {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        } | undefined;
+        method?: string | undefined;
+        spendingLimit?: {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        } | undefined;
+        approvalThreshold?: number | undefined;
+        recipients?: string[] | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    ozConfig?: {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    } | undefined;
+}, {
+    source: "mandate";
+    mandate: {
+        contract: string;
+        chain: "stellar";
+        expiry?: {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        } | undefined;
+        method?: string | undefined;
+        spendingLimit?: {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        } | undefined;
+        approvalThreshold?: number | undefined;
+        recipients?: string[] | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    ozConfig?: {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    } | undefined;
+}>;
+/** Interpreter opt-in for the recording path. Present -> constraints OZ cannot
+ *  express (per-method scoping, invocation-count windows, oracle bounds, exact
+ *  hop paths) lower to a real interpreter predicate document instead of being
+ *  surfaced as warnings. The core deep-validates `smartAccountAddress` (a C...
+ *  contract, not the recording's G... source) and the tighten-only oracle
+ *  bounds; the schema stays light so the core owns the friendly ToolErrors. */
+export declare const InterpreterOptionsSchema: z.ZodObject<{
+    smartAccountAddress: z.ZodString;
+    installNonce: z.ZodOptional<z.ZodNumber>;
+    oracleParams: z.ZodOptional<z.ZodObject<{
+        maxStalenessSeconds: z.ZodOptional<z.ZodNumber>;
+        maxDeviationBps: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxStalenessSeconds?: number | undefined;
+        maxDeviationBps?: number | undefined;
+    }, {
+        maxStalenessSeconds?: number | undefined;
+        maxDeviationBps?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    smartAccountAddress: string;
+    oracleParams?: {
+        maxStalenessSeconds?: number | undefined;
+        maxDeviationBps?: number | undefined;
+    } | undefined;
+    installNonce?: number | undefined;
+}, {
+    smartAccountAddress: string;
+    oracleParams?: {
+        maxStalenessSeconds?: number | undefined;
+        maxDeviationBps?: number | undefined;
+    } | undefined;
+    installNonce?: number | undefined;
+}>;
+export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
+    source: z.ZodLiteral<"recording">;
+    recordedTx: 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">>;
+    network: z.ZodEnum<["mainnet", "testnet"]>;
+    userResponses: z.ZodOptional<z.ZodObject<{
+        windowSeconds: z.ZodOptional<z.ZodNumber>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        invocationLimit: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        windowSeconds: z.ZodOptional<z.ZodNumber>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        invocationLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        windowSeconds: z.ZodOptional<z.ZodNumber>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        invocationLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    confidenceOverride: z.ZodOptional<z.ZodObject<{
+        threshold: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        threshold: number;
+    }, {
+        threshold: number;
+    }>>;
+    interpreter: z.ZodOptional<z.ZodObject<{
+        smartAccountAddress: z.ZodString;
+        installNonce: z.ZodOptional<z.ZodNumber>;
+        oracleParams: z.ZodOptional<z.ZodObject<{
+            maxStalenessSeconds: z.ZodOptional<z.ZodNumber>;
+            maxDeviationBps: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        }, {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        smartAccountAddress: string;
+        oracleParams?: {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        } | undefined;
+        installNonce?: number | undefined;
+    }, {
+        smartAccountAddress: string;
+        oracleParams?: {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        } | undefined;
+        installNonce?: number | undefined;
+    }>>;
+    ozConfig: z.ZodOptional<z.ZodObject<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        instances: z.ZodObject<{
+            spending_limit: z.ZodString;
+            simple_threshold: z.ZodString;
+            weighted_threshold: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        }, {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    }, {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    network: "mainnet" | "testnet";
+    source: "recording";
+    recordedTx: {
+        events: {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }[];
+        network: "mainnet" | "testnet";
+        signers: string[];
+        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;
+        };
+        sourceAccount: string;
+    } & {
+        [k: string]: unknown;
+    };
+    interpreter?: {
+        smartAccountAddress: string;
+        oracleParams?: {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        } | undefined;
+        installNonce?: number | undefined;
+    } | undefined;
+    userResponses?: z.objectOutputType<{
+        windowSeconds: z.ZodOptional<z.ZodNumber>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        invocationLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    confidenceOverride?: {
+        threshold: number;
+    } | undefined;
+    ozConfig?: {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    } | undefined;
+}, {
+    network: "mainnet" | "testnet";
+    source: "recording";
+    recordedTx: {
+        events: {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }[];
+        network: "mainnet" | "testnet";
+        signers: string[];
+        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;
+        };
+        sourceAccount: string;
+    } & {
+        [k: string]: unknown;
+    };
+    interpreter?: {
+        smartAccountAddress: string;
+        oracleParams?: {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        } | undefined;
+        installNonce?: number | undefined;
+    } | undefined;
+    userResponses?: z.objectInputType<{
+        windowSeconds: z.ZodOptional<z.ZodNumber>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        invocationLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    confidenceOverride?: {
+        threshold: number;
+    } | undefined;
+    ozConfig?: {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    } | undefined;
+}>;
+export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"source", [z.ZodObject<{
+    source: z.ZodLiteral<"mandate">;
+    mandate: z.ZodObject<{
+        chain: z.ZodLiteral<"stellar">;
+        contract: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        spendingLimit: z.ZodOptional<z.ZodObject<{
+            token: z.ZodString;
+            limit: z.ZodString;
+            windowSeconds: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }>>;
+        approvalThreshold: z.ZodOptional<z.ZodNumber>;
+        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        expiry: z.ZodOptional<z.ZodObject<{
+            validUntilLedger: z.ZodOptional<z.ZodNumber>;
+            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        chain: z.ZodLiteral<"stellar">;
+        contract: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        spendingLimit: z.ZodOptional<z.ZodObject<{
+            token: z.ZodString;
+            limit: z.ZodString;
+            windowSeconds: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }>>;
+        approvalThreshold: z.ZodOptional<z.ZodNumber>;
+        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        expiry: z.ZodOptional<z.ZodObject<{
+            validUntilLedger: z.ZodOptional<z.ZodNumber>;
+            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        chain: z.ZodLiteral<"stellar">;
+        contract: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        spendingLimit: z.ZodOptional<z.ZodObject<{
+            token: z.ZodString;
+            limit: z.ZodString;
+            windowSeconds: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }, {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        }>>;
+        approvalThreshold: z.ZodOptional<z.ZodNumber>;
+        recipients: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        expiry: z.ZodOptional<z.ZodObject<{
+            validUntilLedger: z.ZodOptional<z.ZodNumber>;
+            validUntilUnixSeconds: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }, {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        }>>;
+    }, z.ZodTypeAny, "passthrough">>;
+    ozConfig: z.ZodOptional<z.ZodObject<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        instances: z.ZodObject<{
+            spending_limit: z.ZodString;
+            simple_threshold: z.ZodString;
+            weighted_threshold: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        }, {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    }, {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    source: "mandate";
+    mandate: {
+        contract: string;
+        chain: "stellar";
+        expiry?: {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        } | undefined;
+        method?: string | undefined;
+        spendingLimit?: {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        } | undefined;
+        approvalThreshold?: number | undefined;
+        recipients?: string[] | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    ozConfig?: {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    } | undefined;
+}, {
+    source: "mandate";
+    mandate: {
+        contract: string;
+        chain: "stellar";
+        expiry?: {
+            validUntilLedger?: number | undefined;
+            validUntilUnixSeconds?: number | undefined;
+        } | undefined;
+        method?: string | undefined;
+        spendingLimit?: {
+            token: string;
+            limit: string;
+            windowSeconds: number;
+        } | undefined;
+        approvalThreshold?: number | undefined;
+        recipients?: string[] | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    ozConfig?: {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    } | undefined;
+}>, z.ZodObject<{
+    source: z.ZodLiteral<"recording">;
+    recordedTx: 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">>;
+    network: z.ZodEnum<["mainnet", "testnet"]>;
+    userResponses: z.ZodOptional<z.ZodObject<{
+        windowSeconds: z.ZodOptional<z.ZodNumber>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        invocationLimit: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        windowSeconds: z.ZodOptional<z.ZodNumber>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        invocationLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        windowSeconds: z.ZodOptional<z.ZodNumber>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        invocationLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    confidenceOverride: z.ZodOptional<z.ZodObject<{
+        threshold: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        threshold: number;
+    }, {
+        threshold: number;
+    }>>;
+    interpreter: z.ZodOptional<z.ZodObject<{
+        smartAccountAddress: z.ZodString;
+        installNonce: z.ZodOptional<z.ZodNumber>;
+        oracleParams: z.ZodOptional<z.ZodObject<{
+            maxStalenessSeconds: z.ZodOptional<z.ZodNumber>;
+            maxDeviationBps: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        }, {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        smartAccountAddress: string;
+        oracleParams?: {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        } | undefined;
+        installNonce?: number | undefined;
+    }, {
+        smartAccountAddress: string;
+        oracleParams?: {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        } | undefined;
+        installNonce?: number | undefined;
+    }>>;
+    ozConfig: z.ZodOptional<z.ZodObject<{
+        network: z.ZodEnum<["mainnet", "testnet"]>;
+        instances: z.ZodObject<{
+            spending_limit: z.ZodString;
+            simple_threshold: z.ZodString;
+            weighted_threshold: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        }, {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    }, {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    network: "mainnet" | "testnet";
+    source: "recording";
+    recordedTx: {
+        events: {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }[];
+        network: "mainnet" | "testnet";
+        signers: string[];
+        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;
+        };
+        sourceAccount: string;
+    } & {
+        [k: string]: unknown;
+    };
+    interpreter?: {
+        smartAccountAddress: string;
+        oracleParams?: {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        } | undefined;
+        installNonce?: number | undefined;
+    } | undefined;
+    userResponses?: z.objectOutputType<{
+        windowSeconds: z.ZodOptional<z.ZodNumber>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        invocationLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    confidenceOverride?: {
+        threshold: number;
+    } | undefined;
+    ozConfig?: {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    } | undefined;
+}, {
+    network: "mainnet" | "testnet";
+    source: "recording";
+    recordedTx: {
+        events: {
+            contract: string;
+            topics: string[];
+            data?: unknown;
+        }[];
+        network: "mainnet" | "testnet";
+        signers: string[];
+        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;
+        };
+        sourceAccount: string;
+    } & {
+        [k: string]: unknown;
+    };
+    interpreter?: {
+        smartAccountAddress: string;
+        oracleParams?: {
+            maxStalenessSeconds?: number | undefined;
+            maxDeviationBps?: number | undefined;
+        } | undefined;
+        installNonce?: number | undefined;
+    } | undefined;
+    userResponses?: z.objectInputType<{
+        windowSeconds: z.ZodOptional<z.ZodNumber>;
+        validUntilLedger: z.ZodOptional<z.ZodNumber>;
+        limitAmount: z.ZodOptional<z.ZodString>;
+        invocationLimit: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    confidenceOverride?: {
+        threshold: number;
+    } | undefined;
+    ozConfig?: {
+        network: "mainnet" | "testnet";
+        instances: {
+            spending_limit: string;
+            simple_threshold: string;
+            weighted_threshold: string;
+        };
+    } | undefined;
+}>]>;
+export type SynthesizePolicyInput = z.infer<typeof SynthesizePolicyInputSchema>;
+export declare const ToolErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "error", "fatal"]>;
+    retryable: z.ZodBoolean;
+    remediation: z.ZodOptional<z.ZodObject<{
+        toolCall: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            args: Record<string, unknown>;
+            name: string;
+        }, {
+            args: Record<string, unknown>;
+            name: string;
+        }>>;
+        userQuestion: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            question: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            question: string;
+        }, {
+            code: string;
+            question: string;
+        }>>;
+        docsUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        toolCall?: {
+            args: Record<string, unknown>;
+            name: string;
+        } | undefined;
+        userQuestion?: {
+            code: string;
+            question: string;
+        } | undefined;
+        docsUrl?: string | undefined;
+    }, {
+        toolCall?: {
+            args: Record<string, unknown>;
+            name: string;
+        } | undefined;
+        userQuestion?: {
+            code: string;
+            question: string;
+        } | undefined;
+        docsUrl?: string | undefined;
+    }>>;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    code: z.ZodString;
+    message: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "error", "fatal"]>;
+    retryable: z.ZodBoolean;
+    remediation: z.ZodOptional<z.ZodObject<{
+        toolCall: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            args: Record<string, unknown>;
+            name: string;
+        }, {
+            args: Record<string, unknown>;
+            name: string;
+        }>>;
+        userQuestion: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            question: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            question: string;
+        }, {
+            code: string;
+            question: string;
+        }>>;
+        docsUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        toolCall?: {
+            args: Record<string, unknown>;
+            name: string;
+        } | undefined;
+        userQuestion?: {
+            code: string;
+            question: string;
+        } | undefined;
+        docsUrl?: string | undefined;
+    }, {
+        toolCall?: {
+            args: Record<string, unknown>;
+            name: string;
+        } | undefined;
+        userQuestion?: {
+            code: string;
+            question: string;
+        } | undefined;
+        docsUrl?: string | undefined;
+    }>>;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    code: z.ZodString;
+    message: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "error", "fatal"]>;
+    retryable: z.ZodBoolean;
+    remediation: z.ZodOptional<z.ZodObject<{
+        toolCall: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            args: Record<string, unknown>;
+            name: string;
+        }, {
+            args: Record<string, unknown>;
+            name: string;
+        }>>;
+        userQuestion: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            question: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            question: string;
+        }, {
+            code: string;
+            question: string;
+        }>>;
+        docsUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        toolCall?: {
+            args: Record<string, unknown>;
+            name: string;
+        } | undefined;
+        userQuestion?: {
+            code: string;
+            question: string;
+        } | undefined;
+        docsUrl?: string | undefined;
+    }, {
+        toolCall?: {
+            args: Record<string, unknown>;
+            name: string;
+        } | undefined;
+        userQuestion?: {
+            code: string;
+            question: string;
+        } | undefined;
+        docsUrl?: string | undefined;
+    }>>;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, z.ZodTypeAny, "passthrough">>;