@crediolabs/policy-synth 0.1.17 → 0.2.0

package/dist/run/schemas.d.ts

@@ -352,7 +352,7 @@ export declare const RecordedTransactionSchema: z.ZodObject<{
 /** 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<{
+export declare const MandateSpecSchema: z.ZodEffects<z.ZodObject<{
     chain: z.ZodLiteral<"stellar">;
     contract: z.ZodString;
     method: z.ZodOptional<z.ZodString>;
@@ -439,6 +439,64 @@ export declare const MandateSpecSchema: z.ZodObject<{
         validUntilLedger?: number | undefined;
         validUntilUnixSeconds?: number | undefined;
     }>>;
+}, z.ZodTypeAny, "passthrough">>, 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<{
@@ -447,18 +505,66 @@ export declare const ComposeUserResponsesSchema: z.ZodObject<{
     limitAmount: z.ZodOptional<z.ZodString>;
     invocationLimit: z.ZodOptional<z.ZodNumber>;
     swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        asset: z.ZodEffects<z.ZodString, string, string>;
+        operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+        value: z.ZodString;
+        decimals: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        operator: "eq" | "lt" | "lte" | "gt" | "gte";
+        asset: string;
+        decimals: number;
+    }, {
+        value: string;
+        operator: "eq" | "lt" | "lte" | "gt" | "gte";
+        asset: string;
+        decimals: number;
+    }>, "many">>;
 }, "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>;
     swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        asset: z.ZodEffects<z.ZodString, string, string>;
+        operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+        value: z.ZodString;
+        decimals: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        operator: "eq" | "lt" | "lte" | "gt" | "gte";
+        asset: string;
+        decimals: number;
+    }, {
+        value: string;
+        operator: "eq" | "lt" | "lte" | "gt" | "gte";
+        asset: string;
+        decimals: number;
+    }>, "many">>;
 }, 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>;
     swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        asset: z.ZodEffects<z.ZodString, string, string>;
+        operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+        value: z.ZodString;
+        decimals: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        operator: "eq" | "lt" | "lte" | "gt" | "gte";
+        asset: string;
+        decimals: number;
+    }, {
+        value: string;
+        operator: "eq" | "lt" | "lte" | "gt" | "gte";
+        asset: string;
+        decimals: number;
+    }>, "many">>;
 }, z.ZodTypeAny, "passthrough">>;
 /** OzAdapterConfig - the per-network OZ built-in instance addresses. */
 export declare const OzAdapterConfigSchema: z.ZodObject<{
@@ -530,7 +636,7 @@ export declare const RecordTransactionInputSchema: z.ZodEffects<z.ZodEffects<z.Z
 export type RecordTransactionInput = z.infer<typeof RecordTransactionInputSchema>;
 export declare const SynthesizePolicyMandateInputSchema: z.ZodObject<{
     source: z.ZodLiteral<"mandate">;
-    mandate: z.ZodObject<{
+    mandate: z.ZodEffects<z.ZodObject<{
         chain: z.ZodLiteral<"stellar">;
         contract: z.ZodString;
         method: z.ZodOptional<z.ZodString>;
@@ -617,6 +723,64 @@ export declare const SynthesizePolicyMandateInputSchema: z.ZodObject<{
             validUntilLedger?: number | undefined;
             validUntilUnixSeconds?: number | undefined;
         }>>;
+    }, z.ZodTypeAny, "passthrough">>, 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"]>;
@@ -1010,18 +1174,66 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
         limitAmount: z.ZodOptional<z.ZodString>;
         invocationLimit: z.ZodOptional<z.ZodNumber>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            asset: z.ZodEffects<z.ZodString, string, string>;
+            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+            value: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }>, "many">>;
     }, "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>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            asset: z.ZodEffects<z.ZodString, string, string>;
+            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+            value: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }>, "many">>;
     }, 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>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            asset: z.ZodEffects<z.ZodString, string, string>;
+            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+            value: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }>, "many">>;
     }, z.ZodTypeAny, "passthrough">>>;
     confidenceOverride: z.ZodOptional<z.ZodObject<{
         threshold: z.ZodNumber;
@@ -1141,6 +1353,22 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
         limitAmount: z.ZodOptional<z.ZodString>;
         invocationLimit: z.ZodOptional<z.ZodNumber>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            asset: z.ZodEffects<z.ZodString, string, string>;
+            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+            value: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }>, "many">>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
     confidenceOverride?: {
         threshold: number;
@@ -1206,6 +1434,22 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
         limitAmount: z.ZodOptional<z.ZodString>;
         invocationLimit: z.ZodOptional<z.ZodNumber>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            asset: z.ZodEffects<z.ZodString, string, string>;
+            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+            value: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }>, "many">>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
     confidenceOverride?: {
         threshold: number;
@@ -1222,7 +1466,7 @@ export declare const SynthesizePolicyRecordingInputSchema: z.ZodObject<{
 }>;
 export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"source", [z.ZodObject<{
     source: z.ZodLiteral<"mandate">;
-    mandate: z.ZodObject<{
+    mandate: z.ZodEffects<z.ZodObject<{
         chain: z.ZodLiteral<"stellar">;
         contract: z.ZodString;
         method: z.ZodOptional<z.ZodString>;
@@ -1309,6 +1553,64 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
             validUntilLedger?: number | undefined;
             validUntilUnixSeconds?: number | undefined;
         }>>;
+    }, z.ZodTypeAny, "passthrough">>, 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"]>;
@@ -1667,18 +1969,66 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
         limitAmount: z.ZodOptional<z.ZodString>;
         invocationLimit: z.ZodOptional<z.ZodNumber>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            asset: z.ZodEffects<z.ZodString, string, string>;
+            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+            value: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }>, "many">>;
     }, "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>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            asset: z.ZodEffects<z.ZodString, string, string>;
+            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+            value: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }>, "many">>;
     }, 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>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            asset: z.ZodEffects<z.ZodString, string, string>;
+            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+            value: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }>, "many">>;
     }, z.ZodTypeAny, "passthrough">>>;
     confidenceOverride: z.ZodOptional<z.ZodObject<{
         threshold: z.ZodNumber;
@@ -1798,6 +2148,22 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
         limitAmount: z.ZodOptional<z.ZodString>;
         invocationLimit: z.ZodOptional<z.ZodNumber>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            asset: z.ZodEffects<z.ZodString, string, string>;
+            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+            value: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }>, "many">>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
     confidenceOverride?: {
         threshold: number;
@@ -1863,6 +2229,22 @@ export declare const SynthesizePolicyInputSchema: z.ZodDiscriminatedUnion<"sourc
         limitAmount: z.ZodOptional<z.ZodString>;
         invocationLimit: z.ZodOptional<z.ZodNumber>;
         swapRecipientAllowlist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+        oraclePriceBound: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            asset: z.ZodEffects<z.ZodString, string, string>;
+            operator: z.ZodEnum<["eq", "lt", "lte", "gt", "gte"]>;
+            value: z.ZodString;
+            decimals: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }, {
+            value: string;
+            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+            asset: string;
+            decimals: number;
+        }>, "many">>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
     confidenceOverride?: {
         threshold: number;
@@ -2641,20 +3023,28 @@ export declare const VerifyPolicyInputSchema: z.ZodObject<{
     }> | undefined;
 }>;
 export type VerifyPolicyInput = z.infer<typeof VerifyPolicyInputSchema>;
-/** Pinned interpreter address (testnet). Mirrors DEPLOYMENTS.md:128.
+/** Pinned interpreter address (testnet).
  *  Single source for the MCP layer; do not embed elsewhere. */
-export declare const PINNED_INTERPRETER_TESTNET_ADDRESS = "CDR4NLV22STCXFGZPNKDQTEANWLF7LZ6AJLY6B7CLJXKHDZGYJWIOKGP";
-/** Pinned interpreter address (mainnet). Mirrors DEPLOYMENTS.md:18. Mainnet
- *  has now been deployed (2026-08-04); the mainnet interpreter IS the binary
- *  that was exercised on testnet (same wasm sha256, see
- *  PINNED_INTERPRETER_WASM_SHA256). The address differs because instance
- *  ids are network-scoped. UNAUDITED at the time of writing - see
- *  DEPLOYMENTS.md:29-32 for the recorded decision and what is still pending. */
+export declare const PINNED_INTERPRETER_TESTNET_ADDRESS = "CALHNU4LXZRKFAXYRBODTGDANTNXHJPBTJNYGLUWLIFIP24NWSGWIE4K";
+/** Pinned interpreter address (mainnet), deployed 2026-08-04.
+ *  UNAUDITED at the time of writing. */
 export declare const PINNED_INTERPRETER_MAINNET_ADDRESS = "CALZAMUPREIRY4TULBEXIK77AUTOEJG63XLCPUWEHHQDOVK6ZVVS7VQ2";
-/** Pinned interpreter wasm sha256 (hex). Mirrors DEPLOYMENTS.md:156-157. */
+/** Pinned interpreter wasm sha256 (hex), mainnet.
+ *
+ *  The two networks no longer run the same binary. Testnet carries the
+ *  selector-leaf minimum and the signer-set cap; mainnet predates both. Read
+ *  the hash through `PINNED_INTERPRETER_WASM_SHA256_BY_NETWORK` rather than
+ *  this constant unless mainnet is specifically what is meant, or
+ *  `get_interpreter_info` will report a hash the queried network does not
+ *  run. */
 export declare const PINNED_INTERPRETER_WASM_SHA256 = "6e6c13d93e197aa380303a42cd120f5ddb080dd36ef2a343ee1dbd04ca52a443";
+/** Pinned interpreter wasm sha256 (hex), testnet. Byte-identical to the
+ *  artifact built from `contracts/policy-interpreter` at the commit that
+ *  introduced errors 216 and 217, verified by fetching the deployed wasm back
+ *  off chain. */
+export declare const PINNED_INTERPRETER_WASM_SHA256_TESTNET = "a4d58bc88fd82bbb8e223941ba5889db919717fae92ced13f6f55bfe583b8e22";
 /** The grammar version the interpreter enforces (matches SELF_VERSION in
- *  packages/policy-interpreter/src/version.rs). */
+ *  contracts/policy-interpreter/src/version.rs). */
 export declare const PINNED_INTERPRETER_GRAMMAR_VERSION = 1;
 /** Default Soroban RPC for the install / revoke / info tools. The recorder
  *  keeps its own copy in record/rpc.ts because it hands back a fetcher rather
@@ -2666,11 +3056,12 @@ export declare const TESTNET_RPC_URL = "https://soroban-testnet.stellar.org";
  *  RPC rather than always testnet. Public mainnet endpoint, the same one
  *  the deploy script hit during the 2026-08-04 mainnet rollout. */
 export declare const MAINNET_RPC_URL = "https://mainnet.sorobanrpc.com";
-/** Pin + RPC lookup for the gate enforcement. The interpreters' wasm sha256
- *  is identical across both networks (the same binary was uploaded both
- *  places; DEPLOYMENTS.md:25-27), so `PINNED_INTERPRETER_WASM_SHA256` stays
- *  a single constant - only the addresses and RPCs are network-scoped. */
+/** Pin + RPC lookup for the gate enforcement. Addresses, RPCs and wasm
+ *  hashes are all network-scoped: the networks diverged when the
+ *  selector-leaf and signer-cap controls were deployed to testnet ahead of
+ *  mainnet. */
 export declare const PINNED_INTERPRETER_ADDRESS_BY_NETWORK: Record<Network, string>;
+export declare const PINNED_INTERPRETER_WASM_SHA256_BY_NETWORK: Record<Network, string>;
 export declare const RPC_URL_BY_NETWORK: Record<Network, string>;
 /** Soroban `valid_until` window (ledgers) added to the latest ledger when
  *  building the auth entry. ~25 minutes at 5s/ledger. */
@@ -3164,6 +3555,17 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
      *  everything. Selecting `network: 'mainnet'` is NOT an opt-in -
      *  the mainnet pin is its own deny-by-default anchor. */
     allowUnpinnedInterpreter: z.ZodOptional<z.ZodBoolean>;
+    /** Opt-in to installing when a signer of this rule can already reach the
+     *  same calls through a context rule that has NO policy attached. OZ lets
+     *  the signer choose which rule authorises a call and enforces only that
+     *  rule's policies, so an unpoliced rule covering the same calls makes
+     *  this policy decorative. Default-deny, because the caller almost
+     *  certainly believes they are restricting something. */
+    allowAuthorityOverlap: z.ZodOptional<z.ZodBoolean>;
+    /** Skip the cross-rule authority scan entirely. The scan costs one RPC
+     *  read per rule on the account; skipping it means the response carries
+     *  no statement about what the signers can already do. */
+    skipAuthorityScan: z.ZodOptional<z.ZodBoolean>;
     /** Base fee in stroops; defaults to BASE_FEE (100). */
     baseFee: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
@@ -3209,6 +3611,8 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
+    allowAuthorityOverlap?: boolean | undefined;
+    skipAuthorityScan?: boolean | undefined;
     baseFee?: number | undefined;
 }, {
     installNonce: number;
@@ -3253,6 +3657,8 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
+    allowAuthorityOverlap?: boolean | undefined;
+    skipAuthorityScan?: boolean | undefined;
     baseFee?: number | undefined;
 }>, {
     installNonce: number;
@@ -3297,6 +3703,8 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
+    allowAuthorityOverlap?: boolean | undefined;
+    skipAuthorityScan?: boolean | undefined;
     baseFee?: number | undefined;
 }, {
     installNonce: number;
@@ -3341,9 +3749,53 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
+    allowAuthorityOverlap?: boolean | undefined;
+    skipAuthorityScan?: boolean | undefined;
     baseFee?: number | undefined;
 }>;
 export type InstallPolicyInput = z.infer<typeof InstallPolicyInputSchema>;
+/** `merge_policy` input.
+ *
+ *  The tightening remedy for a cross-rule overlap: replace a rule's predicate
+ *  with the conjunction of it and a new one. Two transactions, in order,
+ *  because OZ refuses to re-attach a policy already on the rule - so the
+ *  caller runs `detach`, waits for it to confirm, then runs `reinstall`. */
+export declare const MergePolicyInputSchema: z.ZodObject<{
+    smartAccount: z.ZodString;
+    sourceAccount: z.ZodString;
+    /** The rule whose predicate is being tightened. */
+    ruleId: z.ZodNumber;
+    /** The predicate to conjoin, base64 canonical ScVal, as emitted by
+     *  `synthesize_policy`. */
+    incomingPredicateBlobBase64: z.ZodString;
+    /** Which half of the remedy to build. */
+    step: z.ZodEnum<["detach", "reinstall"]>;
+    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
+    rpcUrl: z.ZodOptional<z.ZodString>;
+    allowUnpinnedRpcUrl: z.ZodOptional<z.ZodBoolean>;
+    baseFee: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    smartAccount: string;
+    sourceAccount: string;
+    step: "detach" | "reinstall";
+    ruleId: number;
+    incomingPredicateBlobBase64: string;
+    network?: "mainnet" | "testnet" | undefined;
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    baseFee?: number | undefined;
+}, {
+    smartAccount: string;
+    sourceAccount: string;
+    step: "detach" | "reinstall";
+    ruleId: number;
+    incomingPredicateBlobBase64: string;
+    network?: "mainnet" | "testnet" | undefined;
+    rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
+    baseFee?: number | undefined;
+}>;
+export type MergePolicyInput = z.infer<typeof MergePolicyInputSchema>;
 export declare const RevokePolicyInputSchema: z.ZodEffects<z.ZodObject<{
     /** The smart account contract address (C...). */
     smartAccount: z.ZodString;
@@ -3403,15 +3855,24 @@ export declare const GetInterpreterInfoInputSchema: z.ZodObject<{
     /** When true, perform an optional live `grammar_version()` RPC call to
      *  verify the deployed contract matches the pin. */
     verifyLive: z.ZodOptional<z.ZodBoolean>;
-    /** Optional RPC URL override. */
+    /** Optional RPC URL override. When `verifyLive` is true, the URL must
+     *  equal the pinned RPC for the selected network unless
+     *  `allowUnpinnedRpcUrl: true` is also set (same opt-in shape as
+     *  install/revoke - the live grammar_version() answer binds to whichever
+     *  RPC returned it). */
     rpcUrl: z.ZodOptional<z.ZodString>;
+    /** Opt-in to using a non-pinned RPC URL when `verifyLive` is true. Same
+     *  semantics as install/revoke: the caller accepts the trust shift. */
+    allowUnpinnedRpcUrl: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     network?: "mainnet" | "testnet" | undefined;
     rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
     verifyLive?: boolean | undefined;
 }, {
     network?: "mainnet" | "testnet" | undefined;
     rpcUrl?: string | undefined;
+    allowUnpinnedRpcUrl?: boolean | undefined;
     verifyLive?: boolean | undefined;
 }>;
 export type GetInterpreterInfoInput = z.infer<typeof GetInterpreterInfoInputSchema>;